Skip to content

j-mauro-r/SAT-Dengue-V2 / .agents/skills/deepworkplan

deepworkplan

Verified

DeepWorkPlan — turn any repo AI-first and run Deep Work Plans. Routes to create, execute, refine, resume, status, verify, upgrade, and repo-onboarding sub-skills based on intent. Use when the developer wants to plan, execute, manage, or verify structured multi-task work, or make a repository AI-agent-ready.

FileKindSize
SKILL.mdskill md12.0 KB
TRUST.mdmarkdown16.1 KB
addons/README.mdmarkdown11.7 KB
addons/machine-installs.mdmarkdown2.9 KB
examples/CREATE_PLAN.mdmarkdown6.9 KB
examples/ORCHESTRATOR_TASK_TEMPLATE_create_child_dwp.mdmarkdown15.0 KB
examples/ORCHESTRATOR_TASK_TEMPLATE_execute_child_dwp.mdmarkdown16.7 KB
examples/ORCHESTRATOR_TASK_TEMPLATE_integration_checkpoint.mdmarkdown9.0 KB
examples/PROMPTS_TEMPLATE.mdmarkdown4.0 KB
examples/TEAM_AGENTS_TASK_TEMPLATE.mdmarkdown5.1 KB
examples/V6_PLAN_EXAMPLE.mdmarkdown5.5 KB
guide/GUIDE.mdmarkdown8.0 KB
guide/authoring.mdmarkdown28.5 KB
guide/execution.mdmarkdown21.0 KB
guide/large-repo-onboarding.mdmarkdown3.3 KB
guide/orchestration-at-scale.mdmarkdown11.4 KB
guide/orchestrator.mdmarkdown37.9 KB
guide/prompts.mdmarkdown10.1 KB
guide/skills-integration.mdmarkdown6.5 KB
guide/structure.mdmarkdown6.2 KB
guide/swarm.mdmarkdown21.2 KB
guide/team-agents.mdmarkdown12.3 KB
shared/adaptation.mdmarkdown2.7 KB
shared/addon_sync.pyscript17.7 KB
shared/benchmark.pyscript97.6 KB
shared/config.pyscript41.5 KB
shared/context.shscript4.2 KB
shared/context_manifest.pyscript40.8 KB
shared/contract_v6.pyscript82.7 KB
shared/delegators.pyscript3.0 KB
shared/dwp-paths.mdmarkdown5.8 KB
shared/finalize_plan.pyscript7.2 KB
shared/install-verification.mdmarkdown1.8 KB
shared/ledger.pyscript141.5 KB
shared/migrate_v6.pyscript46.5 KB
shared/outcomes.pyscript27.2 KB
shared/plan_paths.pyscript4.8 KB
shared/resources.pyscript49.0 KB
shared/scheduler.pyscript41.6 KB
shared/state_contract.pyscript9.8 KB
shared/swarm.pyscript27.3 KB
shared/troubleshooting.mdmarkdown7.4 KB
shared/update-state.pyscript12.5 KB
shared/views.pyscript21.0 KB
shared/working-principles.mdmarkdown7.1 KB
spec/ADDONS.mdmarkdown27.4 KB
spec/AGENT_PROTOCOL.mdmarkdown28.0 KB
spec/ARCHETYPES.mdmarkdown10.6 KB
spec/BENCHMARK.mdmarkdown20.3 KB
spec/CONFIG.mdmarkdown8.7 KB
spec/DOCUMENTATION_STANDARD.mdmarkdown40.7 KB
spec/DWP_SPECIFICATION.mdmarkdown65.1 KB
spec/LITE_PLANS.mdmarkdown4.0 KB
spec/PLAN_STATE.mdmarkdown34.9 KB
spec/README.mdmarkdown11.5 KB
spec/V6_CONTEXT.mdmarkdown6.4 KB
spec/V6_CONTRACT.mdmarkdown12.3 KB
spec/V6_LIFECYCLE.mdmarkdown13.5 KB
spec/V6_RESOURCES.mdmarkdown4.7 KB
spec/V7_ABILITIES.mdmarkdown4.9 KB
spec/V7_CONTRACT.mdmarkdown6.4 KB
spec/V7_ROADMAP.mdmarkdown4.6 KB
spec/schema/addon-descriptor-v1.schema.jsonconfig5.5 KB
spec/schema/benchmark-record.schema.jsonconfig14.0 KB
spec/schema/context-manifest-v6.schema.jsonconfig12.5 KB
spec/schema/dwp-config-v1.schema.jsonconfig3.5 KB
spec/schema/dwp-handoff-v1.schema.jsonconfig3.0 KB
spec/schema/journal-event-v6.schema.jsonconfig22.3 KB
spec/schema/journal-event-v7.schema.jsonconfig24.9 KB
spec/schema/learnings-record.schema.jsonconfig6.0 KB
spec/schema/plan-contract-v6.schema.jsonconfig16.4 KB
spec/schema/plan-contract-v7.schema.jsonconfig16.6 KB
spec/schema/plan-manifest-v2.schema.jsonconfig1.0 KB
spec/schema/plan-manifest-v5.schema.jsonconfig1.3 KB
spec/schema/plan-manifest-v6.schema.jsonconfig2.0 KB
spec/schema/plan-manifest-v7.schema.jsonconfig1.7 KB
spec/schema/plan-manifest.schema.jsonconfig1.8 KB
spec/schema/plan-snapshot-v6.schema.jsonconfig7.8 KB
spec/schema/plan-state-v2.schema.jsonconfig6.4 KB
spec/schema/plan-state-v5.schema.jsonconfig6.7 KB
spec/schema/plan-state.schema.jsonconfig3.7 KB

