@oneie/claude 0.2.0 → 0.3.0

package/commands/do.md

@@ -122,7 +122,7 @@ For each **enabled** stop (per the pruned spine), in order: check if its artifac
 | ↳ *ANALYZE* | — | `do-analyze.sh plans/<slug>-todo.md` — CRITICAL exit 1 blocks BUILD | bash · none |
 | **code** | survey verdict = `build` (≥70% match → `expose`/`extend` instead) | the BUILD engine (Step 3) | sonnet · low–medium |
 | **tests** | test file in the repo folder | test-first, one assertion per deliverable | sonnet · low |
-| **proof** | proof artifact captured | `do-prove.sh` (browser / curl / contract / sync) + `accessibility`; **promise-check** the shipped thing against `text/<slug>.md`; FEATURE/SCHEMA built in a worktree → **merge to trunk only on PROVE pass**, abandon on fail | sonnet · low |
+| **proof** | proof artifact captured | `do-prove.sh` (browser / curl / contract / sync) + `accessibility`; **promise-check** the shipped thing against `text/<slug>.md`. A multi-cycle plan already built on its own `do/<slug>` branch (worktree isolation — see Step 2); PROVE is the gate that branch must clear before a human merges it to trunk | sonnet · low |
 | **docs** | feature doc + runbook exist | `tutorial` + `writer` — written against the *proven* behavior | sonnet · medium |
 | **release** | changelog / README row | `/release` + adoption signal | sonnet · low |
 
@@ -163,6 +163,8 @@ bun .claude/scripts/do-auto.sh <slug>
 
 `do-auto.sh` loops: each iteration spawns a clean `/do <slug> --next-cycle` that runs exactly one batch (W1→W4), ticks its boxes, writes state, and exits. Because each cycle starts from near-zero context, prior-cycle recon/edit/verify chatter never accumulates. The main session just kicks off the loop and reports the close.
 
+**Worktree isolation comes free with the loop.** The loop's existence *is* the trigger — `do-auto.sh` only runs for multi-cycle plans, which is exactly the FEATURE/SCHEMA work that must not land half-built on trunk. So before the first cycle it cuts a worktree `.do-worktrees/<slug>` on branch `do/<slug>` (reusing it on resume), syncs the plan's spine artifacts into it, and runs **every cycle inside it** — each cycle's edits and box-ticks commit to that branch. Trunk never moves while the loop runs; a halt (trust `cautious` / stall / max-cycles) leaves a clean, inspectable WIP branch, and re-running `/do <slug>` resumes in the same worktree. On plan-complete the loop **reports** the merge (`git merge --no-ff do/<slug>`) rather than running it — landing to trunk is a human decision (commit only when asked), and PROVE is the gate that branch cleared to earn the merge. PATCH/FIX never reach the loop, so they run inline with no worktree.
+
 A **single** incomplete cycle (or a PATCH/FIX) runs inline — there's nothing to isolate from, and spawning a subprocess would cost more than it saves.
 
 **`--next-cycle` is internal.** It means "run one batch, tick boxes, exit — do **not** loop." Only `do-auto.sh` passes it; it is the recursion guard that keeps a fresh `/do` from re-entering the loop. A human never types it.
@@ -266,7 +268,7 @@ PATCH clears {1,2,3,8}. FEATURE clears all eight.
 
 ## Available to /do — the toolbox
 
