@webpresso/claude-plugin 3.1.11 → 3.1.13

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Webpresso agent-kit Claude Code plugin: blueprints, skills, hooks, MCP server",
-    "version": "3.1.11"
+    "version": "3.1.13"
   },
   "plugins": [
     {
@@ -34,5 +34,5 @@
       }
     }
   ],
-  "version": "3.1.11"
+  "version": "3.1.13"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-kit",
-  "version": "3.1.11",
+  "version": "3.1.13",
   "description": "Webpresso agent-kit: blueprints, skills, lore commit protocol, tech-debt lifecycle",
   "author": {
     "name": "Webpresso",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpresso/claude-plugin",
-  "version": "3.1.11",
+  "version": "3.1.13",
   "private": false,
   "description": "Claude Code plugin adapter for Webpresso agent-kit skills, commands, and MCP runtime.",
   "homepage": "https://github.com/webpresso/agent-kit#readme",
@@ -15,6 +15,7 @@
   },
   "files": [
     ".claude-plugin",
+    "plugin-skill-ownership.json",
     "skills",
     "commands",
     "bin/wp",

package/plugin-skill-ownership.json

@@ -0,0 +1,86 @@
+{
+  "schemaVersion": 1,
+  "host": "claude",
+  "packageName": "@webpresso/claude-plugin",
+  "packageVersion": "3.1.13",
+  "runtimeDirs": [
+    ".claude/skills"
+  ],
+  "skills": {
+    "autopilot": {
+      "digest": "sha256:7fc1fe9f5fb5b8a3e755f8e3ac4b807e4f140288544ffcf39e4cbfdea984014d"
+    },
+    "autoresearch": {
+      "digest": "sha256:b4d51cd53beb4a3271827172dfbd0b1d27bd58761ca07a35d49a5d6324b87fdf"
+    },
+    "best-practice-research": {
+      "digest": "sha256:b0d355c7f4afe9c38be83e293788bf582bea068c1db2fa5c45400441e315735d"
+    },
+    "browse": {
+      "digest": "sha256:21fd24862e7f7c8a1feadea6bc376492b136b99fc381cf1b8927c9db80615431"
+    },
+    "claude": {
+      "digest": "sha256:b75a472594d78bd9452c07fd791a426864848a2c9c726454dc72daf3813ae22b"
+    },
+    "codex": {
+      "digest": "sha256:803cea9c1b37406d7bdc8e44e9d5e9f3988218277500d8d6cb0d955c933c3302"
+    },
+    "deep-research": {
+      "digest": "sha256:01dafd194066a2936db0b437fd5c3beef6d7ff82478d0d995393093d89496f18"
+    },
+    "design-review": {
+      "digest": "sha256:5b213735e2842568774572f36b198bccf03c03a54b2732484aadd023f04acb23"
+    },
+    "devex-review": {
+      "digest": "sha256:306355888da0827e3523022077f731845726bbaaf595ca12515cc91d8605b5e6"
+    },
+    "fix": {
+      "digest": "sha256:e43dfad198f7279ebc2dca9e62f43fd960c783ca0ab25f133668fca13aed96b2"
+    },
+    "goal": {
+      "digest": "sha256:85380b633cfaaff8ec1639dd3a88412a41920aae3e8531de95e2b79411926a18"
+    },
+    "hooks-doctor": {
+      "digest": "sha256:3bfb0af64ff6796c56d51e4cd2bede7fb24c869f89b292546ea13ad2f5d3bb73"
+    },
+    "lore-protocol": {
+      "digest": "sha256:a80fbacc765e8b886437b9fdf7dd71e1ceb1b98b939078ec90fc88d06a8b4c69"
+    },
+    "opencode-go": {
+      "digest": "sha256:ccb2bcf09cc1c5c0d54027b84f580e688f5f5cf624e6cdc19870bd3ce99940fc"
+    },
+    "plan-ceo-review": {
+      "digest": "sha256:4d426158518dd71f8998770e8d4037bcbfa3c65d7265a93a4a78a9b015ba881e"
+    },
+    "plan-design-review": {
+      "digest": "sha256:a8a33efe67844d0602ff595c0b7e8f5529e52f51a781112952636c91963ce19e"
+    },
+    "plan-devex-review": {
+      "digest": "sha256:a49b4f61f1c54a7d89111c270616684dcbf2a7236bc817fafb5919366a7cda31"
+    },
+    "plan-eng-review": {
+      "digest": "sha256:b728dad90254d4c9f81b3818321d34ab53519b79ce20ff3bfe08bfacb2aa3e86"
+    },
+    "plan-refine": {
+      "digest": "sha256:891e84ff8592b8489b59e8642f6a602c9558fd57edd171af98499c94e2f62f13"
+    },
+    "ralplan": {
+      "digest": "sha256:db285d477f43ed23df990d4c03750d9916cdc7809356c1bf025efdf6a9add9ed"
+    },
+    "team": {
+      "digest": "sha256:151ef81df917435073a2d7b41173d33c45cb8aa1e5fdf34a70043bb3a2e746ff"
+    },
+    "tech-debt": {
+      "digest": "sha256:8b1f30e55ec6e5ab185ff19ecf15384438dbd619f675c2c65f2e53cedecbae5c"
+    },
+    "testing-philosophy": {
+      "digest": "sha256:43fa05bcb7eaf8efd4a8dcc0f9fb9c30ae9f80079d9b3dbfdc926734a64a2973"
+    },
+    "tph": {
+      "digest": "sha256:bed3684a850651534f315d355cdeae50d951c429817df0f105cccdb7f4e1561b"
+    },
+    "verify": {
+      "digest": "sha256:ce0dd3a77508d1bf11c805dec2de04e75b689201d376b2ff0fa957604d584500"
+    }
+  }
+}

package/skills/autoresearch/SKILL.md

@@ -0,0 +1,49 @@
+---
+type: skill
+slug: autoresearch
+title: Autoresearch
+status: active
+scope: repo
+applies_to: [agents]
+related: [deep-research, best-practice-research, plan-refine, verify]
+created: "2026-07-13"
+last_reviewed: "2026-07-13"
+name: autoresearch
+description: "Artifact-gated research loop with explicit validation."
+argument-hint: "<research mission and validator>"
+---
+
+# Autoresearch
+
+Use when the user wants research to continue until a concrete validator accepts the result. This is for bounded research deliverables, not quick factual lookup or ordinary planning context.
+
+## Boundary
+
+- Use `deep-research` for one-pass citation-backed reports.
+- Use `best-practice-research` for focused upstream guidance.
+- Use `autoresearch` when completion depends on an explicit evaluator, benchmark, review rubric, or acceptance artifact.
+
+## Workflow
+
+1. Define the research mission, output artifact path, validator, and stop condition.
+2. Choose one validation mode:
+   - command validator: a repo command or script must pass and write the result.
+   - review validator: an independent review must approve the produced artifact against the mission.
+3. Create or update the durable research artifact before iterating.
+4. Gather sources and repo context until the artifact addresses the mission and cites material claims.
+5. Run the validator. If it fails, preserve the failure evidence, revise the artifact, and repeat.
+6. Stop only when the validator passes or a blocker prevents more evidence-gathering.
+
+## Output
+
+Return:
+
+- mission
+- artifact path
+- validation mode
+- validator command or review rubric
+- evidence gathered
+- pass/fail result
+- remaining gaps or blocker
+
+Do not treat elapsed turns, model confidence, or a draft report as completion evidence. Completion requires the declared validator to pass.

package/skills/claude/SKILL.md

@@ -38,6 +38,19 @@ PROMPT_FILE=$(mktemp -t wp-claude-review.XXXXXX)
 trap 'rm -f "$PROMPT_FILE"' EXIT
 ```
 
+## Dashboard helper relation
+
+When this skill is invoked from `wp dash`, create explicit lifecycle records around the outside-voice call. The shared `wp dash-helper-*` service owns the event JSON and report shape; do not duplicate it in a skill. Outside the dashboard the block is a no-op, preserving standalone calls.
+
+```bash
+DASH_HELPER_RUN_ID=""
+if [ "${WP_DASH:-}" = "1" ] && [ -n "${WP_DASH_RUN_ID:-}" ]; then
+  DASH_HELPER_RUN_ID=$(wp dash-helper-start --provider claude --role reviewer)
+fi
+```
+
+Claude's managed native subagent lifecycle does not provide a reliable parent-linked completion event. It remains explicitly unsupported rather than being inferred from transcript text or timing.
+
 ## Modes
 
 ### Review
@@ -77,116 +90,55 @@ TARGET_FILE=${TARGET_FILE:?set TARGET_FILE to one changed file}
 } >"$PROMPT_FILE"
 ```
 
-#### Timed Claude artifact wrapper
+#### Progress-aware review runtime
 
-Run Claude through the bounded Python wrapper. Use `claude --print --model "$CLAUDE_REVIEW_MODEL"`; do not recommend `--bare` for this path. Do not add artificial budget caps unless the user requested one. The wrapper is deterministic:
-
-- it defaults to `CLAUDE_REVIEW_MODEL=sonnet` and allows only `opus` or `sonnet`
-- it never passes `--tools ""`, because Claude's variadic `--tools` option can swallow the prompt
-- it captures stdout and stderr for preflight and the full review
-- it writes the artifact on success, non-zero exit, or timeout
-- it runs one full review attempt only; retry only if you change the command shape for a specific diagnosed reason
-
-Preflight must be only the tiny `claude-ok` prompt with the selected model. Do not use the real review prompt for preflight.
+Run both the availability probe and the full review through the typed `wp review run` owner. Skills must not embed subprocess supervision. The runtime consumes Claude's streaming JSON events, advances its idle clock only on monotonic semantic progress, and has no total wall-clock cutoff.
 
 ```bash
 CLAUDE_REVIEW_MODEL=${CLAUDE_REVIEW_MODEL:-sonnet}
 CLAUDE_REVIEW_EFFORT=${CLAUDE_REVIEW_EFFORT:-medium}
-CLAUDE_REVIEW_PREFLIGHT_TIMEOUT_SECONDS=${CLAUDE_REVIEW_PREFLIGHT_TIMEOUT_SECONDS:-30}
-CLAUDE_REVIEW_IDLE_TIMEOUT_SECONDS=${CLAUDE_REVIEW_IDLE_TIMEOUT_SECONDS:-180}
-CLAUDE_REVIEW_ARTIFACT=${CLAUDE_REVIEW_ARTIFACT:-"$(pwd)/.webpresso/claude-review-$(date +%Y%m%dT%H%M%S).json"}
-export CLAUDE_REVIEW_MODEL CLAUDE_REVIEW_EFFORT CLAUDE_REVIEW_PREFLIGHT_TIMEOUT_SECONDS CLAUDE_REVIEW_IDLE_TIMEOUT_SECONDS CLAUDE_REVIEW_ARTIFACT
-mkdir -p "$(dirname "$CLAUDE_REVIEW_ARTIFACT")"
-
-python3 - "$PROMPT_FILE" "$CLAUDE_REVIEW_ARTIFACT" <<'PY'
-from __future__ import annotations
-
-import json, os, subprocess, sys, time
-from pathlib import Path
-
-prompt_path = Path(sys.argv[1])
-artifact_path = Path(sys.argv[2])
-model = os.environ.get("CLAUDE_REVIEW_MODEL", "sonnet")
-effort = os.environ.get("CLAUDE_REVIEW_EFFORT", "medium")
-preflight_timeout = float(os.environ.get("CLAUDE_REVIEW_PREFLIGHT_TIMEOUT_SECONDS", "30"))
-review_idle_timeout = float(os.environ.get("CLAUDE_REVIEW_IDLE_TIMEOUT_SECONDS", "180"))
-if model not in {"opus", "sonnet"}: raise SystemExit("CLAUDE_REVIEW_MODEL must be one of: opus, sonnet")
-if effort not in {"medium", "high"}: raise SystemExit("CLAUDE_REVIEW_EFFORT must be one of: medium, high")
-if preflight_timeout <= 0 or review_idle_timeout <= 0: raise SystemExit("Claude timeout values must be positive numbers")
-
-
-def utc_now() -> str: return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-
-artifact: dict[str, object] = {"tool": "claude-outside-voice", "model": model, "effort": effort, "startedAt": utc_now(), "artifactPath": str(artifact_path), "runs": []}
-
-
-def write_artifact(status: str, exit_code: int) -> None:
-    artifact.update({"finishedAt": utc_now(), "status": status, "exitCode": exit_code})
-    artifact_path.parent.mkdir(parents=True, exist_ok=True)
-    artifact_path.write_text(json.dumps(artifact, indent=2) + "\n", encoding="utf-8")
-
-
-def as_text(value: str | bytes | None) -> str:
-    return value.decode(errors="replace") if isinstance(value, bytes) else (value or "")
-
-
-def run_claude(stage: str, prompt: str, timeout_seconds: float, timeout_kind: str) -> int:
-    command = ["claude", "--print", "--model", model, "--effort", effort, prompt]
-    started = last_progress = time.monotonic()
-    last_progress_at = utc_now()
-    out = err = ""
-    record: dict[str, object] = {"stage": stage, "command": [*command[:-1], "<prompt>"], "timeoutKind": timeout_kind, "timeoutSeconds": timeout_seconds, "idleTimeoutSeconds": timeout_seconds if timeout_kind == "idle" else None, "startedAt": last_progress_at}
-    try:
-        process = subprocess.Popen(command, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        while True:
-            try:
-                new_out, new_err = process.communicate(timeout=0.5)
-                out, err = as_text(new_out), as_text(new_err)
-                code = int(process.returncode)
-                timed_out = False
-                break
-            except subprocess.TimeoutExpired as exc:
-                new_out, new_err = as_text(exc.stdout), as_text(exc.stderr)
-                if new_out != out or new_err != err:
-                    out, err, last_progress, last_progress_at = new_out, new_err, time.monotonic(), utc_now()
-                reference = last_progress if timeout_kind == "idle" else started
-                if time.monotonic() - reference > timeout_seconds:
-                    process.kill()
-                    final_out, final_err = process.communicate()
-                    out += as_text(final_out)[len(out):]
-                    err += as_text(final_err)[len(err):]
-                    code, timed_out = 124, True
-                    break
-    except OSError as exc:
-        out, err, code, timed_out = "", str(exc), 1, False
-    record.update({"exitCode": code, "timedOut": timed_out, "stdout": out, "stderr": err, "finishedAt": utc_now(), "lastProgressAt": last_progress_at, "elapsedSeconds": round(time.monotonic() - started, 3)})
-    artifact["runs"].append(record)
-    return code
-
-preflight_code = run_claude("preflight", "claude-ok", preflight_timeout, "wall-clock")
-if preflight_code != 0:
-    write_artifact("preflight-timeout" if preflight_code == 124 else "preflight-failed", preflight_code)
-    print(f"CLAUDE_REVIEW_PREFLIGHT_EXIT={preflight_code}", file=sys.stderr)
-    print(f"CLAUDE_REVIEW_ARTIFACT={artifact_path}", file=sys.stderr)
-    raise SystemExit(preflight_code)
-review_code = run_claude("review", prompt_path.read_text(encoding="utf-8"), review_idle_timeout, "idle")
-write_artifact("idle-timeout" if review_code == 124 else ("success" if review_code == 0 else "failed"), review_code)
-print(f"CLAUDE_REVIEW_EXIT={review_code}", file=sys.stderr)
-print(f"CLAUDE_REVIEW_ARTIFACT={artifact_path}", file=sys.stderr)
-raise SystemExit(review_code)
-PY
+CLAUDE_REVIEW_PROBE_IDLE_SECONDS=${CLAUDE_REVIEW_PROBE_IDLE_SECONDS:-180}
+CLAUDE_REVIEW_IDLE_SECONDS=${CLAUDE_REVIEW_IDLE_SECONDS:-180}
+CLAUDE_REVIEW_ARTIFACT_ROOT=${CLAUDE_REVIEW_ARTIFACT_ROOT:-"$(pwd)/.webpresso/reviews"}
+PROBE_FILE=$(mktemp -t wp-claude-probe.XXXXXX)
+trap 'rm -f "$PROMPT_FILE" "$PROBE_FILE"' EXIT
+printf 'Reply exactly CLAUDE_OK.\n' >"$PROBE_FILE"
+
+wp review run \
+  --provider claude \
+  --prompt-file "$PROBE_FILE" \
+  --model "$CLAUDE_REVIEW_MODEL" \
+  --effort "$CLAUDE_REVIEW_EFFORT" \
+  --stage probe \
+  --expected-marker CLAUDE_OK \
+  --artifact-root "$CLAUDE_REVIEW_ARTIFACT_ROOT" \
+  --idle-seconds "$CLAUDE_REVIEW_PROBE_IDLE_SECONDS"
+
+wp review run \
+  --provider claude \
+  --prompt-file "$PROMPT_FILE" \
+  --model "$CLAUDE_REVIEW_MODEL" \
+  --effort "$CLAUDE_REVIEW_EFFORT" \
+  --stage review \
+  --artifact-root "$CLAUDE_REVIEW_ARTIFACT_ROOT" \
+  --idle-seconds "$CLAUDE_REVIEW_IDLE_SECONDS"
+CLAUDE_REVIEW_CODE=$?
 ```
 
-After the wrapper exits, verify both the exit code and artifact path before summarizing Claude's raw output:
+After the review runtime exits, emit its terminal state using the same artifact path:
 
 ```bash
-test -f "$CLAUDE_REVIEW_ARTIFACT" || {
-  echo "CLAUDE_REVIEW_ARTIFACT=missing: $CLAUDE_REVIEW_ARTIFACT" >&2
-  exit 1
-}
-echo "CLAUDE_REVIEW_ARTIFACT=$CLAUDE_REVIEW_ARTIFACT"
+if [ -n "$DASH_HELPER_RUN_ID" ]; then
+  if [ "$CLAUDE_REVIEW_CODE" -eq 0 ]; then
+    wp dash-helper-complete --provider claude --run-id "$DASH_HELPER_RUN_ID" --role reviewer --outcome completed --artifact "${CLAUDE_REVIEW_ARTIFACT:-}"
+  else
+    wp dash-helper-complete --provider claude --run-id "$DASH_HELPER_RUN_ID" --role reviewer --outcome failed --artifact "${CLAUDE_REVIEW_ARTIFACT:-}"
+  fi
+fi
 ```
 
+Treat `true-idle`, `protocol-unsupported`, provider failure, abort, spawn failure, or artifact failure as unavailable review evidence. Never replace them with a static timeout, arbitrary byte-growth heartbeat, or buffered-output fallback.
+
 #### Retry policy
 
 Do not perform blind retries. Run the full review once. Retry only after diagnosing and changing a command-shape problem; record the reason and artifact path. Do not fall back to an unbounded whole-PR prompt.

package/skills/codex/SKILL.md

@@ -25,6 +25,31 @@ PROMPT_FILE=$(mktemp -t wp-codex-review.XXXXXX)
 trap 'rm -f "$PROMPT_FILE"' EXIT
 ```
 
+## Dashboard helper relation
+
+When called by `wp dash`, register the outside-voice helper through the shared service rather than writing relationship JSON in this skill. This is intentionally a no-op for standalone use.
+
+```bash
+DASH_HELPER_RUN_ID=""
+if [ "${WP_DASH:-}" = "1" ] && [ -n "${WP_DASH_RUN_ID:-}" ]; then
+  DASH_HELPER_RUN_ID=$(wp dash-helper-start --provider codex --role reviewer)
+fi
+```
+
+After the review command completes, report the exact terminal outcome. Supply an artifact path when the caller created one.
+
+```bash
+if [ -n "$DASH_HELPER_RUN_ID" ]; then
+  if [ "${CODEX_REVIEW_CODE:-0}" -eq 0 ]; then
+    wp dash-helper-complete --provider codex --run-id "$DASH_HELPER_RUN_ID" --role reviewer --outcome completed --artifact "${CODEX_REVIEW_ARTIFACT:-}"
+  else
+    wp dash-helper-complete --provider codex --run-id "$DASH_HELPER_RUN_ID" --role reviewer --outcome failed --artifact "${CODEX_REVIEW_ARTIFACT:-}"
+  fi
+fi
+```
+
+Codex native subagent events are not currently parent-linked in the managed lifecycle. They are shown as unsupported, never inferred from text, PIDs, or timestamps.
+
 ## Modes
 
 ### Review
@@ -39,7 +64,8 @@ case "$CODEX_REVIEW_EFFORT" in
   medium|high) ;;
   *) echo "CODEX_REVIEW_EFFORT must be one of: medium, high" >&2; exit 2 ;;
 esac
-codex exec -c model_reasoning_effort="\"$CODEX_REVIEW_EFFORT\"" --sandbox read-only --cd "$PWD" - <"$PROMPT_FILE"
+CODEX_REVIEW_CODE=0
+codex exec -c model_reasoning_effort="\"$CODEX_REVIEW_EFFORT\"" --sandbox read-only --cd "$PWD" - <"$PROMPT_FILE" || CODEX_REVIEW_CODE=$?
 ```
 
 4. Summarize findings with severity, evidence, and whether you independently verified them.

package/skills/opencode-go/SKILL.md

@@ -28,6 +28,32 @@ PROMPT_FILE=$(mktemp -t wp-opencode-go-review.XXXXXX)
 trap 'rm -f "$PROMPT_FILE"' EXIT
 ```
 
+## Dashboard helper relation
+
+When `wp dash` provides dashboard context, use the shared helper emitter around this outside-voice review. The commands leave standalone OpenCode Go reviews unchanged.
+
+```bash
+DASH_HELPER_RUN_ID=""
+if [ "${WP_DASH:-}" = "1" ] && [ -n "${WP_DASH_RUN_ID:-}" ]; then
+  DASH_HELPER_RUN_ID=$(wp dash-helper-start --provider opencode-go --role reviewer --artifact "${OPENCODE_GO_REVIEW_ARTIFACT:-}")
+fi
+```
+
+After the review runtime exits, record its actual result and optional artifact:
+
+```bash
+OPENCODE_GO_REVIEW_CODE=$?
+if [ -n "$DASH_HELPER_RUN_ID" ]; then
+  if [ "$OPENCODE_GO_REVIEW_CODE" -eq 0 ]; then
+    wp dash-helper-complete --provider opencode-go --run-id "$DASH_HELPER_RUN_ID" --role reviewer --outcome completed --artifact "${OPENCODE_GO_REVIEW_ARTIFACT:-}"
+  else
+    wp dash-helper-complete --provider opencode-go --run-id "$DASH_HELPER_RUN_ID" --role reviewer --outcome failed --artifact "${OPENCODE_GO_REVIEW_ARTIFACT:-}"
+  fi
+fi
+```
+
+The managed OpenCode plugin currently has no parent-linked native subagent completion lifecycle. This capability is explicit unsupported coverage, not an inferred dashboard relation.
+
 ## Review command
 
 Use read-only prompts. Run from the repo directory; do NOT pass `--dir "$PWD"` because opencode already uses the current directory and the extra index can stall reviews.
@@ -44,64 +70,37 @@ MODEL=$(echo "$CATALOG" | grep '^opencode-go/kimi' | grep -- '-code$' | sort -V
 [ -z "$MODEL" ] && MODEL=$(echo "$CATALOG" | grep '^opencode-go/mimo' | grep -- '-pro$' | sort -V | tail -1)
 [ -z "$MODEL" ] && MODEL=$(echo "$CATALOG" | sort -V | tail -1)
 
-# Fail fast on blocked quota before launching a long review. The probe uses
-# an idle timeout, not a wall-clock timeout, so active output is allowed to continue.
-# The probe succeeds as soon as it observes the expected success marker instead of
-# waiting for the CLI to finish teardown after the reply has already arrived.
+# Fail fast on blocked quota before launching a long review. The typed runtime
+# consumes provider JSON events and resets its idle clock only on semantic progress.
 [ -n "$MODEL" ] || { echo "No OpenCode Go model resolved for this reviewer." >&2; exit 2; }
 OPENCODE_GO_REVIEW_EFFORT=${OPENCODE_GO_REVIEW_EFFORT:-medium}
 [ "$OPENCODE_GO_REVIEW_EFFORT" = medium ] || [ "$OPENCODE_GO_REVIEW_EFFORT" = high ] || { echo "OPENCODE_GO_REVIEW_EFFORT must be one of: medium, high" >&2; exit 2; }
-OPENCODE_GO_PROBE_TIMEOUT=${OPENCODE_GO_PROBE_TIMEOUT:-20}
-case "$OPENCODE_GO_PROBE_TIMEOUT" in
-  ""|*[!0-9]*) echo "OPENCODE_GO_PROBE_TIMEOUT must be a positive integer number of seconds" >&2; exit 2 ;;
-esac
-[ "$OPENCODE_GO_PROBE_TIMEOUT" -gt 0 ] || { echo "OPENCODE_GO_PROBE_TIMEOUT must be a positive integer number of seconds" >&2; exit 2; }
-PROBE_LOG=$(mktemp -t wp-opencode-go-probe.XXXXXX)
-unset PROBE_RC
-opencode run --format json --variant "$OPENCODE_GO_REVIEW_EFFORT" --model "$MODEL" --title opencode-go-credit-probe 'Reply exactly OPENCODE_GO_OK.' >"$PROBE_LOG" 2>&1 &
-PROBE_PID=$!
-LAST_PROBE_SIZE=$(wc -c <"$PROBE_LOG" | tr -d " ")
-LAST_PROBE_PROGRESS_AT=$(date +%s)
-while kill -0 "$PROBE_PID" 2>/dev/null; do
-  if grep -q "OPENCODE_GO_OK" "$PROBE_LOG"; then
-    kill "$PROBE_PID" 2>/dev/null || true
-    wait "$PROBE_PID" 2>/dev/null || true
-    PROBE_RC=0
-    break
-  fi
-  CURRENT_PROBE_SIZE=$(wc -c <"$PROBE_LOG" | tr -d " ")
-  NOW=$(date +%s)
-  if [ "$CURRENT_PROBE_SIZE" -gt "$LAST_PROBE_SIZE" ]; then
-    LAST_PROBE_SIZE=$CURRENT_PROBE_SIZE
-    LAST_PROBE_PROGRESS_AT=$NOW
-  elif [ $((NOW - LAST_PROBE_PROGRESS_AT)) -gt "$OPENCODE_GO_PROBE_TIMEOUT" ]; then
-    printf '\nOPENCODE_GO_PROBE_TIMEOUT after %ss without progress\n' "$OPENCODE_GO_PROBE_TIMEOUT" >>"$PROBE_LOG"
-    kill -KILL "$PROBE_PID" 2>/dev/null || true
-    wait "$PROBE_PID" 2>/dev/null || true
-    PROBE_RC=124
-    break
-  fi
-  sleep 1
-done
-if [ -z "${PROBE_RC+x}" ]; then
-  if grep -q "OPENCODE_GO_OK" "$PROBE_LOG"; then
-    PROBE_RC=0
-  else
-    wait "$PROBE_PID" || PROBE_RC=$?
-  fi
-fi
-if [ "$PROBE_RC" -eq 0 ] && ! grep -q "OPENCODE_GO_OK" "$PROBE_LOG"; then
-  echo "OpenCode Go probe finished without the expected success marker." >>"$PROBE_LOG"
-  PROBE_RC=1
-fi
-if [ "$PROBE_RC" -ne 0 ]; then
-  echo "OpenCode Go probe failed or timed out for $MODEL after ${OPENCODE_GO_PROBE_TIMEOUT}s; skipping this reviewer instead of starting the full review." >&2
-  sed -n '1,80p' "$PROBE_LOG" >&2
-  rm -f "$PROBE_LOG"
-  exit "$PROBE_RC"
-fi
-rm -f "$PROBE_LOG"
-opencode run --variant "$OPENCODE_GO_REVIEW_EFFORT" --model "$MODEL" "$(cat "$PROMPT_FILE")"
+OPENCODE_GO_PROBE_IDLE_SECONDS=${OPENCODE_GO_PROBE_IDLE_SECONDS:-180}
+OPENCODE_GO_REVIEW_IDLE_SECONDS=${OPENCODE_GO_REVIEW_IDLE_SECONDS:-180}
+OPENCODE_GO_REVIEW_ARTIFACT_ROOT=${OPENCODE_GO_REVIEW_ARTIFACT_ROOT:-"$(pwd)/.webpresso/reviews"}
+PROBE_FILE=$(mktemp -t wp-opencode-go-probe.XXXXXX)
+trap 'rm -f "$PROMPT_FILE" "$PROBE_FILE"' EXIT
+printf 'Reply exactly OPENCODE_GO_OK.\n' >"$PROBE_FILE"
+
+wp review run \
+  --provider opencode \
+  --prompt-file "$PROBE_FILE" \
+  --model "$MODEL" \
+  --effort "$OPENCODE_GO_REVIEW_EFFORT" \
+  --stage probe \
+  --expected-marker OPENCODE_GO_OK \
+  --artifact-root "$OPENCODE_GO_REVIEW_ARTIFACT_ROOT" \
+  --idle-seconds "$OPENCODE_GO_PROBE_IDLE_SECONDS"
+
+wp review run \
+  --provider opencode \
+  --prompt-file "$PROMPT_FILE" \
+  --model "$MODEL" \
+  --effort "$OPENCODE_GO_REVIEW_EFFORT" \
+  --stage review \
+  --artifact-root "$OPENCODE_GO_REVIEW_ARTIFACT_ROOT" \
+  --idle-seconds "$OPENCODE_GO_REVIEW_IDLE_SECONDS"
 ```
 
 If `$MODEL` is empty, run `opencode models opencode-go` and choose a present reviewer.
+Treat `true-idle`, `protocol-unsupported`, provider failure, abort, spawn failure, or artifact failure as unavailable review evidence. Never replace them with a static timeout, arbitrary byte-growth heartbeat, or buffered-output fallback.

package/skills/ralplan/SKILL.md

@@ -0,0 +1,50 @@
+---
+type: skill
+slug: ralplan
+title: Ralplan Consensus Planning
+status: active
+scope: repo
+applies_to: [agents]
+related: [plan-refine, plan-eng-review, plan-ceo-review, plan-design-review, plan-devex-review]
+created: "2026-07-13"
+last_reviewed: "2026-07-13"
+name: ralplan
+description: "Consensus planning gate for plan-refine"
+---
+
+# Ralplan Consensus Planning
+
+Use when the user invokes `$ralplan`, asks for RALPLAN, or wants consensus planning before execution.
+
+`ralplan` is an agent-kit planning gate, not an implementation lane. It applies consensus review to a durable plan before execution starts.
+
+## Workflow
+
+1. Create or identify the durable blueprint or plan artifact that will own the work.
+2. Run the `plan-refine` methodology against that artifact: verify local code facts, verify external claims when relevant, sharpen acceptance criteria, split independent work, and lock verification gates.
+3. Apply the relevant review lenses before execution:
+   - `plan-eng-review` for architecture, sequencing, tests, and rollout risk.
+   - `plan-ceo-review` when scope, customer value, or sequencing tradeoffs matter.
+   - `plan-design-review` when UI/UX is material.
+   - `plan-devex-review` when docs, CLI/API ergonomics, onboarding, or migration risk is material.
+4. Consolidate the reviews into one decision record with:
+   - decision and drivers
+   - alternatives considered
+   - material corrections
+   - implementation tasks and dependencies
+   - verification gates
+   - residual risks or blockers
+5. Stop at an approved plan or an explicit blocker. Do not edit implementation code from this skill unless the user explicitly changes the task from planning to execution.
+
+## Output
+
+Return a concise consensus plan with:
+
+- verdict: ready / ready with edits / blocked
+- decision and rationale
+- accepted review findings
+- task breakdown
+- required verification
+- recommended execution lane, usually `goal` for durable sequential work or `autopilot` for the full autonomous pipeline
+
+Use `plan-refine` as the detailed checklist source of truth when deeper plan surgery is needed.

package/skills/team/SKILL.md

@@ -0,0 +1,60 @@
+---
+type: skill
+slug: team
+title: Team
+status: active
+scope: repo
+applies_to: [agents]
+related: [autopilot, goal, plan-refine, verify]
+created: "2026-07-13"
+last_reviewed: "2026-07-13"
+name: team
+description: "Coordinate multiple dashboard-backed agent sessions on one task."
+argument-hint: "<brief|role plan>"
+---
+
+# Team
+
+Use `team` when the work needs coordinated parallel lanes with a leader-owned
+task list, explicit handoffs, and independent verification. Prefer native
+subagents for small bounded lookups; use `team` when the parallel work should be
+visible, durable, and operator-controllable from `wp dash`.
+
+## Protocol
+
+1. Start from a grounded brief or an approved blueprint. If scope is vague, run
+   `plan-refine` first and define task lanes, shared files, and verification.
+2. Open or reuse `wp dash` and launch the provider sessions needed for the
+   lanes. Direct `wp claude`, `wp codex`, and `wp opencode` commands are
+   expected to enter the dashboard in interactive terminals.
+3. Assign one owner per lane. Include the task, allowed files or surfaces,
+   expected output, verification command, and blocker-report rule.
+4. Keep one lane or leader pass responsible for integration and evidence.
+   Workers report findings, patches, tests, and unresolved risks; they do not
+   self-approve or mark blueprint tasks complete.
+5. Integrate only after checking shared-file conflicts, updated assumptions,
+   and verification evidence. Use `wp_blueprint_task_verify` for task completion
+   when a blueprint owns the work.
+6. Stop when every lane is complete, cancelled, or explicitly blocked and the
+   leader has recorded verification evidence.
+
+## Coordination Rules
+
+- Use a single source of truth for assignments: the blueprint, goal handoff, or
+  leader-maintained task list.
+- Require ACK-style lane starts for shared files, dependency boundaries, or
+  handoffs.
+- Reassign or narrow blocked lanes instead of letting work drift.
+- Escalate changed assumptions before widening scope.
+- Never bypass review provenance, push to main, self-approve, or increase
+  timeouts to hide coordination failures.
+
+## Output
+
+Report:
+
+- lane roster and ownership
+- files or surfaces touched by each lane
+- integration decisions and conflicts resolved
+- verification commands and results
+- remaining blockers or risks

package/skills/verify/SKILL.md

@@ -7,14 +7,10 @@ scope: repo
 applies_to: [agents]
 related: [testing-philosophy, tph]
 created: "2026-05-07"
-last_reviewed: "2026-07-03"
+last_reviewed: "2026-07-13"
 name: verify
 description: "Post-implementation quality gate: run checks, TPH audit, cleanup, docs, proof."
 argument-hint: "<target> [--full] where target is: package|file|plan-slug|all"
-hooks:
-  Stop:
-    - command: wp audit agents
-      timeout: 20
 ---
 
 # Verify
@@ -182,6 +178,10 @@ Reviewer preference:
 
 Approval evidence requirements:
 
+- For blueprint lifecycle approval workflows, run `wp review gate <blueprint-slug> --target HEAD --json`
+  first so exact-SHA reusable evidence and approval frontmatter are handled
+  transactionally. Use `wp review log` / `wp review read` for focused ledger
+  inspection or manual evidence recording.
 - Each outside reviewer must return a clear `APPROVED`/`BLOCKED` (or equivalent)
   verdict with enough evidence to identify what it reviewed.
 - Record outside approval evidence as PR comments when a PR exists.