@slowdini/slow-powers-opencode 0.3.0 → 0.4.1

package/README.md

@@ -1,68 +1,43 @@
 # Slow-powers
 
-Slow-powers gives your agent superpowers. It's a complete software development
-methodology for coding agents — a set of composable skills plus a bootstrap
-that ensures the agent reaches for them at the right moments.
+Slow-powers is an agent skill set for professional software development. It enhances plan mode and debugging work, enforces best practices, and works _with_ the features of modern agents, instead of replacing them. It's a plugin for people who don't install plugins.
 
 ## About this fork
 
-Slow-powers is a fork of [obra/superpowers](https://github.com/obra/superpowers)
-at v5.1.0. We preserve the overall workflow of superpowers, while fixing bugs
-and clarifying skill content.
+Slow-powers is a fork of [obra/superpowers](https://github.com/obra/superpowers). Much of the skill content is sourced from upstream, with rewrites focusing on clarity, token efficiency, and enhancing instead of replacing plan mode.
 
 ## Quickstart
 
-Give your agent superpowers with slow-powers: [Claude Code](#claude-code) · [Codex CLI](#codex-cli) · [OpenCode](#opencode). Support varies per harness — see the [feature support](#feature-support) tables.
+[Claude Code](#claude-code) · [Codex CLI](#codex-cli) · [OpenCode](#opencode)
 
-## Feature support
+## How it works
 
-Parity is tracked on two independent surfaces. **Plugin distribution** is how Slow-powers reaches a user's session — manifests, bootstrap injection, skill discovery, hooks:
+Slow-powers is designed to improve the actual day-to-day work of software developers working with agents. It instructs agents to check for skills first, and use the ones that apply. The shipped skills fill real gaps in agentic development, but all discoverable skills benefit from the skill-enforcing guidance.
 
-| Harness         | Status   | Notes                                                                             |
-|-----------------|----------|-----------------------------------------------------------------------------------|
-| Claude Code     | Full     | Reference implementation                                                          |
-| Codex CLI       | Full     | Plugin manifest + shared `hooks/hooks.json`; the plan hand-off hook is Claude-native (N/A here, see #141) |
-| OpenCode        | Full     | JS plugin (npm package) injects bootstrap and registers skills via the native plugin API |
+### Start in plan mode
 
-The **skill-eval runner** (developer tooling under `skills/evaluating-skills/`, slated to move into its own project) is tracked separately:
+Even small features are developed better with a plan. Slow-powers hardens the plan to catch hallucinations and other mistakes before you review it. During implementation, skills guide the agent through best practices, working in isolation, following test-driven development, and reviewing and verifying its work before it hands it back to you.
 
-| Harness         | Status   | Notes                                                                             |
-|-----------------|----------|-----------------------------------------------------------------------------------|
-| Claude Code     | Full     | Reference implementation: transcript adapter, auto-record, `--guard`, `--plan-mode` |
-| Codex CLI       | Manual   | No transcript adapter — hand-authored run records; `llm_judge` assertions carry the measurement |
-| OpenCode        | Manual   | No transcript adapter — hand-authored run records; `llm_judge` assertions carry the measurement |
+### Debugging
 
-Contributors closing parity gaps should follow [`harness-parity-check.md`](./harness-parity-check.md) for distribution gaps, or [`skills/evaluating-skills/harness-parity.md`](./skills/evaluating-skills/harness-parity.md) for eval-runner gaps: each audits which features are wired up for a given harness and preps an agent to close one gap.
+Slow-powers guides agents through an evidence-backed, no-guess debugging approach. No "It works now!" without proof.
 
-## How it works
+### Writing skills
 
-Slow-powers integrates directly into your agent's session, providing a highly disciplined set of technical execution utilities. It enforces strict test-driven development (TDD), systematic scientific debugging, rigorous verification checks, safe workspace isolation so new work doesn't collide with existing work, and clean branch-finishing hygiene. It also enhances native agent planning phases with strict rules: banning placeholders, enforcing atomic task granularity, and requiring TDD-first checklists.
+Skills for writing skills! Slow-powers skills are all written and evaluated following the same guidelines and processes it ships. Back up your own skills with real stats, and understand their cost in time and tokens.
 
-## Installation
+Skill evaluations are powered by [@slowdini/eval-runner](https://github.com/slowdini/eval-runner)
 
-Installation differs by harness. If you use more than one, install
-Slow-powers separately for each.
+## Installation
 
 ### Install with your agent
 
-Don't want to look up the steps? Open the harness you want Slow-powers on and
-paste this prompt to its agent — it'll read the guide, work out which harness
-it's in, and do the install for you:
+Open the harness you want Slow-powers on and paste this prompt:
 
 ```text
-Install the "slow-powers" plugin for the coding-agent harness you are currently
-running in. Read the installation guide at
-https://github.com/slowdini/slow-powers#installation, determine which harness
-this is (Claude Code, Codex CLI, or OpenCode), and follow the matching steps —
-run the documented marketplace/install commands for Claude Code or Codex, or add
-the package to the `plugin` array in opencode.json for OpenCode. Then tell me
-exactly what you changed and what I need to do to finish (e.g. restart the
-session so the skills load).
+Install the slow-powers plugin from https://github.com/slowdini/slow-powers#installation for this harness.
 ```
 
-The per-harness instructions below are the source of truth the agent follows —
-and the reference for installing by hand.
-
 ### Claude Code
 
 ```
@@ -70,6 +45,9 @@ and the reference for installing by hand.
 /plugin install slow-powers@slow-powers
 ```
 
+You can also browse and install it interactively: run `claude`, open
+`/plugin`, choose the `slowdini` marketplace, and install `slow-powers`.
+
 ### Codex CLI
 
 ```bash
@@ -79,15 +57,10 @@ codex plugin add slow-powers@slowdini
 
 You can also browse and install it interactively: run `codex`, open
 `/plugins`, choose the `slowdini` marketplace, and install `slow-powers`.
-Start a new Codex thread after installing so the bundled skills are loaded.
-
-Slow-powers includes a plugin-bundled `SessionStart` hook for bootstrap
-context. Codex hooks are stable, but plugin hooks must be reviewed and trusted
-before Codex runs them.
 
 ### OpenCode
 
-Add Slow-powers to the `plugin` array in your `opencode.json` (global or project-level):
+Add Slow-powers to the `plugin` array in `~/.config/opencode/opencode.json`:
 
 ```json
 {
@@ -95,44 +68,34 @@ Add Slow-powers to the `plugin` array in your `opencode.json` (global or project
 }
 ```
 
-This installs the latest published version from npm.
-
-## The Core Execution Utilities
+## The skills
 
-Slow-powers provides a set of highly focused, execution-level skills that ensure your agent operates with maximum discipline:
+Slow-powers provides a set of highly focused skills that ensure your agent operates with maximum discipline:
 
-1. **`working-in-isolation`** — Establishes an isolated workspace so new work doesn't collide with existing or in-progress work, keeping protected branches like `main` clean.
-2. **`test-driven-development`** — Enforces a strict RED-GREEN-REFACTOR cycle, ensuring all production code is backed by failing test verification first.
-3. **`systematic-debugging`** — Guides the agent to locate the root cause of failures via scientific hypothesis testing, avoiding "guess-and-check" thrashing.
-4. **`verifying-development-work`** — Requires running actual test/build commands and presenting concrete evidence before any success claim, with a final review pass over the change before work is handed back.
-5. **`writing-skills`** — Handles future custom skill authoring and updates.
-
-## What's inside
-
-**Testing & Verification** — `test-driven-development`, `verifying-development-work`
-
-**Debugging** — `systematic-debugging`
-
-**Workspace & Git Hygiene** — `working-in-isolation`
-
-**Meta & Extension** — `writing-skills`
+1. **`hardening-plans`** — Instructs the agent to re-review any plans before it hands them back to you, looking for hallucinations, logical inconsistencies, and other common plan mistakes.
+2. **`systematic-debugging`** — Guides the agent to locate the root cause of failures via scientific hypothesis testing, avoiding "guess-and-check" thrashing.
+3. **`working-in-isolation`** — Establishes an isolated workspace (worktree or branch) so new work doesn't collide with existing or in-progress work, keeping protected branches like `main` clean.
+4. **`test-driven-development`** — Enforces a strict RED-GREEN-REFACTOR cycle, ensuring all code is backed by failing test verification first.
+5. **`verifying-development-work`** — Requires running actual test/build commands and presenting concrete evidence before any success claim, with a final review pass over the change, code AND comments, before work is handed back.
+6. **`writing-skills`** — Helps write and edit skills, following the same best practices that guide slow-powers itself.
+7. **`evaluating-skills`** — Teaches the agent how to run skill evals, so the value of skills and prose changes can be objectively assessed.
 
 ## Intended Workflows
 
-The skills declare lightweight prerequisite / next-step gates so the agent knows the intended sequence. These gates **suggest** what comes before and after a skill once it is invoked; they do **not** restrict when any skill can be invoked. An agent may invoke `test-driven-development`, `verifying-development-work`, or any other skill at any point.
+The skills declare prerequisite / next-step gates so the agent follows an intended skill sequence. These gates **suggest** what comes before and after a skill once it is invoked; they do **not** restrict when any skill can be invoked.
 
 **Plan mode:** plan mode → `hardening-plans` → `working-in-isolation` → `test-driven-development` → `verifying-development-work`
 
 **Debugging:** (`working-in-isolation`) → `systematic-debugging` → `verifying-development-work`
 
-`hardening-plans` points to `test-driven-development` as its next step, and `test-driven-development` requires `working-in-isolation` first — so isolation is reached as TDD's prerequisite, producing the plan-mode order above.
-
 ## Philosophy
 
+Slow-powers skills follow a few opinionated principles:
+
 - Test-Driven Development — write tests first, always
-- Systematic over ad-hoc — process over guessing
-- Complexity reduction — simplicity as a primary goal
-- Evidence over claims — verify before declaring success
+- Plan mode — even small features should start with a plan
+- Prefer branches to worktrees — branches are easier for human review and testing, worktrees are better for agent isolation
+- Skills need evals — evals prove a new skill is better than no skill, and an edit to an existing skill is valuable
 
 ## Repository structure
 
@@ -146,7 +109,6 @@ Flat layout — skills and assets live at root, harness-specific integration liv
 - `opencode/` — OpenCode plugin
 - `.claude-plugin/marketplace.json` — Claude Code marketplace registry
 - `package.json` — OpenCode plugin manifest + dev tooling
-- `harness-parity-check.md` — Instructions for an agent in any harness to audit plugin-distribution gaps and prep to close one (the eval runner's counterpart lives at `skills/evaluating-skills/harness-parity.md`)
 
 ## Releasing
 

package/bootstrap.md

@@ -1,15 +1,9 @@
-# Instructions for using Slow-powers Skills
-
 <EXTREMELY-IMPORTANT>
   If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill.
   IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST USE IT.
   This is not negotiable. This is not optional. You cannot rationalize your way out of this.
 </EXTREMELY-IMPORTANT>
 
-These skills are quality gates on procedures you already run. They don't grant abilities — they enhance how you execute work you already know how to do.
-
-When you reach a gate moment — about to code, hand off a plan, debug, claim done, finish a branch — the matching skill's description surfaces it. Load it then, even if your procedure already feels complete. That "feels complete" is the gate's target.
-
 ## The Rule
 
 **Invoke relevant or requested skills BEFORE any response or action.** Even a 1% chance a skill might apply means that you should invoke the skill to check. If an invoked skill turns out to be wrong for the situation, you don't need to use it.
@@ -55,7 +49,7 @@ These thoughts mean STOP — you're rationalizing:
 
 ## Instruction Priority
 
-Slow-powers skills override default system behavior where they conflict, but user instructions always take precedence:
+Skills override default system behavior where they conflict, but user instructions always take precedence:
 1. **User's explicit instructions** (CLAUDE.md, AGENTS.md, direct requests) — highest priority
 2. **Slow-powers skills / bootstrap guidelines** — override default system prompt behavior where they conflict
 3. **Default system prompt** — lowest priority

package/opencode/plugins/slow-powers.js

@@ -3,8 +3,10 @@
  *
  * Injects slow-powers bootstrap context via system prompt transform.
  * Auto-registers skills directory via config hook (no symlinks needed).
+ * Intercepts plan file writes in plan mode and triggers hardening-plans skill.
  */
 
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -15,17 +17,19 @@ const bootstrapPath = path.resolve(__dirname, "../../bootstrap.md");
 // First line of bootstrap.md — used as an idempotency check so we don't
 // re-inject when OpenCode reruns the transform on an already-transformed
 // message array. Specific enough that user prompts won't accidentally match.
-const bootstrapLeadingPhrase = "# Instructions for using Slow-powers Skills";
+const bootstrapLeadingPhrase = "<EXTREMELY-IMPORTANT>";
 
 // Module-level cache for bootstrap content.
 // The bootstrap.md file does not change during a session, so reading it
 // once eliminates redundant fs work on every agent step.
 let _bootstrapCache; // undefined = not yet loaded, null = file missing
 
-export const SlowPowersPlugin = async ({
-  client: _client,
-  directory: _directory,
-}) => {
+// Deduplication state for plan hardening
+// Map<filePath, contentHash> - tracks processed plan file versions
+const processedPlanHashes = new Map();
+const HARDENED_MARKER = "<!-- hardened-plans -->";
+
+export const SlowPowersPlugin = async ({ client, directory: _directory }) => {
   // Helper to load bootstrap content (cached after first call)
   const getBootstrapContent = () => {
     if (_bootstrapCache !== undefined) return _bootstrapCache;
@@ -40,6 +44,61 @@ export const SlowPowersPlugin = async ({
     return _bootstrapCache;
   };
 
+  const hashContent = (content) =>
+    createHash("sha256").update(content).digest("hex");
+
+  const isPlanHardened = (content) => content.includes(HARDENED_MARKER);
+
+  const handlePlanFileEdit = async (event) => {
+    const filePath = event.properties.file;
+    const sessionID = event.properties.sessionID;
+
+    if (!filePath || !sessionID) return;
+
+    if (!filePath.match(/\.opencode\/plans\/.*\.md$/)) return;
+
+    let session;
+    try {
+      session = await client.session.get({ path: { id: sessionID } });
+    } catch {
+      return;
+    }
+    if (session.agent !== "plan") return;
+
+    let content;
+    try {
+      content = fs.readFileSync(filePath, "utf8");
+    } catch {
+      return;
+    }
+
+    if (isPlanHardened(content)) return;
+
+    const contentHash = hashContent(content);
+    const previousHash = processedPlanHashes.get(filePath);
+    if (previousHash === contentHash) return;
+
+    processedPlanHashes.set(filePath, contentHash);
+
+    try {
+      await client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          noReply: true,
+          parts: [
+            {
+              type: "text",
+              text: `The plan at ${filePath} has been written. Please run the hardening-plans skill on this plan file to review it for hallucinations, missing file references, vague steps, and coverage gaps before presenting it. Update the file in place with the hardened version. Add ${HARDENED_MARKER} marker when done.`,
+            },
+          ],
+        },
+      });
+    } catch (err) {
+      processedPlanHashes.delete(filePath);
+      console.error("[slow-powers] Failed to trigger hardening-plans:", err);
+    }
+  };
+
   return {
     // Inject skills path into live config so OpenCode discovers slow-powers skills
     // without requiring manual symlinks or config file edits.
@@ -82,5 +141,10 @@ export const SlowPowersPlugin = async ({
 
       firstUser.parts.unshift({ type: "text", text: bootstrap });
     },
+
+    event: async ({ event }) => {
+      if (event.type !== "file.edited") return;
+      await handlePlanFileEdit(event);
+    },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slowdini/slow-powers-opencode",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Slow-powers — structured development workflows for coding agents (TDD, debugging, verification, git hygiene)",
   "type": "module",
   "main": "./opencode/plugins/slow-powers.js",
@@ -36,19 +36,19 @@
   },
   "scripts": {
     "test": "bun test --path-ignore-patterns='skills-workspace/**'",
-    "evals": "bun run skills/evaluating-skills/runner/run.ts --skill-dir ./skills --bootstrap ./bootstrap.md",
-    "evals:snapshot": "bun run skills/evaluating-skills/runner/run.ts snapshot --skill-dir ./skills",
-    "evals:validate": "bun run skills/evaluating-skills/runner/validate-all.ts --skill-dir ./skills",
-    "evals:ingest": "bun run skills/evaluating-skills/runner/run.ts ingest --skill-dir ./skills",
-    "evals:finalize": "bun run skills/evaluating-skills/runner/run.ts finalize --skill-dir ./skills",
-    "evals:record-runs": "bun run skills/evaluating-skills/runner/record-runs.ts --skill-dir ./skills",
-    "evals:fill-transcripts": "bun run skills/evaluating-skills/runner/fill-transcripts.ts --skill-dir ./skills",
-    "evals:detect-stray-writes": "bun run skills/evaluating-skills/runner/detect-stray-writes.ts --skill-dir ./skills",
-    "evals:teardown-guard": "bun run skills/evaluating-skills/runner/run.ts teardown-guard --skill-dir ./skills",
-    "evals:teardown": "bun run skills/evaluating-skills/runner/run.ts teardown --skill-dir ./skills",
-    "evals:grade": "bun run skills/evaluating-skills/runner/grade.ts --skill-dir ./skills",
-    "evals:aggregate": "bun run skills/evaluating-skills/runner/aggregate.ts --skill-dir ./skills",
-    "evals:promote-baseline": "bun run skills/evaluating-skills/runner/promote-baseline.ts --skill-dir ./skills",
+    "evals": "bunx @slowdini/eval-runner run --skill-dir ./skills --bootstrap ./bootstrap.md",
+    "evals:snapshot": "bunx @slowdini/eval-runner snapshot --skill-dir ./skills",
+    "evals:validate": "bunx @slowdini/eval-runner validate --skill-dir ./skills",
+    "evals:ingest": "bunx @slowdini/eval-runner ingest --skill-dir ./skills",
+    "evals:finalize": "bunx @slowdini/eval-runner finalize --skill-dir ./skills",
+    "evals:record-runs": "bunx @slowdini/eval-runner record-runs --skill-dir ./skills",
+    "evals:fill-transcripts": "bunx @slowdini/eval-runner fill-transcripts --skill-dir ./skills",
+    "evals:detect-stray-writes": "bunx @slowdini/eval-runner detect-stray-writes --skill-dir ./skills",
+    "evals:teardown-guard": "bunx @slowdini/eval-runner teardown-guard --skill-dir ./skills",
+    "evals:teardown": "bunx @slowdini/eval-runner teardown --skill-dir ./skills",
+    "evals:grade": "bunx @slowdini/eval-runner grade --skill-dir ./skills",
+    "evals:aggregate": "bunx @slowdini/eval-runner aggregate --skill-dir ./skills",
+    "evals:promote-baseline": "bunx @slowdini/eval-runner promote-baseline --skill-dir ./skills",
     "check": "biome check --write .",
     "check:ci": "biome check --error-on-warnings .",
     "typecheck": "tsc --noEmit",
@@ -62,8 +62,5 @@
     "husky": "^9.1.7",
     "lint-staged": "^17.0.4",
     "typescript": "^6.0.3"
-  },
-  "dependencies": {
-    "ajv": "^8.20.0"
   }
 }