guide/execution.md

View on GitHub
# DeepWorkPlan Guide — Execution Rules, Commits and Completion Tracking

> Part of the DeepWorkPlan methodology guide. The routing index is
> [`GUIDE.md`](GUIDE.md); read only the guide files your flow names.

## 6. Agent Execution Rules (Critical Behavior)

When an agent is instructed to use this system, it must obey:

1. **Single-task focus**
   - Only work on **one task file** at a time.
   - Ignore other tasks until the current one is fully completed or blocked.

2. **Strict order**
   - Always process the **first unchecked** task in the plan README (`[ ]`).
   - Once completed, mark it `[x]` and move to the next.

3. **Validation required**
   - Never mark a task as completed unless every Validation command in the task file has been **run and passed**. On failure, stop, log, and do not mark `[x]` (`spec/DWP_SPECIFICATION.md` §5.1).
   - For behavior-changing tasks, the validations **must** include the repo's tests and its lint/type-check/format checks **selected from the task's Touched Surface** (falling back to the full suite when the change is shared/core or no scoped invocation is documented), and the task must have added/updated tests for the new behavior (`authoring.md` §5.3). The complete suite runs on the final state in the Final Review.

4. **Logging & commits**
   - Always update the task's log.
   - Always commit work before moving on. Stage the task's touched surface by
     path — never a blanket `git add -A` that sweeps in another agent's work.
     External test data (accounts, records, cloud resources) is created and
     deleted by recorded ID only.
   - **Commit message format** — Include a reference to the plan and task:
     ```
     type(scope): description - Task N of {PLAN_NAME}
     ```
     Examples:
     ```
     feat(api): add notification endpoint - Task 2 of PLAN_001_notification_system
     docs(technical): update architecture guide - Task 3 of PLAN_002_docs_reorganization
     fix(chatbot): resolve timeout in handler - Task 1 of PLAN_003_bug_fixes
     ```

5. **Stop on failure**
   - If a validation fails or something is unclear, stop and log.
   - Do not continue blindly.

