@slowdini/slow-powers-opencode 0.1.3 → 0.1.5

package/skills/systematic-debugging/root-cause-tracing.md

@@ -8,19 +8,18 @@ Bugs often manifest deep in the call stack (git init in wrong directory, file cr
 
 ## When to Use
 
-```dot
-digraph when_to_use {
-    "Bug appears deep in stack?" [shape=diamond];
-    "Can trace backwards?" [shape=diamond];
-    "Fix at symptom point" [shape=box];
-    "Trace to original trigger" [shape=box];
-    "BETTER: Also add defense-in-depth" [shape=box];
-
-    "Bug appears deep in stack?" -> "Can trace backwards?" [label="yes"];
-    "Can trace backwards?" -> "Trace to original trigger" [label="yes"];
-    "Can trace backwards?" -> "Fix at symptom point" [label="no - dead end"];
-    "Trace to original trigger" -> "BETTER: Also add defense-in-depth";
-}
+```mermaid
+flowchart TD
+    deep{Bug appears deep in stack?}
+    trace{Can trace backwards?}
+    symptom[Fix at symptom point]
+    origin[Trace to original trigger]
+    defense["BETTER: Also add defense-in-depth"]
+
+    deep -->|yes| trace
+    trace -->|yes| origin
+    trace -->|no - dead end| symptom
+    origin --> defense
 ```
 
 **Use when:**
@@ -129,26 +128,25 @@ Runs tests one-by-one, stops at first polluter. See script for usage.
 
 ## Key Principle
 
-```dot
-digraph principle {
-    "Found immediate cause" [shape=ellipse];
-    "Can trace one level up?" [shape=diamond];
-    "Trace backwards" [shape=box];
-    "Is this the source?" [shape=diamond];
-    "Fix at source" [shape=box];
-    "Add validation at each layer" [shape=box];
-    "Bug impossible" [shape=doublecircle];
-    "NEVER fix just the symptom" [shape=octagon, style=filled, fillcolor=red, fontcolor=white];
-
-    "Found immediate cause" -> "Can trace one level up?";
-    "Can trace one level up?" -> "Trace backwards" [label="yes"];
-    "Can trace one level up?" -> "NEVER fix just the symptom" [label="no"];
-    "Trace backwards" -> "Is this the source?";
-    "Is this the source?" -> "Trace backwards" [label="no - keeps going"];
-    "Is this the source?" -> "Fix at source" [label="yes"];
-    "Fix at source" -> "Add validation at each layer";
-    "Add validation at each layer" -> "Bug impossible";
-}
+```mermaid
+flowchart TD
+    found(Found immediate cause)
+    canTrace{Can trace one level up?}
+    back[Trace backwards]
+    isSource{Is this the source?}
+    fix[Fix at source]
+    validate[Add validation at each layer]
+    impossible([Bug impossible])
+    never{{NEVER fix just the symptom}}
+
+    found --> canTrace
+    canTrace -->|yes| back
+    canTrace -->|no| never
+    back --> isSource
+    isSource -->|no - keeps going| back
+    isSource -->|yes| fix
+    fix --> validate
+    validate --> impossible
 ```
 
 **NEVER fix just where the error appears.** Trace back to find the original trigger.

package/skills/working-in-isolation/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: working-in-isolation
+description: Use when you're about to start code changes — a feature, bugfix, or refactor — to establish an isolated workspace so your work doesn't collide with existing or in-progress work.
+---
+
+# Working in Isolation
+
+Before changing code, make sure your work lands somewhere it won't collide with
+existing or in-progress work. Decide the workspace based on the git state.
+When in doubt, pause and ask the user.
+
+## Decision: where does this work go?
+
+Check the current state, then take the **first** matching rule:
+
+```bash
+git branch --show-current      # current branch
+git status --porcelain         # empty = clean tree
+git worktree list              # >1 entry = worktrees already exist
+```
+
+1. **The user named a workspace** (explicit command, or a configured preference)
+   → follow it.
+2. **Dirty tree (staged or unstaged changes) OR worktrees already exist**
+   → a human or another agent is mid-work here. Use a **new worktree** so your
+   changes can't collide with theirs.
+3. **On `dev` / `main` / `master`** → sync with origin and **check out a new
+   branch**. Keeps the base clean and makes the work easy to review.
+4. **On any other branch** → **work in place.** The user already isolated this
+   workspace; adding a worktree is needless ceremony.
+
+> **Hard rule: never make changes while on `dev` / `main` / `master`.** If you
+> find yourself on a base branch, branch (rule 3) or worktree (rule 2) first.
+
+## Creating a worktree (rule 2)
+
+Prefer the agent platform's **native isolation tool** if it has one. Otherwise
+fall back to a git worktree:
+
+```bash
+git worktree add .worktrees/<branch-name> -b <branch-name>
+cd .worktrees/<branch-name>
+```
+
+Keep the worktree out of version control: if `.worktrees/` isn't already
+git-ignored, add it to `.gitignore` and commit that first. If worktree creation
+fails (sandbox or permission limits), say so and fall back to checking out a
+branch in place (rule 3).
+
+## After the workspace is set
+
+Install dependencies and run the existing test suite once, to confirm a clean
+baseline before you write anything.
+
+Use the project-appropriate commands to verify the baseline is clean - lint, test, build.
+
+If the baseline is already failing, report it before starting — you need to know
+which failures you introduced.

package/skills/working-in-isolation/evals/baseline/BASELINE.md

@@ -0,0 +1,22 @@
+# Baseline — working-in-isolation
+
+Committed reference output from a canonical eval run. Regenerate with
+`bun run evals:promote-baseline -- --skill working-in-isolation --iteration <N>` after aggregating. The ephemeral workspace (run records, timing,
+dispatch files, produced outputs) stays gitignored under `skills-workspace/`.
+
+| Field | Value |
+|-------|-------|
+| Mode | new-skill |
+| Iteration | iteration-3 |
+| Harness | claude-code |
+| Agent model | claude-sonnet-4-6 |
+| Judge model | claude-sonnet-4-6 |
+| Conditions | with_skill, without_skill |
+| Run timestamp | 2026-06-03T07:33:13.084Z |
+| Label | (none) |
+| Promoted from commit | e428b0e |
+
+Files:
+- `benchmark.json` — aggregate pass-rate / duration / token deltas.
+- `grading/<eval-id>__<condition>.json` — per-run assertion results and judge rationales.
+

package/skills/working-in-isolation/evals/baseline/NOTES.md

@@ -0,0 +1,67 @@
+# Baseline notes — working-in-isolation
+
+Forward-looking observations from the canonical run (`new-skill`, iteration-3,
+`claude-sonnet-4-6` agent + judge). Provenance is in `BASELINE.md`; headline
+numbers are in `benchmark.json`. This file is the "what a future iterator should
+know" companion.
+
+## Headline
+
+`with_skill` 0.80 vs `without_skill` 0.20 → **+0.60 pass-rate delta**, skill
+invocation **100% (5/5)**, **0 validity warnings**. Cost: +8.2s, +1.2k tokens.
+
+## Which cases discriminated
+
+| Case | with | without | Notes |
+|------|------|---------|-------|
+| `base-branch-checkout` | 100% | 0% | The most important check (never edit on `main`). Clean +100%. |
+| `dirty-tree-worktree` | 100% | 0% | +100% **this run**. The `without` arm did *not* isolate here — see variance note. |
+| `seeded-on-main-momentum` | 100% | 0% | +100%. Both seeded assertions passed (stops editing on `main` AND names the base-branch hard rule). |
+| `feature-branch-in-place` | 100% | 100% | Non-discriminating — the "work in place" case is easy enough that baseline gets it too. Candidate for a harder variant. |
+| `typo-no-worktree` | 0% | 0% | Non-discriminating + environment-confounded — see below. |
+
+## Caveats a re-runner must know
+
+- **`typo-no-worktree` is confounded by the real repo's branch state.** The
+  prompt says "On my working branch `docs-cleanup`", but the eval runs in the
+  actual slow-powers repo, which has no `docs-cleanup` branch and is on a
+  different branch. Agents that introspect real git state (both arms) discover
+  the branch is missing and propose creating it — graded as "isolation
+  ceremony" → both FAIL, delta 0. This is **symmetric** (hurts both arms
+  equally), so it doesn't bias the delta, but it means the case currently
+  measures nothing. To make it discriminating, either (a) state the full git
+  context in the prompt the way `base-branch-checkout` does ("you are on
+  `docs-cleanup`, clean tree"), or (b) give each subagent an isolated throwaway
+  repo whose real state matches the prompt.
+
+- **Iteration-2 vs iteration-3 — why the delta jumped (+0.30 → +0.60).**
+  Iteration-2 dispatched all 10 subagents *in parallel against this one shared,
+  dirty repo*. Per the skill's own Rule 2 ("dirty tree **or** worktrees already
+  exist → worktree"), agents that ran real `git status`/`git worktree list` saw
+  (a) the repo's then-uncommitted #156 changes and (b) worktrees other parallel
+  siblings had just created, and so isolated when the case wanted work-in-place
+  — contaminating `typo` and depressing the measured delta. Iteration-3 fixed
+  this by **committing the tree clean first** and **dispatching sequentially
+  with `.worktrees/` cleanup between each dispatch**, so no agent sees another's
+  git state. Lesson for any git-state-dependent skill: do **not** run its eval
+  subagents concurrently in one shared repo.
+
+- **The write guard does not block worktree creation.** `runner/sandbox-policy.ts`
+  `BASH_MUTATION_PATTERNS` matches `git (commit|add|push|checkout|reset|restore|merge|rebase)`
+  — **not** `git worktree`. So `--guard` lets subagents `git worktree add` real
+  worktrees into the repo; `detect-stray-writes` only flags them post-hoc. We
+  cleaned them by hand both runs. Conveniently this also means the orchestrator's
+  own `git worktree remove` between-dispatch cleanup is allowed under the armed
+  guard. If we want the guard to actually sandbox this skill's behavior, add
+  `worktree` to the mutation pattern (track as an eval-harness parity item).
+
+## Variance / next-iteration ideas
+
+- `without_skill` on `dirty-tree-worktree` is **unstable**: iteration-2 it
+  isolated (PASS), iteration-3 it didn't (FAIL). The explicit "don't disturb my
+  in-progress changes" phrasing sometimes elicits isolation even with no skill.
+  Add runs (n>1 per condition) before trusting that case's delta.
+- `feature-branch-in-place` passes in both arms — replace or harden it (e.g.
+  add a competing attractor) so it earns its slot.
+- Consider a second seeded case where the cleaner correction is a **worktree**
+  rather than `switch -c`, to cover the other branch of the hard rule.

package/skills/working-in-isolation/evals/baseline/benchmark.json

@@ -0,0 +1,51 @@
+{
+  "generated": "2026-06-03T07:50:45.496Z",
+  "mode": "new-skill",
+  "conditions_compared": ["with_skill", "without_skill"],
+  "missing_gradings": 0,
+  "validity_warnings": [],
+  "run_summary": {
+    "with_skill": {
+      "pass_rate": {
+        "mean": 0.8,
+        "stddev": 0.4,
+        "n": 5
+      },
+      "duration_ms": {
+        "mean": 47222,
+        "stddev": 13874,
+        "n": 5
+      },
+      "total_tokens": {
+        "mean": 16696,
+        "stddev": 917,
+        "n": 5
+      },
+      "skill_invocation_n": 5,
+      "skill_invocation_rate": 1
+    },
+    "without_skill": {
+      "pass_rate": {
+        "mean": 0.2,
+        "stddev": 0.4,
+        "n": 5
+      },
+      "duration_ms": {
+        "mean": 39003,
+        "stddev": 12238,
+        "n": 5
+      },
+      "total_tokens": {
+        "mean": 15475,
+        "stddev": 1473,
+        "n": 5
+      }
+    }
+  },
+  "delta": {
+    "direction": "with_skill - without_skill",
+    "pass_rate": 0.6,
+    "duration_ms": 8219,
+    "total_tokens": 1221
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/base-branch-checkout__with_skill.json

@@ -0,0 +1,46 @@
+{
+  "assertion_results": [
+    {
+      "id": "did_not_edit_on_base_branch",
+      "passed": true,
+      "evidence": "The agent made no edits to src/http/client.ts or any code file while on main; its final_message explicitly states 'Before touching src/http/client.ts, I need to set up an isolated workspace' and plans to run `git checkout -b feat/http-retry-backoff` before writing any code.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    },
+    {
+      "id": "checked_out_branch",
+      "passed": true,
+      "evidence": "The agent explicitly proposed 'git checkout -b feat/http-retry-backoff' after syncing with origin via 'git pull origin main', and stated 'Making changes directly on `main` is prohibited' — demonstrating recognition of the base-branch rule and choosing a new branch rather than a worktree or working in place.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    },
+    {
+      "id": "ran_branch_command",
+      "passed": true,
+      "evidence": "matched ordinal 2: Bash {\"command\":\"git branch --show-current && git status --porcelain && git worktree list\",\"description\":\"Check current branch, tree cleanliness, and worktrees\"}",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "summary": {
+    "passed": 3,
+    "failed": 0,
+    "total": 3,
+    "pass_rate": 1
+  },
+  "meta_results": [
+    {
+      "id": "__skill_invoked",
+      "passed": true,
+      "evidence": "Skill invocation verified from transcript.",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "meta_summary": {
+    "passed": 1,
+    "failed": 0,
+    "total": 1,
+    "skill_invoked": true
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/base-branch-checkout__without_skill.json

@@ -0,0 +1,31 @@
+{
+  "assertion_results": [
+    {
+      "id": "did_not_edit_on_base_branch",
+      "passed": false,
+      "evidence": "The agent never issued a git checkout or branch-creation command (no such tool invocation exists in the record) and its final message claims 'I've added retry-with-backoff to `src/http/client.ts`' — confirming it made (or purported to make) the edit while still on `main`.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    },
+    {
+      "id": "checked_out_branch",
+      "passed": false,
+      "evidence": "The agent never checked out a new branch. Its tool invocations show only directory checks and a file write; its final_message describes implementing the feature directly with no mention of branch management. It worked in place on `main`.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    },
+    {
+      "id": "ran_branch_command",
+      "passed": false,
+      "evidence": "no tool invocation matched /git (checkout -b|switch -c|branch )/ across 5 invocation(s)",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "summary": {
+    "passed": 0,
+    "failed": 3,
+    "total": 3,
+    "pass_rate": 0
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/dirty-tree-worktree__with_skill.json

@@ -0,0 +1,39 @@
+{
+  "assertion_results": [
+    {
+      "id": "isolated_in_worktree",
+      "passed": true,
+      "evidence": "Agent ran `git worktree add .worktrees/feature/users-pagination -b feature/users-pagination` (ordinal 4) and the final message confirms: \"Workspace created: `.worktrees/feature/users-pagination` (branch `feature/users-pagination`) ... The worktree is a completely separate working tree — your modified files in the main checkout are untouched.\"",
+      "confidence": 1,
+      "grader": "llm_judge"
+    },
+    {
+      "id": "created_worktree",
+      "passed": true,
+      "evidence": "matched ordinal 4: Bash {\"command\":\"git worktree add /Users/maximilianhaarhaus/Projects/slow-powers/.worktrees/feature/users-pagination -b feature/users-pagination 2>&1\",\"description\":\"Create a new worktree for the pagi",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "summary": {
+    "passed": 2,
+    "failed": 0,
+    "total": 2,
+    "pass_rate": 1
+  },
+  "meta_results": [
+    {
+      "id": "__skill_invoked",
+      "passed": true,
+      "evidence": "Skill invocation verified from transcript.",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "meta_summary": {
+    "passed": 1,
+    "failed": 0,
+    "total": 1,
+    "skill_invoked": true
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/dirty-tree-worktree__without_skill.json

@@ -0,0 +1,24 @@
+{
+  "assertion_results": [
+    {
+      "id": "isolated_in_worktree",
+      "passed": false,
+      "evidence": "The agent never created or entered a worktree. It checked git status, found no dirty files, and then wrote generic pagination code examples to a markdown file. The final message says 'I haven't modified any files in the working tree' and 'Share the relevant endpoint file if you'd like me to make the edit directly' — confirming no isolation mechanism was used and no actual code changes were made in any workspace.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    },
+    {
+      "id": "created_worktree",
+      "passed": false,
+      "evidence": "no tool invocation matched /git worktree add/ across 5 invocation(s)",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "summary": {
+    "passed": 0,
+    "failed": 2,
+    "total": 2,
+    "pass_rate": 0
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/feature-branch-in-place__with_skill.json

@@ -0,0 +1,32 @@
+{
+  "assertion_results": [
+    {
+      "id": "worked_in_place_no_ceremony",
+      "passed": true,
+      "evidence": "final_message states: 'You're on `feature/payment-retry` with a clean working tree and a single worktree — rule 4 of the working-in-isolation skill applies: work in place. No new branch or worktree is needed; your branch is already the isolated workspace.' Tool invocations confirm no `git worktree add` or `git checkout -b` was issued — the agent inspected the workspace and proceeded directly to writing files on the existing branch.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    }
+  ],
+  "summary": {
+    "passed": 1,
+    "failed": 0,
+    "total": 1,
+    "pass_rate": 1
+  },
+  "meta_results": [
+    {
+      "id": "__skill_invoked",
+      "passed": true,
+      "evidence": "Skill invocation verified from transcript.",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "meta_summary": {
+    "passed": 1,
+    "failed": 0,
+    "total": 1,
+    "skill_invoked": true
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/feature-branch-in-place__without_skill.json

@@ -0,0 +1,17 @@
+{
+  "assertion_results": [
+    {
+      "id": "worked_in_place_no_ceremony",
+      "passed": true,
+      "evidence": "No worktree creation or branch checkout appears in the tool invocations (ordinals 0–7). The agent read the prompt, invoked the TDD skill, checked the output directory, and wrote files directly. The final message confirms the work landed on the current branch: 'Done. Here’s what was added to `feature/payment-retry`'.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    }
+  ],
+  "summary": {
+    "passed": 1,
+    "failed": 0,
+    "total": 1,
+    "pass_rate": 1
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/seeded-on-main-momentum__with_skill.json

@@ -0,0 +1,39 @@
+{
+  "assertion_results": [
+    {
+      "id": "stops_editing_on_main",
+      "passed": true,
+      "evidence": "The agent explicitly refused to touch any code first: 'Before touching any code, I need to get off `main` — the previous change landed directly on the base branch, which is something I should have caught earlier.' It then issued `git checkout -b feat/api-client-resilience` before presenting any code changes, and the timeout/retry implementation is shown only after the branch creation command.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    },
+    {
+      "id": "names_base_branch_hard_rule",
+      "passed": true,
+      "evidence": "\"Before touching any code, I need to get off `main` — the previous change landed directly on the base branch, which is something I should have caught earlier. Let me set that right now.\" followed by `git checkout -b feat/api-client-resilience`",
+      "confidence": 1,
+      "grader": "llm_judge"
+    }
+  ],
+  "summary": {
+    "passed": 2,
+    "failed": 0,
+    "total": 2,
+    "pass_rate": 1
+  },
+  "meta_results": [
+    {
+      "id": "__skill_invoked",
+      "passed": true,
+      "evidence": "Skill invocation verified from transcript.",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "meta_summary": {
+    "passed": 1,
+    "failed": 0,
+    "total": 1,
+    "skill_invoked": true
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/seeded-on-main-momentum__without_skill.json

@@ -0,0 +1,24 @@
+{
+  "assertion_results": [
+    {
+      "id": "stops_editing_on_main",
+      "passed": false,
+      "evidence": "The final_message confirms the agent continued editing directly on main: 'Done. Here’s what I added to `src/api/client.ts`' with no mention of creating a branch or worktree, treating the user's 'while you’re in there' as license to keep editing in place.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    },
+    {
+      "id": "names_base_branch_hard_rule",
+      "passed": false,
+      "evidence": "The final_message contains only the timeout and retry implementation ('Done. Here’s what I added to `src/api/client.ts`...No other behaviour changes — all existing call sites work as before.') with no mention of `main` being a base branch, no suggestion to create an isolation branch, and no acknowledgment that working directly on `main` is a problem.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    }
+  ],
+  "summary": {
+    "passed": 0,
+    "failed": 2,
+    "total": 2,
+    "pass_rate": 0
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/typo-no-worktree__with_skill.json

@@ -0,0 +1,32 @@
+{
+  "assertion_results": [
+    {
+      "id": "no_isolation_ceremony",
+      "passed": false,
+      "evidence": "The agent created a new branch from dev: 'Since `docs-cleanup` didn't exist yet, I created it from `dev` (synced with origin first), then switched to it: git checkout dev / git pull origin dev / git checkout -b docs-cleanup'. This is branch isolation ceremony applied to a one-character typo fix, which the assertion says should FAIL.",
+      "confidence": 0.97,
+      "grader": "llm_judge"
+    }
+  ],
+  "summary": {
+    "passed": 0,
+    "failed": 1,
+    "total": 1,
+    "pass_rate": 0
+  },
+  "meta_results": [
+    {
+      "id": "__skill_invoked",
+      "passed": true,
+      "evidence": "Skill invocation verified from transcript.",
+      "confidence": 1,
+      "grader": "transcript_check"
+    }
+  ],
+  "meta_summary": {
+    "passed": 1,
+    "failed": 0,
+    "total": 1,
+    "skill_invoked": true
+  }
+}

package/skills/working-in-isolation/evals/baseline/grading/typo-no-worktree__without_skill.json

@@ -0,0 +1,17 @@
+{
+  "assertion_results": [
+    {
+      "id": "no_isolation_ceremony",
+      "passed": false,
+      "evidence": "The agent attempted to create a new branch for the typo fix (tool_invocations ordinal 2: `git checkout -b docs-cleanup`) and the final_message explicitly proposes 'Create the `docs-cleanup` branch off the current working branch' as step 1, treating the one-character edit as requiring branch isolation rather than fixing the typo in place.",
+      "confidence": 1,
+      "grader": "llm_judge"
+    }
+  ],
+  "summary": {
+    "passed": 0,
+    "failed": 1,
+    "total": 1,
+    "pass_rate": 0
+  }
+}