@loneexile/omp-superpowers 7.0.1-omp.4 → 7.0.2-omp.2

package/skills/executing-plans/SKILL.md

@@ -153,7 +153,8 @@ The workspace and ledger are shared with superpowers:subagent-driven-development
 and the new one resumes from the same ledger.
 
 - Each plan owns a workspace: at skill start, run
-  `../subagent-driven-development/scripts/sdd-workspace PLAN_FILE` — it
+  `../subagent-driven-development/scripts/sdd-workspace PLAN_FILE` by its
+  absolute path, from the working tree you're executing in — it
   prints the plan's git-ignored directory
   (`<repo-root>/.superpowers/sdd/<plan-basename>/`), home to every
   artifact for THIS plan: ledger, briefs, review packages. Another plan's
@@ -175,8 +176,9 @@ and the new one resumes from the same ledger.
   if that happens, recover from `git log`.
 - **On omp, resolve the scripts directories first.** The relative paths in
   this skill (`scripts/task-start`, `../subagent-driven-development/scripts/…`)
-  do not resolve from the repo root, and `omp read skill://…` lists the files
-  but gives no filesystem path. Once, before the first script, run
+  do not resolve from the repo root, so each script runs by its absolute path,
+  and `omp read skill://…` lists the files but gives no filesystem path. Once,
+  before the first script, run
   `realpath skill://executing-plans/scripts` and
   `realpath skill://subagent-driven-development/scripts` in the `bash` tool
   and add the printed paths to the ledger, after the identity line, as
@@ -187,11 +189,11 @@ and the new one resumes from the same ledger.
   `rtk ls`. Use the printed paths everywhere else. Ledger lines are found by
   their prefix, never by position. This ledger is shared with
   subagent-driven-development, which writes only `SDD scripts:`: add
-  whichever of the two lines it lacks. Then run
-  each script as `bash <dir>/<name>` — `scripts/task-start` and
-  `scripts/task-done` from the executing-plans directory, `sdd-workspace` and
-  `review-package` from the SDD one — with the working directory at the repo
-  root; the scripts call `git rev-parse`. The invocation lines in this skill
+  whichever of the two lines it lacks. Then run each script by its
+  absolute path, `bash <dir>/<name>`, from the working tree you're executing
+  in (the scripts act on its repository, as git does): `task-start` and
+  `task-done` from the executing-plans directory, `sdd-workspace` and
+  `review-package` from the SDD one. The invocation lines in this skill
   stay as upstream wrote them.
 
 Read the plan once, note its context and Global Constraints, and create a
@@ -223,7 +225,8 @@ in the workspace and read its tail; read a brief, not the whole plan.
 
 ### 1. Take the task
 