6. **Progress reporting** — handled by the **optional** Dailybot addon at [`addons/dailybot/`](../addons/dailybot/SKILL.md) (`spec/ADDONS.md` §2 / §6.2). A repo with **zero optional addons** is fully conformant; Dailybot is **not** part of the DWP baseline (the only declared baseline exception is the AI Diff Reviewer **local** review). Apply the rules below **only when** the Dailybot skill is installed and authorized in the session; otherwise skip silently and never invent an install. Trigger by intent ("report this to Dailybot") or via `/dailybot_report` on Claude Code. Auth is deferred to the Dailybot skill; reporting is never-blocking.

   **Per-task reports (only when Dailybot is installed/authorized; only for individually significant tasks):**
   - After a task that ships a feature, fixes a bug, or completes a major refactor, trigger the skill with a standup-style message — e.g., *"Implemented JWT middleware for the API gateway — all protected routes now validate tokens."*
   - **Skip** intermediate/setup tasks (scaffolding, base classes, config changes) — they'll be covered by the plan completion report when Dailybot is in use.
   - **NEVER use** internal references: *"Completed Task N: {title} - {PLAN_NAME}"* — this is tracking, not a standup update.

   **🔔 Plan completion report (when Dailybot is installed and authorized — golden rule for that channel; never required for DWP conformance):**
   - When ALL tasks in a plan are complete **and** Dailybot is available, send a Dailybot report as a **milestone** with **structured data** (completed/in-progress/blockers) and **metadata** (plan name, repo). If Dailybot is absent or unauthorized, skip — do not block completion.
   - **The message MUST describe what was BUILT, not that a plan ran.** This is the #1 anti-pattern — never send vague reports.
   - **If an Executive Report is requested:** generate it from durable evidence (task logs, PROGRESS.md, `analysis_results/`, the state layer, PR summaries) without replaying the plan. Do not generate it unrequested.

     Examples (the message itself; the skill builds the payload):
     - ✅ GOLD STANDARD: *"Built a full-text search feature for the agents dashboard — users can now search across report content, structured data, metadata, and agent names with real-time highlighted results."* (with structured data listing each deliverable and metadata `{"plan": "PLAN_004_dashboard_search", "repo": "web-app"}`)
     - ❌ NEVER (vague, no detail): *"Completed a deep work plan with multiple tasks executed and validated"*
     - ❌ NEVER (process-focused): *"Plan completed: PLAN_005_auth_refactor - 8 tasks completed successfully"*

   See [`addons/dailybot/templates/INTEGRATION.md`](../addons/dailybot/templates/INTEGRATION.md) for the full pattern when the addon is in use.

   **General rules (when Dailybot reporting runs):**
   - ALWAYS in English, regardless of conversation language
   - If the reporting script fails or times out, **continue without blocking** — progress reporting is secondary to the actual work.
   - See `AGENTS.md` "Agent Progress Reporting" section and the Dailybot skill for the complete standard.

7. **Multi-repository commits** (for plans spanning multiple projects)
   - Commit changes in **each affected repository separately**
   - Push commits immediately after each task completion
   - Never accumulate changes across multiple tasks
   - See section below for detailed multi-project workflow

---

## 6.1. Final Review, Task-Local Skills and the Optional Report

Every DWP plan created under spec 2.3.0 ends with **one** mandatory task, the **Final Review**, automatically added by `/dwp-create`. Two responsibilities that older plans placed in separate closing tasks now live elsewhere: skills decisions happen **inside the task that produced the pattern**, and the Executive Report is **optional**. Plans created under earlier versions still carry three closing tasks (Security Review → Skills & Agents Discovery → Executive Report) and are executed under their own shape — never retrofitted mid-flight (`spec/DWP_SPECIFICATION.md` §6.5).

### Final Review (Last Task)

This task closes the plan, in this order:

**(a) Security pass** — over everything the plan changed, before the plan can complete:

- Reviews the plan's full accumulated diff for hardcoded secrets, injection risks, unsafe input handling, new attack surface, and auth/permission changes
- Audits dependencies the plan introduced or upgraded (best-effort, using the ecosystem's audit tooling where available)
- Verifies `docs/SECURITY.md` still reflects reality and updates it when the plan changed secrets handling, the auth model, or data boundaries
- Writes `analysis_results/SECURITY_REVIEW.md`, even when the conclusion is "no findings"
- A critical finding (e.g. a committed secret) blocks plan completion until fixed or explicitly accepted by the user
- Runs the required AI Diff Reviewer local review against the plan range (`--base <the plan's starting revision>`; `authoring.md` §5.4) and records a `local reviewer not installed` finding when the reviewer is missing; installation belongs to onboarding, while other installed addons that augment the pass run here under their never-block rules
- Runs **before the irreversible step**: any merge, tag or publish the plan performs waits for this review. With the reviewer unavailable, that step stays blocked on the recorded finding until the reviewer runs or the developer explicitly waives it. Methodology, protocol and security-relevant changes also get a reviewer of another vendor or agent where one is available (`spec/DWP_SPECIFICATION.md` §5.1.4)

Security is not a separate workstream bolted on at the end of a project — every plan leaves the repository's security documentation current and its own changes audited.

**(b) Final-state validation** — the repository's complete applicable test, lint, type-check and format suites run and pass on the **final** state (`spec/DWP_SPECIFICATION.md` §5.1.3). In a v6/v7 plan a criterion is observed only under a task whose `gate_intent` declares it: when the review fixes code, re-gate the fixed task (`ledger.py gate --task <that task> --criterion <AC> --no-reuse`), not the review task. Fixes made during the review invalidate affected results, which are rerun: review → fixes and mirror refresh → final gates → closure. Nothing ships after its last applicable validation.

**(c) Skills reconciliation** — checks that every task's log carries a skills disposition and that every entry in `analysis_results/SKILLS_CANDIDATES.md` has one; finishes any warranted authoring still open (and validates it before (b) is final). **Promote load-bearing helpers on second use:** a script a gate or the lead depends on that still lives in scratch space or `analysis_results/` moves into the repository or a skill now; a plan that wrote such helpers and leaves the skills ledger empty fails this step. It does **not** re-read the whole plan to rediscover patterns and writes **no** second discovery report — the ledger is the record.

**(d) Documentation reconciliation** — sweeps every behavior-changing task's reconciled surface against the docs that register it: the gate registry (`docs/TESTING_GUIDE.md`) first, then architecture, module and feature docs, then the `AGENTS.md` index for new top-level surface. Misses are fixed **inside the review** and affected validations rerun; the result lands in `analysis_results/SECURITY_REVIEW.md` as a "Documentation reconciliation" subsection (checked → current, or the fixed list). Bounded to the plan's touched surface — a whole-repo documentation audit belongs to `/dwp-verify`. The plan does not close with an undocumented behavior-changing surface unless the user explicitly accepted the miss.

Documentation is not a follow-up project — the plan closes with every surface it touched still legible in the docs that register it. The step exists because its absence has shipped real misses: a released feature whose new validation gate was never registered in the gate registry.

**Records coherence** — before (e), the README checkboxes, `PROGRESS.md`, `state.json` and any receipt agree with each other and, for a v6/v7 plan, with the journal (`ledger.py project` and `views.py render`, then compare). A disagreement is fixed here, never carried into the completion report. `analysis_results/` stays lean: reports, logs, digests and pointers, never products or dependency trees.

**(e) Completion** — reports deliverables, validation evidence, limitations and PR links; offers the Executive Report **once**; when Dailybot (or another configured reporting channel) is installed and authorized, sends the completion report there (best-effort, never blocking). Absence of Dailybot does not block completion. The plan is complete at this point.

### Task-Local Skills Decisions (Every Task)

The question "did this work create a reusable pattern worth a skill or agent?" is answered **inside each task, while the evidence is in context**:

- Every task's Completion & Log carries a **skills disposition**: `none`, `update <existing>`, `create <name>`, or `defer — <reason and owner>`. `none` needs no ledger row.
- A real candidate is appended to `analysis_results/SKILLS_CANDIDATES.md` with a stable ID (`T{task}-{seq}`), an evidence pointer and the disposition; on resume an existing ID is updated, never duplicated.
- Warranted, in-scope authoring (a new or updated skill/agent plus its catalog entry) happens **in that task, before its validation gate and commit**, after checking the existing `.agents/` catalog for duplicates. Prefer updating an existing capability; a single routine change does not justify a new skill.
- This keeps the virtuous cycle — plans → skills → better plans → better skills — without an end-of-plan re-read (`skills-integration.md` §11).

### Executive Report (Optional, On Request)

`analysis_results/EXECUTIVE_REPORT.md` is generated **only** when the developer asks — at the completion offer, earlier in the plan's guidelines, or at any later time (from durable evidence, without replaying the plan). No answer, a declined offer, or an unattended run leaves the plan complete with no report. When produced it is a comprehensive report written for cross-functional consumption:

- **Executive Summary** — Non-technical overview of what was accomplished
- **Product Impact** — User-facing changes, business value delivered
- **Technical Details** — Architecture decisions, code quality, files changed
- **QA Verification Guide** — Step-by-step guide for verifying changes
- **FAQs** — Common questions about the changes
- **Next Steps** — Recommended follow-up actions

The report adapts its emphasis based on plan type (code, docs, research, refactoring).

---

## 🔄 Multi-Project Commit Workflow

> **CRITICAL for plans that span multiple repositories (repositories/api, repositories/functions, repositories/web-app, repositories/gateway, etc.)**
>
> **For complex multi-repo features**, consider using an **Orchestrator Plan** instead of a direct multi-project plan. Orchestrator plans create child DWP plans in each sub-repository, leveraging each repo's own AGENTS.md and validation commands. See **section 13**.

### When Does This Apply?

This workflow applies when a Deep Work Plan involves changes to **multiple sub-projects** within the Dailybot ecosystem. Each sub-project is its own independent git repository.

### Per-Task Commit Protocol

**After completing EACH task in a multi-project plan:**

1. **Identify affected repositories:**
   ```bash
   # Check which repos have changes (from workspace root)
   cd repositories/api && git status
   cd ../functions && git status
   cd ../web-app && git status
   cd ../gateway && git status
   ```

2. **Run validations in each affected repository:**
   ```bash
   # API Services (from workspace root)
   cd repositories/api && codecheck

   # Chatbot Functions
   cd ../functions && npm run test && npm run eslint:check

   # Web App
   cd ../web-app && npm run test && npm run lint

   # Discord Gateway
   cd ../gateway && npm run test && npm run eslint:check
   ```

3. **Commit and push in each repository:**
   ```bash
   # Template for each repository
   cd {repository}
   git add -- {the task's touched paths}   # never a blanket git add -A
   git commit -m "type(scope): description - Task N of {PLAN_NAME}"
   git push
   ```

4. **Update the plan README** in the core-hub:
   - Mark the task as `[x]` completed
   - Update the Plan Status section
   - Commit plan tracking changes if needed

### Commit Message Format

For multi-project plans, use this format to maintain traceability:

```
type(scope): description - Task N of {PLAN_NAME}

[Optional details]

Refs: Related commits in other repos (if applicable)
```

**Examples:**
```
feat(api): add notification preferences endpoint - Task 2 of PLAN_001_notification_system
feat(chatbot): implement notification dispatcher - Task 2 of PLAN_001_notification_system
feat(web): add notification settings UI - Task 3 of PLAN_001_notification_system
```

### Why Commit After Each Task?

| Benefit | Description |
|---------|-------------|
| **Recoverability** | If session is interrupted, all completed work is safely committed |
| **Traceability** | Each task has its own commit, easy to track or rollback |
| **Resume capability** | Plan can be resumed from any point with clear git history |
| **Multi-agent support** | Different agents can work on different tasks safely |
| **Progress visibility** | User can see exactly what was completed |

### Agent Behavior Checklist

When executing multi-project plans, the agent **MUST**:

- [ ] ✅ Complete all work for a single task before any commits
- [ ] ✅ Run validations in **each** affected repository
- [ ] ✅ Commit in each repository **separately** (not from root)
- [ ] ✅ Push to remote immediately (don't leave local-only commits)
- [ ] ✅ Update plan README and task log
- [ ] ✅ Report commit status to user after each task

**The agent MUST NOT:**

- ❌ Accumulate changes across multiple tasks
- ❌ Commit sub-project code from the root repository
- ❌ Skip pushing commits (risky for long-running plans)
- ❌ Continue without confirming commits succeeded
- ❌ Forget to commit in any affected repository

### Example: Complete Task Workflow

**Scenario:** Task 3 of PLAN_006_user_preferences modifies `repositories/api` and `repositories/web-app`

```bash
# 1. Work on the task (implementation)
# ... agent makes changes ...

# 2. Run validations (from workspace root)
cd repositories/api && codecheck
cd ../web-app && npm run test && npm run lint

# 3. Fill each task's Completion & Log and update the plan projections
#    (task log → README checkbox/status → PROGRESS.md)
#
# 4. Commit in api
cd ../api
git add -- src/preferences/ tests/preferences/   # the task's touched paths
git commit -m "feat(api): add user preferences model and endpoints - Task 3 of PLAN_006_user_preferences"
git push

# 5. Commit in web-app
cd ../web-app
git add -- src/settings/preferences/ tests/settings/   # the task's touched paths
git commit -m "feat(ui): add user preferences settings page - Task 3 of PLAN_006_user_preferences"
git push

# 6. Update the state layer, if present
cd ..
# Rewrite state.json atomically with the completed task, gate records, outcome,
# and commit hash.

# 7. Report to user
# "Task 3 complete. Committed and pushed:
#  - api: feat(api): add user preferences model and endpoints
#  - web-app: feat(ui): add user preferences settings page"
```

---

## ⚠️ CRITICAL: Task Completion Tracking (MANDATORY)

> **THIS IS THE MOST IMPORTANT RULE OF THE ENTIRE SYSTEM**

### Why This Matters

The plan README's task list (`[ ]` / `[x]`) is the **SINGLE SOURCE OF TRUTH** for plan progress. Without proper task marking:
- Interrupted sessions cannot resume correctly
- Progress is lost and tasks may be repeated
- Plan status becomes unreliable
- Multi-day executions become impossible to track

### MANDATORY Actions After Each Task

**IMMEDIATELY after completing EACH task, the agent MUST:**

1. **Update the task file's Completion & Log section** - Record status, timestamp, and summary
2. **Update the plan README.md** - Change `[ ]` to `[x]` for the completed task
3. **Update the Plan Status table** - Update the phase status and completed count
4. **Update PROGRESS.md** - Add a short task summary (a few lines), key decisions, important values — the full narrative stays in the task file's Completion & Log; keep PROGRESS.md a bounded working index

### Example: Before and After

**BEFORE completing Task 3:**
```markdown
## Task List
- [x] Task 1: Setup
- [x] Task 2: Implementation
- [ ] Task 3: Testing        ← Currently working on
- [ ] Task 4: Documentation

## Plan Status
**Completed**: 2/4
```

**AFTER completing Task 3:**
```markdown
## Task List
- [x] Task 1: Setup
- [x] Task 2: Implementation
- [x] Task 3: Testing        ← Just completed, MUST mark!
- [ ] Task 4: Documentation

## Plan Status
**Completed**: 3/4
```

### Verification Checklist (Run After Each Task)

Before moving to the next task, verify:

- [ ] ✅ Plan README task is marked `[x]`
- [ ] ✅ Plan Status count is updated (e.g., "3/25")
- [ ] ✅ Task file Completion & Log section is filled
- [ ] ✅ PROGRESS.md is updated with task summary
- [ ] ✅ Changes are committed
- [ ] ✅ Dailybot progress report sent if task is independently significant (non-blocking — continue if fails)

### Consequences of Not Marking Tasks

❌ **If tasks are NOT marked as completed:**
- Resume operations will REDO already-completed work
- Time and resources will be wasted
- The plan becomes unreliable and confusing
- Long-running plans become impossible to manage

✅ **If tasks ARE properly marked:**
- Seamless resume after interruptions
- Clear progress visibility at all times
- Reliable multi-day/multi-session execution
- Accurate status reporting

---

---

### Verified plan publication

Before announcing completion, author the finished task logs (including
`Skills disposition:` and `Documentation decision:`), README index and PROGRESS
from earned source/acceptance results. Then close the final task through
`shared/update-state.py`: its terminal transition validates the completed
candidate against all plan artifacts before writing state, verifies the actual
files afterward, and records `analysis_results/FINALIZATION.json`. Do not add
an invented passing gate for this invocation to the candidate it is validating.
The receipt is external evidence, not its own prerequisite. Run
`bash ../verify/conformance.sh --plan <plan>` on the actual artifacts next.

An interrupted publication leaves `.finalizing.json`; normal verification fails
until evidence is inspected and `python3 ../shared/finalize_plan.py PLAN_DIR
--candidate CANDIDATE.json --recover` succeeds. A stale cooperative lock requires
checking that no writer is active before removal. No helper commits, pushes,
executes stored gate commands or silently repairs Markdown. Missing Python means
UNVERIFIED, never completed. These checks enforce records and structure; manually
judge acceptance, consumer coverage and the truth of the underlying evidence.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall