supipowers 1.0.1 → 1.2.0

package/README.md

@@ -1,8 +1,18 @@
-<img width="1584" height="672" alt="image" src="https://github.com/user-attachments/assets/ec0f3658-54d7-4471-91ba-39297191f055" />
+<img width="1584" height="672" alt="supipowers" src="https://github.com/user-attachments/assets/ec0f3658-54d7-4471-91ba-39297191f055" />
+
+<div align="center">
 
 # Supipowers
 
-Agentic workflows for [OMP](https://github.com/can1357/oh-my-pi). Plan features, orchestrate sub-agents, run quality gates, and ship releases — all from slash commands.
+[![npm version](https://img.shields.io/npm/v/supipowers?style=flat-square)](https://www.npmjs.com/package/supipowers)
+[![License](https://img.shields.io/badge/License-MIT-blue?style=flat-square)](LICENSE)
+
+Agentic workflows for [Pi](https://github.com/mariozechner/pi-coding-agent) and [OMP](https://github.com/can1357/oh-my-pi) coding agents.
+Plan features, orchestrate sub-agents, run quality gates, fix PRs, manage MCP servers, and ship releases. All from slash commands.
+
+[Install](#install) · [Commands](#commands) · [How it works](#how-it-works) · [Configuration](#configuration) · [Development](#development)
+
+</div>
 
 ## Install
 
@@ -10,33 +20,64 @@ Agentic workflows for [OMP](https://github.com/can1357/oh-my-pi). Plan features,
 bunx supipowers@latest
 ```
 
-The installer checks for OMP, helps you install it if needed, copies supipowers into `~/.omp/agent/`, and optionally installs LSP servers for better code intelligence.
-
-Re-running the installer updates supipowers if a newer version is available. Already up-to-date installs are detected and skipped.
+The installer detects which agent you're running (Pi or OMP), copies supipowers into the right directory, and optionally sets up LSP servers for better code intelligence. Re-running the installer upgrades to the latest version if one is available.
 
-### Update from inside OMP
+### Update from inside your agent
 
 ```
 /supi:update
 ```
 
-Checks npm for the latest version, downloads and installs it — no prompts, no restart needed.
+Checks npm for the latest version, downloads and installs it. No prompts, no restart needed.
 
-## Commands
+## Requirements
+
+### Required
+
+| Dependency | What it's for |
+| --- | --- |
+| [Pi](https://github.com/mariozechner/pi-coding-agent) or [OMP](https://github.com/can1357/oh-my-pi) | The coding agent that supipowers extends |
+| [Bun](https://bun.sh) | Runtime (provides bun:sqlite with FTS5 for full-text search) |
+| [Git](https://git-scm.com) | Version control (used by the installer and context-mode setup) |
+
+### Optional
+
+The installer scans for these and offers to install any that are missing. Everything works without them, but each one unlocks additional capabilities.
+
+| Dependency | Category | What it enables | Install command |
+| --- | --- | --- | --- |
+| [mcpc](https://github.com/apify/mcpc) | MCP | MCP server management via `/supi:mcp` | `npm install -g @apify/mcpc` |
+| [context-mode](https://github.com/mksglu/context-mode) | MCP | Context window protection (auto-routes large outputs through sandboxed execution) | Installed as extension via `git clone` + `npm install` |
+| [typescript-language-server](https://github.com/typescript-language-server/typescript-language-server) | LSP | TypeScript/JavaScript diagnostics, references, completions | `bun add -g typescript-language-server typescript` |
+| [Pyright](https://github.com/microsoft/pyright) | LSP | Python type checking and language features | `pip install pyright` |
+| [rust-analyzer](https://rust-analyzer.github.io) | LSP | Rust language server | `rustup component add rust-analyzer` |
+| [gopls](https://pkg.go.dev/golang.org/x/tools/gopls) | LSP | Go language server | `go install golang.org/x/tools/gopls@latest` |
+| [playwright-cli](https://github.com/microsoft/playwright-cli) | Testing | Interactive browser exploration for E2E flow discovery via `/supi:qa --e2e` | `npm install -g @playwright/cli@latest` |
+| [Playwright Test](https://playwright.dev) | Testing | Test runner for E2E test execution via `run-e2e-tests.sh` | `npm install -g @playwright/cli@latest` |
 
-| Command          | What it does                                     |
-| ---------------- | ------------------------------------------------ |
-| `/supi`          | Interactive menu — commands and project status   |
-| `/supi:plan`     | Collaborative planning with task breakdown       |
-| `/supi:run`      | Execute a plan with parallel sub-agents          |
-| `/supi:review`   | Quality gates at chosen depth                    |
-| `/supi:qa`       | Run test suite and E2E pipeline                  |
-| `/supi:release`  | Version bump, release notes, publish             |
-| `/supi:config`   | Interactive settings (TUI)                       |
-| `/supi:status`   | Check running sub-agents and progress            |
-| `/supi:update`   | Update supipowers to latest version              |
+LSP servers are language-specific. You only need the ones matching the languages in your project. Sub-agents use them to check diagnostics and find references before making changes.
 
-Commands like `/supi`, `/supi:config`, `/supi:status`, and `/supi:update` open native OMP TUI dialogs — they don't send chat messages or trigger the AI.
+> [!TIP]
+> Run `/supi:doctor` at any time to check which dependencies are installed and which are missing.
+
+## Commands
+
+| Command         | What it does                                          |
+| --------------- | ----------------------------------------------------- |
+| `/supi`         | Interactive menu with commands and project status     |
+| `/supi:plan`    | Collaborative planning with structured task breakdown |
+| `/supi:run`     | Execute a plan with parallel sub-agents               |
+| `/supi:review`  | Quality gates at chosen depth                         |
+| `/supi:qa`      | E2E testing pipeline with playwright-cli               |
+| `/supi:release` | Version bump, release notes, publish                  |
+| `/supi:fix-pr`  | Assess and fix PR review comments                     |
+| `/supi:mcp`     | Manage MCP servers (connect, disconnect, list)        |
+| `/supi:config`  | Interactive settings (TUI)                            |
+| `/supi:status`  | Check running sub-agents and progress                 |
+| `/supi:doctor`  | Diagnose extension health and configuration           |
+| `/supi:update`  | Update supipowers to latest version                   |
+
+Commands like `/supi`, `/supi:config`, `/supi:status`, and `/supi:update` open native TUI dialogs. They don't send chat messages or trigger the AI.
 
 ### Planning
 
@@ -44,7 +85,7 @@ Commands like `/supi`, `/supi:config`, `/supi:status`, and `/supi:update` open n
 /supi:plan add authentication to the API
 ```
 
-Starts an interactive planning session: clarifying questions, approach proposals, then a structured task breakdown saved to `.omp/supipowers/plans/`.
+Starts an interactive session: clarifying questions, approach proposals, then a structured task breakdown saved to `.omp/supipowers/plans/` (or the Pi equivalent).
 
 For simple tasks, skip the brainstorming:
 
@@ -60,7 +101,7 @@ For simple tasks, skip the brainstorming:
 
 Loads the latest plan and executes it with sub-agent orchestration. Tasks marked `[parallel-safe]` run concurrently (up to the configured limit). Sequential tasks respect their dependency chains.
 
-The orchestration loop: dispatch batch → collect results → detect conflicts → retry failures → next batch. If interrupted, re-running picks up where it left off.
+The orchestration loop: dispatch batch, collect results, detect conflicts, retry failures, next batch. If interrupted, re-running picks up where it left off.
 
 ### Quality review
 
@@ -81,7 +122,16 @@ When no flag is provided, a TUI picker lets you choose the review profile intera
 /supi:qa --e2e        # Playwright / E2E only
 ```
 
-Detects your test framework on first run (vitest, jest, pytest, cargo test, go test) and caches it. When no flag is provided, a TUI picker lets you choose the scope.
+Detects your test framework on first run (vitest, jest, pytest, cargo test, go test) and caches it. E2E mode (`--e2e`) uses `playwright-cli` to run browser tests autonomously. When no flag is provided, a TUI picker lets you choose the scope.
+
+### Fix PR
+
+```
+/supi:fix-pr          # auto-detects current branch PR
+/supi:fix-pr 42       # targets PR #42
+```
+
+Pulls review comments from GitHub, assesses each one (some comments deserve pushback, not code changes), then fixes what needs fixing. Tracks sessions so you can pick up where you left off.
 
 ### Release
 
@@ -91,13 +141,35 @@ Detects your test framework on first run (vitest, jest, pytest, cargo test, go t
 
 Analyzes commits since last tag, suggests a version bump, generates release notes, and publishes. On first run, a TUI picker lets you choose your pipeline (npm, GitHub release, or manual).
 
+### MCP servers
+
+```
+/supi:mcp
+```
+
+Register, connect, and manage MCP (Model Context Protocol) servers through supipowers. Each server gets auto-generated trigger rules so the agent knows when to use its tools without being told explicitly.
+
+## How it works
+
+Supipowers runs as an extension inside Pi or OMP. A platform abstraction layer handles the API differences between the two agents, so every command works the same regardless of which agent you're using.
+
+**Sub-agent orchestration.** Plans are broken into batches of parallel-safe tasks. Each batch dispatches sub-agents with full tool access (file editing, bash, LSP). After a batch completes, the orchestrator checks for file conflicts, retries failures, and moves to the next batch.
+
+**Quality gates.** Composable checks selected by profile. LSP diagnostics surface real type errors. AI review catches logic issues. Test gates run your actual test suite. Gates report issues with severity levels (error, warning, info).
+
+**LSP integration.** Sub-agents query LSP before making changes (find references, check diagnostics). If no LSP is active, everything still works, just with less precision. The installer offers to set up LSP servers during installation.
+
+**Context-mode integration.** When the [context-mode](https://github.com/ogrodev/context-mode) MCP server is detected, supipowers injects routing hooks that protect the agent's context window. Large command outputs, file reads, and HTTP calls are automatically routed through sandboxed execution so only summaries enter the conversation.
+
+**Update checking.** On session start, supipowers checks npm for a newer version in the background. If one is available, a notification tells you to run `/supi:update`.
+
 ## Configuration
 
 ```
 /supi:config
 ```
 
-Opens an interactive settings screen with all configuration options. Select a setting to change its value — toggles flip instantly, selects open a picker, text fields open an input dialog.
+Opens an interactive settings screen. Select a setting to change its value: toggles flip instantly, selects open a picker, text fields open an input dialog.
 
 ### Profiles
 
@@ -118,65 +190,83 @@ Create custom profiles in `.omp/supipowers/profiles/`.
   "defaultProfile": "thorough",
   "orchestration": {
     "maxParallelAgents": 3, // concurrent sub-agents per batch
-    "maxFixRetries": 2,     // retry failed tasks
-    "maxNestingDepth": 2,   // sub-agent nesting limit
-    "modelPreference": "auto"
+    "maxFixRetries": 2, // retry failed tasks
+    "maxNestingDepth": 2, // sub-agent nesting limit
+    "modelPreference": "auto",
   },
   "lsp": {
-    "setupGuide": true
+    "setupGuide": true,
   },
   "qa": {
     "framework": null, // auto-detected and cached
-    "command": null
-  }
+    "command": null,
+  },
 }
 ```
 
-Config is stored in `~/.omp/agent/extensions/supipowers/` and managed entirely through `/supi:config`.
-
-## How it works
+Config lives in `~/.omp/agent/extensions/supipowers/` (OMP) or `~/.pi/agent/extensions/supipowers/` (Pi) and is managed entirely through `/supi:config`.
 
-Supipowers is built on OMP's extension API. Every command is an immediate action — no state machine, no workflow phases.
+## Skills
 
-**Sub-agent orchestration**: Plans are broken into batches of parallel-safe tasks. Each batch dispatches sub-agents with full OMP tool access (file editing, bash, LSP). After a batch completes, the orchestrator checks for file conflicts, retries failures, and moves to the next batch.
+Supipowers ships with prompt skills that commands load at runtime to steer AI sessions:
 
-**Quality gates**: Composable checks selected by profile. LSP diagnostics feed real type errors. AI review catches logic issues. Test gates run your actual test suite. Gates report issues with severity levels (error/warning/info).
+| Skill                   | Used by                                |
+| ----------------------- | -------------------------------------- |
+| `planning`              | `/supi:plan`                           |
+| `code-review`           | `/supi:review`                         |
+| `debugging`             | Failure retry loop                     |
+| `qa-strategy`           | `/supi:qa`                             |
+| `fix-pr`                | `/supi:fix-pr`                         |
+| `tdd`                   | Plan tasks with test-first annotations |
+| `verification`          | Pre-completion checks                  |
+| `receiving-code-review` | Review comment assessment              |
+| `context-mode`          | Context-mode routing hooks             |
 
-**LSP integration**: Sub-agents query LSP before making changes (find references, check diagnostics). If no LSP is active, everything still works — just better with it. The installer offers to set up LSP servers during installation.
-
-**Update checking**: On session start, supipowers checks npm for a newer version in the background. If one is available, a notification tells you to run `/supi:update`.
+Skills are markdown files in `skills/`. They're loaded on demand, not bundled at build time.
 
 ## Project structure
 
 ```
 src/
-  index.ts                     # extension entry point + update checker
-  commands/                    # slash command handlers
+  index.ts                     # extension entry + platform detection
+  bootstrap.ts                 # command registration orchestrator
+  platform/                    # dual-platform abstraction (Pi + OMP)
+    detect.ts, types.ts, pi.ts, omp.ts
+  commands/                    # one file per slash command
     supi.ts, plan.ts, run.ts, review.ts, qa.ts, release.ts,
-    config.ts, status.ts, update.ts
+    fix-pr.ts, mcp.ts, config.ts, status.ts, doctor.ts, update.ts
   orchestrator/                # sub-agent dispatch & coordination
     batch-scheduler.ts, dispatcher.ts, result-collector.ts,
     conflict-resolver.ts, prompts.ts
+  planning/                    # plan writing & review prompts
+    plan-writer-prompt.ts, plan-reviewer.ts,
+    spec-reviewer.ts, prompt-builder.ts
   quality/                     # composable quality gates
     gate-runner.ts, lsp-gate.ts, ai-review-gate.ts, test-gate.ts
   qa/                          # QA pipeline
-    detector.ts, runner.ts, report.ts
+    session.ts, matrix.ts, prompt-builder.ts, config.ts
+  fix-pr/                      # PR comment assessment & fixing
+    prompt-builder.ts, config.ts, types.ts
+  mcp/                         # MCP server gateway
+    gateway.ts, registry.ts, activation.ts, triggers.ts,
+    lifecycle.ts, manager-tool.ts, mcpc.ts, config.ts
+  context-mode/                # context-mode integration
+    hooks.ts, routing.ts, detector.ts, installer.ts,
+    compressor.ts, event-store.ts, event-extractor.ts,
+    snapshot-builder.ts
   lsp/                         # LSP integration
     detector.ts, bridge.ts, setup-guide.ts
-  notifications/               # rich inline notifications
-    renderer.ts, types.ts
-  config/                      # configuration & profiles
-    loader.ts, profiles.ts, defaults.ts, schema.ts
-  storage/                     # persistence
-    plans.ts, runs.ts, reports.ts
   release/                     # release automation
     analyzer.ts, notes.ts, publisher.ts
+  config/                      # configuration & profiles
+    loader.ts, profiles.ts, defaults.ts, schema.ts
+  storage/                     # persistence layer
+    plans.ts, runs.ts, reports.ts, specs.ts,
+    qa-sessions.ts, fix-pr-sessions.ts
+  notifications/               # rich inline notifications
+    renderer.ts, types.ts
   types.ts                     # shared type definitions
-skills/
-  planning/SKILL.md
-  code-review/SKILL.md
-  debugging/SKILL.md
-  qa-strategy/SKILL.md
+skills/                        # runtime-loaded prompt skills
 bin/
   install.mjs                  # bunx installer
 ```
@@ -187,15 +277,17 @@ bin/
 git clone https://github.com/ogrodev/supipowers.git
 cd supipowers
 bun install
-bun run test        # run tests
-bun run typecheck   # type checking
-bun run test:watch  # watch mode
+bun test              # run all tests
+bun run typecheck     # type checking
+bun run test:watch    # watch mode
+bun run build         # emit to dist/
 ```
 
-## Requirements
+The test suite mirrors the `src/` structure under `tests/`. Tests use Bun's built-in test runner (`bun:test`) with inline mocks via `mock()`. Filesystem tests use temp directories created in `beforeEach`.
+
+> [!NOTE]
+> Supipowers works with both Pi and OMP. The platform abstraction in `src/platform/` normalizes API differences (event names, tool registration, message delivery) so you can develop against either agent.
 
-- [OMP](https://github.com/can1357/oh-my-pi) (oh-my-pi)
-- [Bun](https://bun.sh) runtime
 
 ## License
 

package/bin/.omp/SYSTEM.md

@@ -0,0 +1,77 @@
+# context-mode — MANDATORY routing rules
+
+You have context-mode MCP tools available. These rules are NOT optional — they protect your context window from flooding. A single unrouted command can dump 56 KB into context and waste the entire session.
+
+## BLOCKED commands — do NOT attempt these
+
+### curl / wget — BLOCKED
+Any Bash command containing `curl` or `wget` is intercepted and replaced with an error message. Do NOT retry.
+Instead use:
+- `ctx_fetch_and_index(url, source)` to fetch and index web pages
+- `ctx_execute(language: "javascript", code: "const r = await fetch(...)")` to run HTTP calls in sandbox
+
+### Inline HTTP — BLOCKED
+Any Bash command containing `fetch('http`, `requests.get(`, `requests.post(`, `http.get(`, or `http.request(` is intercepted and replaced with an error message. Do NOT retry with Bash.
+Instead use:
+- `ctx_execute(language, code)` to run HTTP calls in sandbox — only stdout enters context
+
+### WebFetch / Fetch — BLOCKED
+WebFetch and Fetch calls are denied entirely.
+Instead use:
+- `ctx_fetch_and_index(url, source)` then `ctx_search(queries)` to query the indexed content
+
+### Grep — BLOCKED
+Grep calls are intercepted and blocked. Do NOT retry with Grep.
+Instead use:
+- `ctx_search(queries: ["<pattern>"])` to search indexed content
+- `ctx_batch_execute(commands, queries)` to run searches and return compressed results
+- `ctx_execute(language: "shell", code: "grep ...")` to run searches in sandbox
+
+### Find / Glob — BLOCKED
+Find/Glob calls are intercepted and blocked. Do NOT retry with Find/Glob.
+Instead use:
+- `ctx_execute(language: "shell", code: "find ...")` to run in sandbox
+- `ctx_batch_execute(commands, queries)` for multiple searches
+
+### Read (full-file, no limit) — BLOCKED
+Reading an entire file without a `limit` parameter is blocked.
+- If you need to **Edit** the file → re-call Read with `limit` parameter (e.g., `limit: 200`)
+- If you need to **analyze or explore** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context.
+
+## REDIRECTED tools — use sandbox equivalents
+
+### Bash (>20 lines output)
+Bash is ONLY for: `git`, `mkdir`, `rm`, `mv`, `cd`, `ls`, `npm install`, `pip install`, and other short-output commands.
+For everything else, use:
+- `ctx_batch_execute(commands, queries)` — run multiple commands + search in ONE call
+- `ctx_execute(language: "shell", code: "...")` — run in sandbox, only stdout enters context
+
+### Read (for analysis)
+If you are reading a file to **Edit** it → Read with `limit` is correct (Edit needs content in context).
+If you are reading to **analyze, explore, or summarize** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context. The raw file content stays in the sandbox.
+
+## Tool selection hierarchy
+
+1. **GATHER**: `ctx_batch_execute(commands, queries)` — Primary tool. Runs all commands, auto-indexes output, returns search results. ONE call replaces 30+ individual calls.
+2. **FOLLOW-UP**: `ctx_search(queries: ["q1", "q2", ...])` — Query indexed content. Pass ALL questions as array in ONE call.
+3. **PROCESSING**: `ctx_execute(language, code)` | `ctx_execute_file(path, language, code)` — Sandbox execution. Only stdout enters context.
+4. **WEB**: `ctx_fetch_and_index(url, source)` then `ctx_search(queries)` — Fetch, chunk, index, query. Raw HTML never enters context.
+5. **INDEX**: `ctx_index(content, source)` — Store content in FTS5 knowledge base for later search.
+
+## Subagent routing
+
+When spawning subagents (Agent/Task tool), the routing block is automatically injected into their prompt. Bash-type subagents are upgraded to general-purpose so they have access to MCP tools. You do NOT need to manually instruct subagents about context-mode.
+
+## Output constraints
+
+- Keep responses under 500 words.
+- Write artifacts (code, configs, PRDs) to FILES — never return them as inline text. Return only: file path + 1-line description.
+- When indexing content, use descriptive source labels so others can `ctx_search(source: "label")` later.
+
+## ctx commands
+
+| Command | Action |
+|---------|--------|
+| `ctx stats` | Call the `ctx_stats` MCP tool and display the full output verbatim |
+| `ctx doctor` | Call the `ctx_doctor` MCP tool, run the returned shell command, display as checklist |
+| `ctx upgrade` | Call the `ctx_upgrade` MCP tool, run the returned shell command, display as checklist |

package/bin/ctx-mode-wrapper.mjs

@@ -6,7 +6,7 @@
 //
 // Setting CLAUDE_PROJECT_DIR causes start.mjs to also write a CLAUDE.md
 // in the project root. This is harmless (OMP doesn't read it) but the
-// user should gitignore it. We also write .omp/SYSTEM.md with routing
+// user should gitignore it. We also write .omp/APPEND_SYSTEM.md with routing
 // rules since that's what OMP actually loads as system prompt.
 
 import { resolve, join, dirname } from "node:path";
@@ -32,7 +32,7 @@ if (!startMjs) {
   process.exit(1);
 }
 
-// Write .omp/SYSTEM.md with routing rules (idempotent — only if marker absent)
+// Write .omp/APPEND_SYSTEM.md with routing rules (idempotent — only if marker absent)
 const ROUTING_MARKER = "# context-mode — MANDATORY routing rules";
 try {
   // Find SKILL.md from multiple possible locations
@@ -47,7 +47,7 @@ try {
 
   if (skillContent && skillContent.includes(ROUTING_MARKER)) {
     const ompDir = join(projectDir, ".omp");
-    const systemMdPath = join(ompDir, "SYSTEM.md");
+    const systemMdPath = join(ompDir, "APPEND_SYSTEM.md");
 
     if (!existsSync(ompDir)) mkdirSync(ompDir, { recursive: true });
 

package/bin/install.ts

@@ -199,7 +199,7 @@ function installToPlatform(platformDir: string, packageRoot: string): string {
  */
 async function installContextMode(platformDir: string): Promise<void> {
   const extDir = join(homedir(), platformDir, "extensions", "context-mode");
-  const startMjs = join(extDir, "node_modules", "context-mode", "start.mjs");
+  const startMjs = join(extDir, "start.mjs");
 
   // Check if already installed and built
   if (existsSync(startMjs)) {

package/bin/local-install.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# Install supipowers locally from the current working tree.
+# Usage:  ./bin/local-install.sh
+#
+# This creates a global symlink so both the `supipowers` CLI and
+# the Pi/OMP extension resolve to your local source — no publish needed.
+# Re-run after pulling new changes; the symlink stays valid.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+echo "→ Installing supipowers locally from $PROJECT_DIR"
+
+# 1. Install dependencies (fast no-op when lock is current)
+echo "→ Installing dependencies…"
+cd "$PROJECT_DIR"
+bun install --frozen-lockfile 2>/dev/null || bun install
+
+# 2. Create a global symlink via bun link
+#    This registers the package globally so `supipowers` CLI works
+#    and Pi/OMP can resolve it by name.
+echo "→ Linking supipowers globally…"
+bun link
+
+# 3. Verify the link
+if command -v supipowers &>/dev/null; then
+  echo "✓ 'supipowers' CLI is available at $(which supipowers)"
+else
+  echo "⚠ CLI not on PATH — you may need to add bun's global bin to \$PATH:"
+  echo "  export PATH=\"\$HOME/.bun/bin:\$PATH\""
+fi
+
+# 4. Show version
+VERSION=$(node -e "console.log(require('$PROJECT_DIR/package.json').version)")
+echo ""
+echo "✓ supipowers v${VERSION} installed locally (linked to $PROJECT_DIR)"
+echo "  Any edits to src/ or skills/ take effect immediately — no rebuild needed."

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "supipowers",
-  "version": "1.0.1",
-  "description": "Workflow extension for Pi and OMP coding agents.",
+  "version": "1.2.0",
+  "description": "Workflow extension for OMP coding agents.",
   "type": "module",
   "scripts": {
-    "test": "vitest run",
+    "test": "bun test tests/",
     "typecheck": "tsc --noEmit",
-    "test:watch": "vitest",
-    "build": "tsc -p tsconfig.build.json"
+    "test:watch": "bun test --watch tests/",
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "git config core.hooksPath hooks || true"
   },
   "keywords": [
-    "pi-extension",
     "omp-extension",
     "workflow",
     "agent",
@@ -27,14 +27,6 @@
     "README.md",
     "LICENSE"
   ],
-  "pi": {
-    "extensions": [
-      "./src/index.ts"
-    ],
-    "skills": [
-      "./skills"
-    ]
-  },
   "omp": {
     "extensions": [
       "./src/index.ts"
@@ -47,23 +39,23 @@
     "@clack/prompts": "^0.10.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
     "@oh-my-pi/pi-coding-agent": "*",
     "@sinclair/typebox": "*"
   },
   "peerDependenciesMeta": {
-    "@mariozechner/pi-coding-agent": { "optional": true },
-    "@oh-my-pi/pi-coding-agent": { "optional": true },
-    "@oh-my-pi/pi-tui": { "optional": true }
+    "@oh-my-pi/pi-coding-agent": {
+      "optional": true
+    },
+    "@oh-my-pi/pi-tui": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@oh-my-pi/pi-coding-agent": "latest",
     "@oh-my-pi/pi-tui": "latest",
     "@sinclair/typebox": "^0.34.48",
     "@types/node": "^22.0.0",
-    "better-sqlite3": "^12.8.0",
-    "@types/better-sqlite3": "^7.6.13",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.0"
+    "bun-types": "^1.3.11",
+    "typescript": "^5.9.3"
   }
 }

package/skills/planning/SKILL.md

@@ -18,6 +18,7 @@ Follow these phases in order. Do not skip or combine them.
 ### Phase 1: Explore Project Context
 
 Before asking questions, understand the current state:
+
 - Check files, docs, recent commits
 - Understand existing architecture and patterns
 - If the request covers multiple independent subsystems, flag it immediately and help decompose into sub-projects
@@ -38,6 +39,7 @@ Before asking questions, understand the current state:
 ### Phase 4: Present Design
 
 Once aligned on approach:
+
 - Scale each section to its complexity (a few sentences if straightforward, up to 200-300 words if nuanced)
 - Cover: architecture, components, data flow, error handling, testing
 - Ask after each section whether it looks right so far
@@ -47,13 +49,15 @@ Once aligned on approach:
 ### Phase 5: Write Design Doc
 
 Once the user approves the design:
-- Save to `docs/supipowers/specs/YYYY-MM-DD-<topic>-design.md`
+
+- Save to `.omp/supipowers/specs/YYYY-MM-DD-<topic>-design.md`
 - Use clear, concise writing
 - Commit the design document to git
 
 ### Phase 6: Spec Review Loop
 
 After writing the design doc:
+
 1. Dispatch a spec-document-reviewer sub-agent to verify completeness
 2. If **Issues Found**: fix the issues, re-dispatch the reviewer
 3. Repeat until **Approved** (max 5 iterations, then surface to human)
@@ -69,7 +73,8 @@ Wait for their response. Only proceed once approved.
 ### Phase 8: Create Implementation Plan
 
 Break into bite-sized tasks (2-5 minutes each). Each task must have:
-- Name with parallelism: `[parallel-safe]` or `[sequential: depends on N]`
+
+- Name
 - **files**: Exact paths the agent will touch
 - **criteria**: Acceptance criteria (testable)
 - **complexity**: `small` | `medium` | `large`
@@ -92,7 +97,7 @@ tags: [<relevant>, <tags>]
 
 ## Tasks
 
-### 1. <Task name> [parallel-safe]
+### 1. <Task name>
 - **files**: src/path/to/file.ts
 - **criteria**: <what success looks like>
 - **complexity**: small
@@ -107,8 +112,6 @@ tags: [<relevant>, <tags>]
 ## Principles
 
 - Each task should be completable in 2-5 minutes
-- Tasks that touch different files are parallel-safe
-- Tasks that depend on others' output are sequential
 - Include test files in the files list
 - Prefer small, focused tasks over large ones
 - DRY, YAGNI, TDD, frequent commits