-- Run this skill's `scripts/task-start PLAN_FILE N`. It prints the brief
+- Run this skill's `scripts/task-start PLAN_FILE N` by its absolute path,
+  from the working tree you're executing in. It prints the brief
   path and BASE (the commit the task's range is cut from) in one call.
   Read the brief for every task, including ones you remember from setup:
   what you remember is a summary, the brief has the exact values,
@@ -276,7 +279,7 @@ the claim. If any item is missing, the task is not complete: finish it.
 ### 4. Complete the task
 
 Run this skill's `scripts/task-done PLAN_FILE N BASE -- <test command>`
-with the test command the brief names for the whole task. It runs the
+by its absolute path, from the working tree you're executing in, with the test command the brief names for the whole task. It runs the
 tests, keeps the full output in the workspace, prints the tail, and — only
 if they pass — appends the completion line to the ledger:
 
@@ -288,7 +291,7 @@ mark the todo complete and take the next task.
 ## Final Review
 
 Run `../subagent-driven-development/scripts/review-package PLAN_FILE MERGE_BASE HEAD`
-(MERGE_BASE = the commit the branch started from, e.g.
+by its absolute path, from the working tree you're executing in (MERGE_BASE = the commit the branch started from, e.g.
 `git merge-base main HEAD`) and review from the file it prints.
 
 **With a subagent tool:** dispatch the reviewer on the most capable

package/skills/executing-plans/scripts/task-done

@@ -20,7 +20,10 @@ base=$3
 shift 4
 sdd="$(cd "$(dirname "$0")/../../subagent-driven-development/scripts" && pwd)"
 
-git rev-parse --verify --quiet "$base" >/dev/null || { echo "bad BASE: $base" >&2; exit 2; }
+# The repository the workspace and ledger belong to (see sdd-repo); BASE and
+# HEAD are read there, not in the bare cwd.
+repo=$("${BASH:-bash}" "$sdd/sdd-repo" --with-commit)
+git -C "$repo" rev-parse --verify --quiet "$base" >/dev/null || { echo "bad BASE: $base" >&2; exit 2; }
 
 dir=$("$sdd/sdd-workspace" "$plan")
 log="$dir/task-${n}-tests.log"
@@ -47,6 +50,6 @@ fi
 
 last=$(grep -v '^[[:space:]]*$' "$log" | tail -n 1) || last="(no output)"
 [ -f "$ledger" ] || printf '# SDD ledger — plan: %s\n' "$plan" > "$ledger"
-line="Task $n: complete (commits $(git rev-parse --short=7 "$base")..$(git rev-parse --short=7 HEAD), tests: $cmd → $last)"
+line="Task $n: complete (commits $(git -C "$repo" rev-parse --short=7 "$base")..$(git -C "$repo" rev-parse --short=7 HEAD), tests: $cmd → $last)"
 printf '%s\n' "$line" >> "$ledger"
 echo "ledger: $line"

package/skills/executing-plans/scripts/task-start

@@ -20,9 +20,13 @@ plan=$1
 n=$2
 sdd="$(cd "$(dirname "$0")/../../subagent-driven-development/scripts" && pwd)"
 
+# BASE comes from the same repository the brief is written into (sdd-repo
+# also refuses one with no commit yet), not from the bare cwd.
+repo=$("${BASH:-bash}" "$sdd/sdd-repo" --with-commit)
 out=$("$sdd/task-brief" "$plan" "$n")
 brief=$(printf '%s\n' "$out" | sed -n 's/^wrote \(.*\): [0-9][0-9]* lines$/\1/p')
 [ -n "$brief" ] || { echo "task-brief did not report a path: $out" >&2; exit 1; }
+base=$(git -C "$repo" rev-parse --verify HEAD)
 
 echo "brief: $brief"
-echo "base: $(git rev-parse HEAD)"
+echo "base: $base"

package/skills/finishing-a-development-branch/SKILL.md

@@ -43,6 +43,15 @@ This determines which menu to show and how cleanup works:
 | `GIT_DIR != GIT_COMMON`, named branch | Standard 3 options | Provenance-based (see Step 6) |
 | `GIT_DIR != GIT_COMMON`, detached HEAD | Reduced 2 options (no merge) | Externally managed — leave in place |
 
+**On omp, check for an ovnfs checkout too:** `git config --get ovnfs.checkout`
+prints the checkout's name inside one and nothing elsewhere. An ovnfs
+checkout is a copy-on-write copy of your human partner's folder with its
+own private git directory. The table calls it a normal repo
+(`GIT_DIR == GIT_COMMON`), but nothing committed in it is in their
+repository until it is applied, and the `MAIN_ROOT` lines below fail there
+(`fatal: not a git repository`). Present the standard 3 options and carry
+out the choice as *In an ovnfs checkout* (end of Step 5) says.
+
 ## Step 3: Determine Base Branch
 
 The base branch is whatever this work forked from — usually named in the
@@ -160,6 +169,47 @@ git switch <base-branch>   # normal repo only
 git branch -D <feature-branch>
 ```
 
+### In an ovnfs checkout
+
+`<checkout>` is the name Step 2 printed. Your human partner's repository is
+the folder `ovnfs ls` lists as that checkout's SOURCE. Run these from the
+checkout, still on `<feature-branch>`: ovnfs applies the checkout's HEAD.
+
+**Option 1:**
+
+```bash
+ovnfs apply <checkout> --branch <feature-branch>
+```
+
+That makes the checkout's commits `<feature-branch>` in the folder's
+repository and changes no file there. Then merge in the folder, with the
+`bash` tool's `cwd` set to it: if `git branch --show-current` prints
+`<base-branch>` and `git status --porcelain` prints nothing, run `git pull`,
+`git merge <feature-branch>` and the tests there, and once they pass,
+`git branch -d <feature-branch>`. Otherwise stop and tell your human partner
+that `<feature-branch>` is now in their repository and why you did not
+merge it. `ovnfs apply <checkout> --branch <base-branch>` while the folder
+has `<base-branch>` checked out moves that branch and its index but leaves
+the folder's files as they were, so the merge shows there as uncommitted
+changes that undo it. Plain `ovnfs apply <checkout>`, without `--branch`,
+brings the changes back as uncommitted edits, without the commits.
+
+**Option 2:** as above; the push goes from the checkout.
+
+**Option 3:** report "Keeping branch <name> in ovnfs checkout <checkout>
+(<path>). `ovnfs apply <checkout> --branch <name>` puts it in your
+repository."
+
+**Discard:** in the checkout, `git switch <base-branch>` and
+`git branch -D <feature-branch>`. The branch never reached the folder.
+
+**The checkout itself:** after Option 1 or a discard, remove it with
+`ovnfs rm <checkout>`, run from the folder, only if this session opened it
+with `ovnfs new`, the session's working directory is not inside it, and
+`git status --porcelain` in it prints nothing. Otherwise leave it and tell
+your human partner that `ovnfs rm <checkout>`, run from their folder,
+removes it.
+
 ## Step 6: Cleanup Workspace
 
 **Runs for Option 1 and confirmed discards.** Options 2 and 3 always

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

@@ -191,7 +191,8 @@ sequences — the single most expensive failure observed. Track progress in
 a ledger file, not only in todos.
 
 - Each plan owns a workspace: at skill start, run this skill's
-  `bash scripts/sdd-workspace PLAN_FILE` — it prints the plan's git-ignored
+  `bash scripts/sdd-workspace PLAN_FILE` by its absolute path, from the
+  working tree you're executing in — it prints the plan's git-ignored
   directory (under `<repo-root>/.superpowers/sdd/`), home to
   every artifact for THIS plan: ledger, briefs, reports, review packages.
   Another plan's directory is never yours to read or write.
@@ -497,7 +498,8 @@ the review package and fix-round diffs need it. Every task in a wave shares
 the wave's BASE.
 
 - **Task brief:** before dispatching an implementer, run this skill's
-  `bash scripts/task-brief PLAN_FILE N` — it extracts the task's full text to a
+  `bash scripts/task-brief PLAN_FILE N` by its absolute path, from the
+  working tree you're executing in — it extracts the task's full text to a
   uniquely named file and prints the path. Compose the dispatch so the
   brief stays the single source of
   requirements. Your dispatch should contain: (1) one line on where this
@@ -573,6 +575,20 @@ the wave's BASE.
   omp worktree add -b "sdd/<plan>/task-<N>" ~/.omp/wt/"$repo-<plan>-task-<N>"
   ```
 
+  **With ovnfs on PATH, wave tasks still use `omp worktree add`,** though
+  omp's system prompt then asks for ovnfs checkouts as second copies. A
+  wave task's branch must be in the plan checkout's repository, where the
+  review packages and the merge read it. `omp worktree add` puts it there,
+  inside an ovnfs checkout too. An ovnfs checkout keeps its commits in its
+  own private git directory, and its `ovnfs apply --branch` writes them to
+  the folder ovnfs copied, which is not the plan checkout when the plan
+  checkout is an ovnfs checkout itself. If a wave task's copy is an ovnfs
+  checkout anyway, bring its branch into the plan checkout with
+  `git fetch <its path> sdd/<plan>/task-<N>:sdd/<plan>/task-<N>` before
+  each review package and before the merge, never with `ovnfs apply`, and
+  remove it with `ovnfs rm <name>` where this skill says
+  `git worktree remove`.
+
   `<plan>` is the plan file's name without `.md`;
   superpowers:using-git-worktrees says why `omp worktree add` and
   `~/.omp/wt/`. Then, in each new worktree and before dispatching, run the
@@ -627,7 +643,7 @@ your own checkout gained no changes. A task that wrote into your checkout
 goes back to its implementer with the paths. Then check the task's line in
 the review list.
 
-- **`review per-task`:** generate the review package (`bash scripts/review-package PLAN_FILE BASE HEAD`, from this skill's directory — it prints the unique file path it wrote; BASE is the commit you recorded before dispatching the implementer — never `HEAD~1`, which silently drops all but the last commit of a multi-commit task; for a wave task, its branch `sdd/<plan>/task-<N>` stands in for HEAD), then dispatch `sdd-reviewer` with the printed path.
+- **`review per-task`:** generate the review package (`bash scripts/review-package PLAN_FILE BASE HEAD` by its absolute path, from the working tree you're executing in — it prints the unique file path it wrote; BASE is the commit you recorded before dispatching the implementer — never `HEAD~1`, which silently drops all but the last commit of a multi-commit task; for a wave task, its branch `sdd/<plan>/task-<N>` stands in for HEAD), then dispatch `sdd-reviewer` with the printed path.
 - **`review at final`:** run the covering test command from the brief yourself, once, in the task's checkout, with its output redirected to a file in the plan's workspace; read the tail. A brief that names no test (docs, configuration) gets the cheapest check that can fail instead (a build, a lint, a parse), or goes on the review list. That run is the only check this task gets before the final review, so never take the implementer's report in its place. A pass completes the task (step 5). A failure goes back to the implementer with the output file's path: rounds 1-2 resume it, round 3 is a fresh `sdd-escalation-implementer`, as in the fix loop, and each round ends when your rerun passes, with no re-review. A failure after round 3 is a plan the tests disagree with: stop and ask.
 
 **DONE_WITH_CONCERNS:** The implementer completed the work but flagged doubts. Read the concerns before proceeding. If the concerns are about correctness or scope, address them before review, and put a `review at final` task on the review list (`Task <N>: review per-task — <concern>`). A wave task that changed a file outside its brief's Files list broke its wave's independence: merge it after its wave's other tasks, and run their covering tests too on the merged tree. If the concerns are observations (e.g., "this file is getting large"), note them and proceed.
@@ -666,7 +682,8 @@ self-review never replaces a review: for a listed task the task review is
 it, for any other the final review is.
 
 - Hand the reviewer its diff as a file: run this skill's
-  `bash scripts/review-package PLAN_FILE BASE HEAD` and pass the reviewer the file path
+  `bash scripts/review-package PLAN_FILE BASE HEAD` by its absolute path, from
+  the working tree you're executing in, and pass the reviewer the file path
   it prints (or, without bash: `git log --oneline`, `git diff --stat`,
   and `git diff -U10` for the range, redirected to one uniquely named
   file). The output never enters your own context, and the reviewer sees
@@ -802,7 +819,8 @@ covering test files in the fix message — a one-line fix does not need the
 whole suite.
 
 **The re-review is scoped.** Run `bash scripts/review-package PLAN_FILE FIX_BASE HEAD`
-where FIX_BASE is the head the previous review saw, as a commit SHA (for a
+by its absolute path, from the working tree you're executing in, where
+FIX_BASE is the head the previous review saw, as a commit SHA (for a
 wave task, its branch tip then: `git rev-parse sdd/<plan>/task-<N>`; never
 the branch name, which moves with the fix), and dispatch
 `sdd-rereviewer` with [re-review-prompt.md](re-review-prompt.md): the
@@ -938,7 +956,8 @@ the cap.
 ## Final Review
 
 The final whole-branch review gets a package too: run
-`bash scripts/review-package PLAN_FILE MERGE_BASE HEAD` (MERGE_BASE = the commit the
+`bash scripts/review-package PLAN_FILE MERGE_BASE HEAD` by its absolute path,
+from the working tree you're executing in (MERGE_BASE = the commit the
 branch started from, e.g. `git merge-base main HEAD`) and include the
 printed path in the final review dispatch, so the final reviewer reads
 one file instead of re-deriving the branch diff with git commands. Dispatch
@@ -970,7 +989,8 @@ with the complete findings list — not one fixer per finding.
 Per-finding fixers each rebuild context and re-run suites; a real
 session's final-review fix wave cost more than all its tasks combined.
 Then run exactly one scoped re-review of the fix wave
-(`bash scripts/review-package PLAN_FILE FIX_BASE HEAD` over the fix range,
+(`bash scripts/review-package PLAN_FILE FIX_BASE HEAD` by its absolute path,
+from the working tree you're executing in, over the fix range,
 [re-review-prompt.md](re-review-prompt.md)).
 Adjudicate any residual findings as in the task loop's breaker: park with
 rulings, or rule on the load-bearing ones and ledger what you decided. Only

package/skills/subagent-driven-development/re-review-prompt.md

@@ -118,6 +118,7 @@ that the fix itself broke nothing.
 - `[HEAD_SHA]` — current commit; for a wave task that has not merged yet,
   its branch tip (`git rev-parse sdd/<plan>/task-<N>`)
 - `[DIFF_FILE]` — the path `bash scripts/review-package PLAN_FILE FIX_BASE HEAD` printed
+  (run by its absolute path, from the working tree you're executing in)
 - `[CHECKOUT_LINE]` — same as the task reviewer's: the worktree line for a wave
   task that has not merged yet, omitted otherwise
 

package/skills/subagent-driven-development/scripts/review-package

@@ -4,13 +4,22 @@
 # call. Using the recorded per-task BASE (not HEAD~1) keeps multi-commit
 # tasks intact.
 #
-# Usage: review-package PLAN_FILE BASE HEAD [OUTFILE]
+# Usage: review-package [-C DIR] PLAN_FILE BASE HEAD [OUTFILE]
 # Default OUTFILE: <repo-root>/.superpowers/sdd/<plan-basename>/review-<base7>..<head7>.diff
 # (named per range, so a re-review after fixes gets a distinct fresh file).
+# The repository is the one sdd-repo names; -C DIR runs as if started in DIR,
+# as in sdd-workspace.
 set -euo pipefail
 
+here=$(cd "$(dirname "$0")" && pwd)
+if [ "${1:-}" = "-C" ]; then
+  [ -d "${2:-}" ] || { echo "bad -C directory: ${2:-}" >&2; exit 2; }
+  cd "$2"
+  shift 2
+fi
+
 if [ $# -lt 3 ] || [ $# -gt 4 ]; then
-  echo "usage: review-package PLAN_FILE BASE HEAD [OUTFILE]" >&2
+  echo "usage: review-package [-C DIR] PLAN_FILE BASE HEAD [OUTFILE]" >&2
   exit 2
 fi
 
@@ -19,35 +28,37 @@ base=$2
 head=$3
 [ -f "$plan" ] || { echo "no such plan file: $plan" >&2; exit 2; }
 
-git rev-parse --verify --quiet "$base" >/dev/null || { echo "bad BASE: $base" >&2; exit 2; }
-git rev-parse --verify --quiet "$head" >/dev/null || { echo "bad HEAD: $head" >&2; exit 2; }
+# Invoke via bash rather than direct exec: some extractors (Python zipfile)
+# strip Unix exec bits when unpacking marketplace packages (#2040).
+repo=$("${BASH:-bash}" "$here/sdd-repo" --with-commit)
+
+git -C "$repo" rev-parse --verify --quiet "$base" >/dev/null || { echo "bad BASE: $base" >&2; exit 2; }
+git -C "$repo" rev-parse --verify --quiet "$head" >/dev/null || { echo "bad HEAD: $head" >&2; exit 2; }
 
 # Range guards (exit 3): a wrong-branch HEAD yields a range that is empty or
 # not rooted at BASE; either would silently produce a bogus review package.
-git merge-base --is-ancestor "$base" "$head" || { echo "HEAD is not a descendant of BASE: ${base}..${head}" >&2; exit 3; }
-[ "$(git rev-list --count "${base}..${head}")" -gt 0 ] || { echo "empty commit range: ${base}..${head}" >&2; exit 3; }
+git -C "$repo" merge-base --is-ancestor "$base" "$head" || { echo "HEAD is not a descendant of BASE: ${base}..${head}" >&2; exit 3; }
+[ "$(git -C "$repo" rev-list --count "${base}..${head}")" -gt 0 ] || { echo "empty commit range: ${base}..${head}" >&2; exit 3; }
 
 if [ $# -eq 4 ]; then
   out=$4
 else
-  # Invoke via bash rather than direct exec: some extractors (Python zipfile)
-  # strip Unix exec bits when unpacking marketplace packages (#2040).
-  dir=$("${BASH:-bash}" "$(cd "$(dirname "$0")" && pwd)/sdd-workspace" "$plan")
-  out="$dir/review-$(git rev-parse --short "$base")..$(git rev-parse --short "$head").diff"
+  dir=$("${BASH:-bash}" "$here/sdd-workspace" "$plan")
+  out="$dir/review-$(git -C "$repo" rev-parse --short "$base")..$(git -C "$repo" rev-parse --short "$head").diff"
 fi
 
 {
   echo "# Review package: ${base}..${head}"
   echo
   echo "## Commits"
-  git log --oneline "${base}..${head}"
+  git -C "$repo" log --oneline "${base}..${head}"
   echo
   echo "## Files changed"
-  git diff --stat "${base}..${head}"
+  git -C "$repo" diff --stat "${base}..${head}"
   echo
   echo "## Diff"
-  git diff -U10 "${base}..${head}"
+  git -C "$repo" diff -U10 "${base}..${head}"
 } > "$out"
 
-commits=$(git rev-list --count "${base}..${head}")
+commits=$(git -C "$repo" rev-list --count "${base}..${head}")
 echo "wrote ${out}: ${commits} commit(s), $(wc -c < "$out" | tr -d ' ') bytes"

package/skills/subagent-driven-development/scripts/sdd-repo

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# Print the top-level directory of the git working tree the SDD scripts use:
+# the current directory's, exactly as git itself picks one. A caller that
+# means a different working tree says so with the scripts' -C DIR, which
+# they apply (cd) before calling this.
+#
+# The plan file's location never picks the repository. An executor working
+# in a linked worktree commonly holds an absolute path to the plan in the
+# main checkout (writing-plans leaves the plan uncommitted there), and its
+# workspace and commits belong to the worktree it is working in. And a
+# caller standing outside any repository, such as the skill's own directory
+# in an installed plugin, is in the wrong place: guessing a repository from
+# the plan would silently act on whichever checkout the path points into.
+#
+# Outside any working tree, stop. --with-commit also stops on a repository
+# with no commit yet, for callers that need HEAD as a BASE or a review
+# range. The message covers both ways to get here: running from the wrong
+# directory (where 'git init' would be the wrong fix) and a new project
+# that has no repository or commit yet.
+#
+# Single source of truth for which repository the SDD and executing-plans
+# scripts work in, so no two of them can disagree.
+#
+# Usage: sdd-repo [--with-commit]
+set -euo pipefail
+
+with_commit=false
+if [ "${1:-}" = "--with-commit" ]; then
+  with_commit=true
+  shift
+fi
+
+if [ $# -ne 0 ]; then
+  echo "usage: sdd-repo [--with-commit]" >&2
+  exit 2
+fi
+
+if root=$(git rev-parse --show-toplevel 2>/dev/null); then
+  if [ "$with_commit" = false ] || git -C "$root" rev-parse --verify --quiet HEAD >/dev/null; then
+    printf '%s\n' "$root"
+    exit 0
+  fi
+  said=$(git -C "$root" rev-parse --verify HEAD 2>&1 >/dev/null) || true
+else
+  said=$(git rev-parse --show-toplevel 2>&1 >/dev/null) || true
+fi
+
+# git's own first line always follows the shared message: where git refuses
+# a working tree the caller is inside (dubious ownership, git missing from
+# PATH, the cwd inside .git), the shared message alone would be wrong, and
+# git's line names the real fix.
+echo "SDD scripts must run from inside the git working tree you're executing in, with at least one commit (current directory: $PWD). If this is a new project, run 'git init' and make a first commit, then rerun." >&2
+echo "git said: ${said%%$'\n'*}" >&2
+exit 2

package/skills/subagent-driven-development/scripts/sdd-workspace

@@ -27,11 +27,23 @@
 # Single source of truth for the workspace location, so task-brief and
 # review-package cannot drift to different directories.
 #
-# Usage: sdd-workspace PLAN_FILE
+# The repository is the current directory's (see sdd-repo). -C DIR runs as
+# if started in DIR, the way git -C does: a caller working on another
+# checkout or worktree needs no `cd DIR ;` prefix, a compound that harnesses
+# cannot allowlist because DIR differs on every run (#1799).
+#
+# Usage: sdd-workspace [-C DIR] PLAN_FILE
 set -euo pipefail
 
+here=$(cd "$(dirname "$0")" && pwd)
+if [ "${1:-}" = "-C" ]; then
+  [ -d "${2:-}" ] || { echo "bad -C directory: ${2:-}" >&2; exit 2; }
+  cd "$2"
+  shift 2
+fi
+
 if [ $# -ne 1 ]; then
-  echo "usage: sdd-workspace PLAN_FILE" >&2
+  echo "usage: sdd-workspace [-C DIR] PLAN_FILE" >&2
   exit 2
 fi
 
@@ -44,8 +56,12 @@ slug=$(basename "$plan" .md)
 
 # Physical path, spelled the way pwd -P spells the plan path below: on Git
 # Bash, rev-parse prints C:/Users/... while pwd prints /c/Users/..., and the
-# repo-relative marker check needs both in the same form.
-root=$(CDPATH='' cd -- "$(git rev-parse --show-toplevel)" && pwd -P)
+# repo-relative marker check needs both in the same form. Two steps, so a
+# failing sdd-repo stops the script instead of handing cd an empty path.
+# Invoke via bash rather than direct exec: some extractors (Python zipfile)
+# strip Unix exec bits when unpacking marketplace packages (#2040).
+toplevel=$("${BASH:-bash}" "$here/sdd-repo")
+root=$(CDPATH='' cd -- "$toplevel" && pwd -P)
 base="$root/.superpowers/sdd"
 
 # Normalize the plan path (physical directory, so relative/absolute/../
@@ -84,4 +100,11 @@ fi
 # Create-only: a repo may commit its own .gitignore here (e.g. to version
 # progress.md ledgers); overwriting it would revert that on every run.
 [ -e "$base/.gitignore" ] || printf '*\n' > "$base/.gitignore"
-CDPATH='' cd -- "$dir" && pwd
+
+# On Windows (Git Bash, MSYS2, Cygwin) print C:/Users/... rather than
+# /c/Users/... or /tmp/...: the caller may be PowerShell or another native
+# tool, which can't resolve MSYS paths, and bash accepts this form too.
+# Only the printed path changes; the plan-path markers above keep pwd -P's
+# spelling, so existing workspaces still match their plans.
+CDPATH='' cd -- "$dir"
+if command -v cygpath >/dev/null 2>&1; then cygpath -m "$PWD"; else pwd; fi

package/skills/subagent-driven-development/scripts/task-brief

@@ -3,14 +3,21 @@
 # implementer reads in one call, so the task text never has to be pasted
 # through the controller's context.
 #
-# Usage: task-brief PLAN_FILE TASK_NUMBER [OUTFILE]
+# Usage: task-brief [-C DIR] PLAN_FILE TASK_NUMBER [OUTFILE]
 # Default OUTFILE: <repo-root>/.superpowers/sdd/<plan-basename>/task-<N>-brief.md
 # (per plan and per worktree; concurrent runs of the SAME plan in the same
-# working tree share it).
+# working tree share it). -C DIR runs as if started in DIR, as in sdd-workspace.
 set -euo pipefail
 
+here=$(cd "$(dirname "$0")" && pwd)
+if [ "${1:-}" = "-C" ]; then
+  [ -d "${2:-}" ] || { echo "bad -C directory: ${2:-}" >&2; exit 2; }
+  cd "$2"
+  shift 2
+fi
+
 if [ $# -lt 2 ] || [ $# -gt 3 ]; then
-  echo "usage: task-brief PLAN_FILE TASK_NUMBER [OUTFILE]" >&2
+  echo "usage: task-brief [-C DIR] PLAN_FILE TASK_NUMBER [OUTFILE]" >&2
   exit 2
 fi
 
@@ -23,17 +30,75 @@ if [ $# -eq 3 ]; then
 else
   # Invoke via bash rather than direct exec: some extractors (Python zipfile)
   # strip Unix exec bits when unpacking marketplace packages (#2040).
-  dir=$("${BASH:-bash}" "$(cd "$(dirname "$0")" && pwd)/sdd-workspace" "$plan")
+  dir=$("${BASH:-bash}" "$here/sdd-workspace" "$plan")
   out="$dir/task-${n}-brief.md"
 fi
 
-awk -v n="$n" '
-  /^```/ { infence = !infence }
-  !infence && /^#+[ \t]+Task[ \t]+[0-9]+/ {
-    intask = ($0 ~ ("^#+[ \t]+Task[ \t]+" n "([^0-9]|$)"))
+# A task heading is `Task` followed by an ID: letters and digits, optionally
+# dot-separated, containing at least one digit (3, 6b, A1, 2.1). The digit
+# keeps headings like "## Task Overview" or "#### Task notes" from becoming
+# task boundaries. The ID is compared to TASK_NUMBER as a whole string, so
+# Task 6 never matches Task 6b, Task 1 never matches Task 1.1, and
+# TASK_NUMBER never reaches awk as a regex (#2459). A deeper Task heading
+# whose ID extends the requested one with a letter or dot is a sub-task and
+# stays in its brief (### Task 7 keeps #### Task 7a), as it always has.
+# Depth alone is not enough: plans drift from "## Task 1" to "### Task 2".
+#
+# The word stays the English literal "Task", whatever language the rest of
+# the plan is in. A plan with no Task headings at all usually translated it
+# ("## Tarea 1"), so list the headings shaped like tasks before the
+# not-found error instead of implying the plan has no task 1 (#2496).
+#
+# A fence that never closes hides every Task heading after it (#2436). When
+# it hides one while the requested task is being captured, that task's end
+# can't be found and the brief would run on through every later task: refuse
+# (exit 4) rather than hand an implementer several tasks as its requirements.
+# When it hides the requested heading itself, say so before the not-found
+# error. A stray fence that hides no Task heading (real plans end with a lone
+# ``` line) leaves the brief complete, so brief it with a warning.
+# The plan path goes through ENVIRON, not -v, which would mangle the
+# backslashes of a Windows path.
+rc=0
+TASK_BRIEF_PLAN="$plan" awk -v n="$n" '
+  /^```/ { infence = !infence; if (infence) { fence_line = NR; hidden = 0 } }
+  infence && /^#+[ \t]+Task[ \t]/ { hidden = 1 }
+  !infence && /^#+[ \t]+Task[ \t]/ {
+    id = $0
+    sub(/^#+[ \t]+Task[ \t]+/, "", id)
+    if (match(id, /^[A-Za-z0-9]+(\.[A-Za-z0-9]+)*/) && substr(id, 1, RLENGTH) ~ /[0-9]/) {
+      tasks++
+      id = substr(id, 1, RLENGTH)
+      match($0, /^#+/)
+      subtask = intask && RLENGTH > level && substr(id, 1, length(n)) == n \
+        && substr(id, length(n) + 1, 1) ~ /[A-Za-z.]/
+      if (!subtask) {
+        intask = (id == n)
+        level = RLENGTH
+      }
+    }
+  }
+  !infence && /^#+[ \t]+[^ \t]+[ \t]+[A-Za-z0-9.]*[0-9]/ && shaped < 5 { shaped_heading[++shaped] = $0 }
+  intask { print; found = 1 }
+  END {
+    where = "the code fence opened at line " fence_line " of " ENVIRON["TASK_BRIEF_PLAN"] " never closes"
+    if (infence && hidden && (intask || !found)) {
+      print "task-brief: " where ", so no Task heading after it can be seen; close that fence in the plan and rerun" | "cat >&2"
+      if (intask) exit 4
+    } else if (infence && intask) {
+      print "task-brief: warning: " where "; it hides no Task heading, so this brief is complete" | "cat >&2"
+    }
+    # An open fence that hid Task headings already explains why none were
+    # seen; the English-word hint would contradict it.
+    if (!tasks && shaped && !(infence && hidden)) {
+      print "task-brief: no task headings found. Task headings must use the English word \"Task\" (\"### Task 1: ...\"), even when the rest of the plan is in another language. Headings shaped like tasks:" | "cat >&2"
+      for (i = 1; i <= shaped; i++) print "  " shaped_heading[i] | "cat >&2"
+    }
   }
-  intask { print }
-' "$plan" > "$out"
+' "$plan" > "$out" || rc=$?
+if [ "$rc" -ne 0 ]; then
+  if [ -f "$out" ]; then rm -f "$out"; fi
+  exit "$rc"
+fi
 
 if [ ! -s "$out" ]; then
   echo "task ${n} not found in ${plan} (no heading matching 'Task ${n}')" >&2

package/skills/subagent-driven-development/task-reviewer-prompt.md

@@ -194,7 +194,8 @@ more, nothing less) and is well-built (clean, tested, maintainable)
 
 **Placeholders:**
 - `agent: sdd-reviewer` — REQUIRED (see SKILL.md Agent Selection)
-- `[BRIEF_FILE]` — REQUIRED: the task brief file (`bash scripts/task-brief PLAN N`
+- `[BRIEF_FILE]` — REQUIRED: the task brief file (`bash scripts/task-brief PLAN N`,
+  run by its absolute path, from the working tree you're executing in,
   prints the path; same file the implementer worked from)
 - `[GLOBAL_CONSTRAINTS]` — the binding requirements copied verbatim from
   the plan's Global Constraints section or the spec: exact values, formats,
@@ -207,7 +208,8 @@ more, nothing less) and is well-built (clean, tested, maintainable)
   its branch tip (`git rev-parse sdd/<plan>/task-<N>`). Record this SHA:
   it is the next re-review's FIX_BASE
 - `[DIFF_FILE]` — REQUIRED: the path the controller wrote the review
-  package to (`bash scripts/review-package PLAN_FILE BASE HEAD` prints the unique
+  package to (`bash scripts/review-package PLAN_FILE BASE HEAD`, run by its
+  absolute path, from the working tree you're executing in, prints the unique
   path it wrote; the package never enters the controller's context)
 - `[CHECKOUT_LINE]` — for a wave task that has not merged yet: `**Checkout:**
   <worktree absolute path> — the task's code lives here, not in your