-**Scripts** (`.claude/scripts/`): `do-auto.sh` (*internal* — the context-isolated loop `/do` drives for multi-cycle plans) · `do-tier.sh` (tier + pruned spine + classifier + ceiling) · `do-folder.sh` (folder-aware verify/build) · `do-survey.sh` (reuse verdict) · `do-reconcile.sh` (substrate dim/verb/dead-name gate) · `do-analyze.sh` (deliverable↔cycle coverage gate) · `do-prove.sh` (surface-detect proof) · `do-smoke.sh` (deterministic outcome) · `w1-recon.ts` (prompt-cached recon) · `w4-rubric.ts` (cached parallel rubric).
+**Scripts** (`.claude/scripts/`): `do-auto.sh` (*internal* — the context-isolated, worktree-isolated loop `/do` drives for multi-cycle plans; builds on branch `do/<slug>`, merges to trunk only on a human's say-so) · `do-tier.sh` (tier + pruned spine + classifier + ceiling) · `do-folder.sh` (folder-aware verify/build) · `do-survey.sh` (reuse verdict) · `do-reconcile.sh` (substrate dim/verb/dead-name gate) · `do-analyze.sh` (deliverable↔cycle coverage gate) · `do-prove.sh` (surface-detect proof) · `do-smoke.sh` (deterministic outcome) · `w1-recon.ts` (prompt-cached recon) · `w4-rubric.ts` (cached parallel rubric).
 
 **Templates**: `text/template-frame.md` (promise) · `plans/template-spec.md` (design + pre-mortem + decisions) · `plans/template-todo.md` (plan + parallel budget + testing policy) · `plans/agent-template.md` (agent definition).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oneie/claude",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "ONE Claude Code plugin — /do lifecycle, W1-W4 BUILD engine, ONE substrate via MCP, signals, and rules",
   "files": [
     ".claude-plugin",

package/scripts/do-auto.sh

@@ -29,15 +29,84 @@ done
 
 [ -z "$SLUG" ] && { echo "usage: do-auto.sh <slug> [--max-cycles N] [--dry-run]" >&2; exit 1; }
 
-TODO="plans/${SLUG}-todo.md"
-TRUST=".do-trust.json"
+# Validate slug is safe (kebab-case only) before it touches any shell string.
+# Prevents command injection if the slug ever contains metacharacters.
+if ! printf '%s' "$SLUG" | grep -qE '^[a-zA-Z0-9][a-zA-Z0-9_-]*$'; then
+  echo "[do-auto] unsafe slug (must be alphanumeric + hyphens/underscores): $SLUG" >&2; exit 1
+fi
 
-[ -f "$TODO" ] || { echo "[do-auto] $TODO not found — run /do $SLUG first" >&2; exit 1; }
+# Trust boundary: this script runs in the developer's own workspace, invoked by /do
+# which resolves the slug from a plans/ file the developer controls. The spawned
+# claude subprocess uses --dangerously-skip-permissions because it is non-interactive
+# — it cannot prompt the human for tool approvals. The workspace is the isolation
+# boundary. Do not expose this script to untrusted input or run it in shared environments.
+[ -f "plans/${SLUG}-todo.md" ] || { echo "[do-auto] plans/${SLUG}-todo.md not found — run /do $SLUG first" >&2; exit 1; }
+
+# ── Worktree isolation (one per plan) ────────────────────────────────────────
+# The loop's existence IS the trigger: do-auto only runs for multi-cycle plans
+# (>=2 incomplete cycles) = exactly the FEATURE/SCHEMA work that must not land
+# half-built on trunk. So every loop builds in its own worktree on branch
+# do/<slug>, leaving trunk green until a human merges. No tier plumbing, no flag.
+#
+# Why a worktree and not just a branch: the main session keeps observing trunk
+# while the loop's subprocesses build in a separate checkout — they never fight
+# over HEAD or the working tree. A halt leaves a clean, inspectable WIP branch.
+#
+#   trunk (BASE) ── never moves during the loop
+#        └─ do/<slug>  (worktree .do-worktrees/<slug>) ── every cycle commits here
+#   plan complete → report `git merge do/<slug>`  (human lands it — never auto)
+#   halt          → worktree persists → re-run /do <slug> resumes in place
+BASE="$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo HEAD)"
+BR="do/${SLUG}"
+WT=".do-worktrees/${SLUG}"
+
+_setup_worktree() {
+  # Idempotent: reuse an existing worktree (resume), else attach one to an
+  # existing branch (prior halt), else create branch+worktree fresh from HEAD.
+  if git -C "$WT" rev-parse --git-dir >/dev/null 2>&1; then
+    echo "[do-auto] resuming worktree $WT on $BR"
+  elif git show-ref --verify --quiet "refs/heads/$BR"; then
+    echo "[do-auto] re-attaching worktree $WT to existing branch $BR"
+    git worktree add "$WT" "$BR" >/dev/null
+  else
+    echo "[do-auto] creating worktree $WT on new branch $BR (from $BASE)"
+    git worktree add -b "$BR" "$WT" HEAD >/dev/null
+  fi
+
+  # Carry the plan's own artifacts into the worktree. The spine walk may have
+  # just written promise/spec/todo uncommitted in the main tree; a worktree cut
+  # from HEAD wouldn't have them. Copy only this slug's files — never unrelated
+  # working-tree changes — then commit them as the branch baseline.
+  local f changed=0
+  for f in "plans/${SLUG}.md" "plans/${SLUG}-todo.md" "text/${SLUG}.md" ".w4-improvements.json"; do
+    if [ -f "$f" ]; then
+      mkdir -p "$WT/$(dirname "$f")"
+      if ! cmp -s "$f" "$WT/$f" 2>/dev/null; then cp "$f" "$WT/$f"; changed=1; fi
+    fi
+  done
+  if [ "$changed" -eq 1 ]; then
+    git -C "$WT" add -A
+    git -C "$WT" commit -q -m "do(${SLUG}): sync spine artifacts" 2>/dev/null || true
+  fi
+}
+
+if ! $DRY_RUN; then
+  _setup_worktree
+  # All loop state now lives in the worktree — read the boxes the subprocess ticks.
+  TODO="$WT/plans/${SLUG}-todo.md"
+  TRUST="$WT/.do-trust.json"
+else
+  TODO="plans/${SLUG}-todo.md"
+  TRUST=".do-trust.json"
+fi
 
 _remaining() {
   # Count cycles in the Status section that are open ([ ]) or in-flight ([~]) — i.e. not [x].
   # Pattern starts with '\[' (not '-') so grep never mistakes it for an option flag.
-  grep -cE '\[[ ~]\] C[0-9]+' "$TODO" 2>/dev/null || echo 0
+  # grep -c already prints a count (0 on no match) but exits 1 then — capture it so
+  # the `|| true` swallows the exit without appending a second "0" to the output.
+  local n; n=$(grep -cE '\[[ ~]\] C[0-9]+' "$TODO" 2>/dev/null) || true
+  echo "${n:-0}"
 }
 
 _trust() {
@@ -71,6 +140,7 @@ while [ "$i" -lt "$MAX_CYCLES" ]; do
     if [ "$stall" -ge 2 ]; then
       echo "[do-auto] no progress for 2 iterations (${remaining} cycle(s) stuck) — halting." >&2
       echo "[do-auto] The last cycle ticked no checkbox. Inspect $TODO, fix the blocker, then re-run /do $SLUG." >&2
+      echo "[do-auto] WIP preserved on branch $BR (worktree $WT)." >&2
       exit 1
     fi
   else
@@ -81,6 +151,7 @@ while [ "$i" -lt "$MAX_CYCLES" ]; do
   trust=$(_trust)
   if [ "$trust" = "cautious" ]; then
     echo "[do-auto] trust=cautious — halting. Fix the issue, then re-run /do $SLUG."
+    echo "[do-auto] WIP preserved on branch $BR (worktree $WT)."
     exit 1
   fi
 
@@ -96,11 +167,31 @@ while [ "$i" -lt "$MAX_CYCLES" ]; do
     break
   fi
 
-  # Fresh context: no --resume, no --continue. Each cycle is a clean slate.
-  claude --dangerously-skip-permissions -p "/do $SLUG --next-cycle"
+  # Fresh context, isolated tree: the subprocess runs INSIDE the worktree, so
+  # every edit/box-tick/state-write lands on branch $BR — trunk is never touched.
+  ( cd "$WT" && claude --dangerously-skip-permissions -p "/do $SLUG --next-cycle" )
+
+  # Commit the cycle on its branch. A cycle closes with a passing rubric, so it
+  # is the natural commit unit — and committed progress survives a later halt.
+  if [ -n "$(git -C "$WT" status --porcelain)" ]; then
+    git -C "$WT" add -A
+    git -C "$WT" commit -q -m "do(${SLUG}): cycle ${i}" || true
+  fi
 done
 
+if $DRY_RUN; then exit 0; fi
+
 if [ "$i" -ge "$MAX_CYCLES" ]; then
   echo "[do-auto] hit --max-cycles $MAX_CYCLES — halting"
+  echo "[do-auto] WIP preserved on branch $BR (worktree $WT)."
   exit 1
 fi
+
+# Plan complete. The branch holds every cycle, proven and committed; trunk is
+# untouched. Landing it is a human decision (commit/push only when asked), so we
+# report the merge instead of running it — the worktree stays for inspection.
+echo ""
+echo "[do-auto] ✓ plan complete on branch $BR — trunk ($BASE) untouched."
+echo "[do-auto]   land:    git merge --no-ff $BR        # from $BASE"
+echo "[do-auto]   inspect: git -C $WT log --oneline $BASE..$BR"
+echo "[do-auto]   discard: git worktree remove $WT && git branch -D $BR"