@toolu/opencode 6.8.0

package/plugins/toolu/skills/setup/scripts/setup.sh

@@ -0,0 +1,206 @@
+#!/usr/bin/env bash
+# Install toolu's Codex custom-agent profiles without clobbering user files.
+set -euo pipefail
+
+SELF_DIR=$(cd "${BASH_SOURCE[0]%/*}" && pwd)
+PLUGIN_ROOT=$(cd "$SELF_DIR/../../.." && pwd)
+TEMPLATE_DIR="${TOOLU_AGENT_TEMPLATE_DIR:-$PLUGIN_ROOT/assets/agents}"
+CODEX_ROOT="${CODEX_HOME:-${HOME:+$HOME/.codex}}"
+AGENTS_DIR="${CODEX_ROOT:+$CODEX_ROOT/agents}"
+MANAGED_MARKER='# Managed by toolu. Install and update with $toolu:setup.'
+NAMES=(quick-task deep-explore research-agent implementer architect)
+MODELS=(gpt-5.6-luna gpt-5.6-terra gpt-5.6-terra gpt-5.6-terra gpt-5.6-sol)
+EFFORTS=(medium medium medium medium high)
+SANDBOXES=(read-only read-only read-only workspace-write read-only)
+
+usage() {
+  printf '%s\n' 'Usage: setup.sh preview | install [--force] | remove --yes [--force]'
+}
+
+fail() {
+  printf 'toolu setup: %s\n' "$*" >&2
+  exit 1
+}
+
+validate_template() {
+  local index="$1" name file
+  name="${NAMES[$index]}"
+  file="$TEMPLATE_DIR/$name.toml"
+  [ -f "$file" ] || return 1
+  [ "$(grep -Fxc "$MANAGED_MARKER" "$file" || true)" -eq 1 ] || return 1
+  [ "$(grep -Fxc "name = \"$name\"" "$file" || true)" -eq 1 ] || return 1
+  [ "$(grep -Ec '^description = "[^"].*"$' "$file" || true)" -eq 1 ] || return 1
+  [ "$(grep -Fxc "model = \"${MODELS[$index]}\"" "$file" || true)" -eq 1 ] || return 1
+  [ "$(grep -Fxc "model_reasoning_effort = \"${EFFORTS[$index]}\"" "$file" || true)" -eq 1 ] || return 1
+  [ "$(grep -Fxc "sandbox_mode = \"${SANDBOXES[$index]}\"" "$file" || true)" -eq 1 ] || return 1
+  [ "$(grep -Fxc 'developer_instructions = """' "$file" || true)" -eq 1 ] || return 1
+  [ "$(grep -Fxc '"""' "$file" || true)" -eq 1 ] || return 1
+  awk '
+    BEGIN { block=0; assignments=0; starts=0; closes=0; invalid=0 }
+    /^#[[:space:]]*/ || /^[[:space:]]*$/ { next }
+    block {
+      if ($0 == "\"\"\"") { block=0; closes++; next }
+      next
+    }
+    $0 == "developer_instructions = \"\"\"" { block=1; starts++; next }
+    /^(name|description|model|model_reasoning_effort|sandbox_mode) = "[^"\\]*(\\.[^"\\]*)*"$/ {
+      assignments++; next
+    }
+    { invalid=1 }
+    END { exit(invalid || block || assignments != 5 || starts != 1 || closes != 1) }
+  ' "$file" || return 1
+}
+
+classify_install() {
+  local name="$1" source="$TEMPLATE_DIR/$1.toml" target="$AGENTS_DIR/$1.toml"
+  if [ ! -e "$target" ]; then
+    printf 'install'
+  elif cmp -s "$source" "$target"; then
+    printf 'unchanged'
+  elif grep -Fqx "$MANAGED_MARKER" "$target" 2>/dev/null; then
+    printf 'update'
+  else
+    printf 'conflict'
+  fi
+}
+
+classify_remove() {
+  local target="$AGENTS_DIR/$1.toml"
+  if [ ! -e "$target" ]; then
+    printf 'absent'
+  elif grep -Fqx "$MANAGED_MARKER" "$target" 2>/dev/null; then
+    printf 'remove'
+  else
+    printf 'conflict'
+  fi
+}
+
+backup_stamp() {
+  local stamp="${TOOLU_TIMESTAMP:-$(date -u +%Y%m%dT%H%M%SZ)}"
+  case "$stamp" in
+    *[!0-9TZ]*|'') fail "invalid backup timestamp: $stamp" ;;
+  esac
+  printf '%s' "$stamp"
+}
+
+command_name="${1:-}"
+shift 2>/dev/null || true
+force=0
+confirmed=0
+for arg in "$@"; do
+  case "$arg" in
+    --force) force=1 ;;
+    --yes) confirmed=1 ;;
+    *) usage >&2; exit 2 ;;
+  esac
+done
+
+case "$command_name" in
+  preview|install|remove) ;;
+  *) usage >&2; exit 2 ;;
+esac
+[ -n "$AGENTS_DIR" ] || fail 'CODEX_HOME and HOME are both unset'
+
+for index in 0 1 2 3 4; do
+  validate_template "$index" || fail "invalid agent template: $TEMPLATE_DIR/${NAMES[$index]}.toml"
+done
+
+printf 'TARGET %s\n' "$AGENTS_DIR"
+actions=()
+conflicts=0
+for name in "${NAMES[@]}"; do
+  if [ "$command_name" = remove ]; then
+    action=$(classify_remove "$name")
+  else
+    action=$(classify_install "$name")
+  fi
+  actions+=("$action")
+  printf 'PLAN %s %s\n' "$name" "$action"
+  [ "$action" != conflict ] || conflicts=$((conflicts + 1))
+done
+
+if [ "$command_name" = preview ]; then
+  [ "$conflicts" -eq 0 ] || printf 'NOTICE use install --force only after confirming each conflict\n'
+  exit 0
+fi
+
+if [ "$command_name" = remove ] && [ "$confirmed" -ne 1 ]; then
+  printf '%s\n' 'REFUSED removal requires --yes after explicit user confirmation' >&2
+  exit 2
+fi
+if [ "$conflicts" -gt 0 ] && [ "$force" -ne 1 ]; then
+  printf '%s\n' 'REFUSED unmanaged profile conflict; preview it and confirm install/remove --force' >&2
+  exit 2
+fi
+
+stamp=""
+backup_dir=""
+needs_backup=0
+for action in "${actions[@]}"; do
+  case "$action" in update|remove|conflict) needs_backup=1 ;; esac
+done
+if [ "$needs_backup" -eq 1 ]; then
+  stamp=$(backup_stamp)
+  backup_dir="$AGENTS_DIR/.toolu-backups/$stamp"
+  for index in 0 1 2 3 4; do
+    action="${actions[$index]}"
+    case "$action" in
+      update|remove|conflict)
+        [ ! -e "$backup_dir/${NAMES[$index]}.toml" ] || fail "backup already exists: $backup_dir/${NAMES[$index]}.toml"
+        ;;
+    esac
+  done
+fi
+
+mkdir -p "$AGENTS_DIR"
+[ "$needs_backup" -eq 0 ] || mkdir -p "$backup_dir"
+
+if [ "$command_name" = install ]; then
+  installed=0
+  updated=0
+  unchanged=0
+  for index in 0 1 2 3 4; do
+    name="${NAMES[$index]}"
+    action="${actions[$index]}"
+    source="$TEMPLATE_DIR/$name.toml"
+    target="$AGENTS_DIR/$name.toml"
+    case "$action" in
+      unchanged)
+        unchanged=$((unchanged + 1))
+        ;;
+      update|conflict)
+        cp -p "$target" "$backup_dir/$name.toml"
+        tmp="$AGENTS_DIR/.$name.toml.toolu.$$"
+        cp "$source" "$tmp"
+        mv "$tmp" "$target"
+        updated=$((updated + 1))
+        ;;
+      install)
+        tmp="$AGENTS_DIR/.$name.toml.toolu.$$"
+        cp "$source" "$tmp"
+        mv "$tmp" "$target"
+        installed=$((installed + 1))
+        ;;
+    esac
+  done
+  printf 'INSTALLED %d UPDATED %d UNCHANGED %d\n' "$installed" "$updated" "$unchanged"
+else
+  removed=0
+  absent=0
+  for index in 0 1 2 3 4; do
+    name="${NAMES[$index]}"
+    action="${actions[$index]}"
+    target="$AGENTS_DIR/$name.toml"
+    case "$action" in
+      absent) absent=$((absent + 1)) ;;
+      remove|conflict)
+        mv "$target" "$backup_dir/$name.toml"
+        removed=$((removed + 1))
+        ;;
+    esac
+  done
+  printf 'REMOVED %d ABSENT %d\n' "$removed" "$absent"
+fi
+
+[ -z "$backup_dir" ] || printf 'BACKUP %s\n' "$backup_dir"
+printf '%s\n' 'Restart Codex to reload custom agent profiles.'

package/plugins/toolu/skills/spec/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: spec
+description: "Use to write the spec or document the design before planning a new system, cross-cutting feature, public interface, or other durable contract. Clear requirements may enter directly; brainstorm is optional upstream triage."
+---
+
+# Spec
+
+Write a spec when the cost of ambiguity is high. It is the durable contract for
+`plan`, `execution`, and `test`, not a transcript of brainstorming. Start from
+an agreed brainstorm decision when one helped resolve the shape; clear,
+complete requirements may enter here directly. Return to `brainstorm` only when
+a material design choice remains undecided.
+
+Use the mandatory [Jev workflow](../../workflows/semantic-judgments.md) for
+requirement ambiguity and observable outcomes. Agent owns the contract and feasibility.
+
+Write `docs/toolu/specs/<YYYY-MM-DD>-<slug>-design.md`. Keep every section
+short and concrete:
+
+```markdown
+# <Title> — Design
+
+**Date:** <YYYY-MM-DD>   **Status:** Draft   **Author:** <name>   **Topic:** <one line>
+
+## Problem
+The user pain and why it matters now.
+
+## Non-Goals
+Explicit, numbered scope boundaries.
+
+## Architecture
+Chosen approach, the decisive trade-off, and existing paths/utilities to reuse.
+
+## Interfaces / Schema
+Concrete signatures, types, JSON shapes, paths, or config keys.
+
+## Failure modes and edge cases
+Bad, empty, absent, partial, concurrent, or otherwise boundary inputs; state
+the observable behavior and whether failure propagates, is converted, or is
+recovered.
+
+## Acceptance criteria
+- **AC-1:** A testable outcome stated against a real input and observable result.
+
+## Acceptance evidence
+For every AC, name the representative real input or fixture, expected observable
+result, applicable boundary/failure case, and runnable check that will prove it.
+
+## Documentation impact
+State the affected README, `docs/`, `SKILL.md`, command/config, or release-note
+surface; say `None — <reason>` only when no user-facing documentation changes.
+
+## Open Questions
+Unresolved decisions, owner, and whether each question blocks implementation.
+```
+
+Acceptance-criterion ids use stable bold prefixes (`**AC-<n>:**`). They are
+labels rather than indices: gaps are fine, but never reuse an id. Each criterion
+must describe an observable real-data outcome — “given input X, produces Y” —
+so a ledger step can cite it through `ac_refs` and `test` can demonstrate it.
+
+## What done means
+
+Every authored section is filled; acceptance evidence covers every AC; failure
+behavior and documentation impact are explicit; and each open question is
+resolved, owned, or clearly non-blocking. Keep `Status: Draft` and hand off to
+`spec-review`.

package/plugins/toolu/skills/spec-review/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: spec-review
+description: "Use to review the spec or poke holes in this spec before planning or building. Validates authored contract sections, real-data acceptance evidence, scope, and blocking open questions."
+---
+
+# Spec Review
+
+Review the spec adversarially before it becomes a plan. Judge whether a
+competent builder could proceed without guessing; do not add replacement design
+work or praise.
+
+Use the mandatory [Jev workflow](../../workflows/semantic-judgments.md) for
+requirement/evidence alignment. Verify findings against sources; retain this checklist.
+
+## Checklist
+
+Validate exactly the sections authored by `spec`:
+
+- **Problem / Non-Goals** — the user pain and boundary are concrete.
+- **Architecture / Interfaces / Schema** — one decided approach, its trade-off,
+  and buildable contracts/paths are present.
+- **Failure modes and edge cases** — bad, empty, absent, partial, concurrent,
+  and boundary behavior is stated, including failure propagation or recovery.
+- **Acceptance criteria** — every `**AC-<n>:**` names an observable real-data
+  outcome, rather than an implementation activity or “works correctly.”
+- **Acceptance evidence** — every AC has a representative real input or
+  fixture, expected observable result, applicable boundary/failure case, and a
+  runnable check. No mock substitute may stand in for the data under test.
+- **Documentation impact** — affected user-facing documentation is named, or a
+  justified `None` is explicit.
+- **Open Questions** — each has an owner and is explicitly non-blocking; an
+  unanswered question that changes scope, interface, behavior, safety, or a
+  required check is a blocker, not merely owned.
+
+Also reject unstated scope expansion, missing real-data evidence, or an
+architecture that cannot meet the documented size/layout constraints.
+
+## Output
+
+Write one finding per line, with location, severity, problem, and fix:
+
+```
+<section>: 🔴 blocker: <problem>. <fix>.
+<section>: 🟡 should-fix: <gap>. <fix>.
+<section>: 🔵 consider: <minor>. <fix>.
+```
+
+Stamp `**Status:** Approved` only when all authored sections and every AC's
+evidence are sufficient for planning. Otherwise stamp `**Status:** Needs
+changes`, list blockers, and return the spec for revision.

package/plugins/toolu/skills/test/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: test
+description: "Use while executing any feature, fix, refactor, or regression to design high-signal, real-data tests. Enforces test-first discipline and colocated layout; it is a reusable method, not a terminal workflow phase."
+---
+
+# Test
+
+`test` is a **reusable execution-time method**: use it in every behavior step
+and again when reproducing regressions. Tests are written with the change,
+through red → green → refactor, never saved for a terminal phase.
+
+Use the mandatory [Jev workflow](../../workflows/semantic-judgments.md) for
+semantic boundaries in supplied examples. Derive expected outputs and verdicts from contracts and execution.
+
+## Non-negotiables
+
+- Exercise real inputs and real code paths. Do not use mocked or fabricated
+  data as a mock-substitute for the behavior under test. A controlled external
+  failure may be stubbed only to prove failure propagation.
+- Colocate tests: TS/TSX in sibling `__tests__/`, Rust in module-sibling
+  `tests/` (or crate-root integration `tests/`), and Python `test_<module>.py`
+  beside its module. Use the project runner and existing no-mock gates.
+
+## Behavior-to-evidence map
+
+Before writing each test, record a compact map containing:
+
+- relevant AC or risk;
+- representative real input or fixture;
+- observable expected result;
+- boundary or failure case when applicable; and
+- runner command.
+
+Prioritize changed behavior, invalid/boundary input, failure propagation, and
+reproduced regressions. Reject duplicate tests, implementation-detail tests,
+mock-substitute tests, and happy-path-only tests.
+
+## Test-first loop
+
+1. **Red** — add a focused failing test that demonstrates the intended behavior
+   or reproduces the regression; run it and observe the expected failure.
+2. **Green** — make the smallest production change that passes with the real
+   input.
+3. **Refactor** — improve structure without changing behavior; keep the runner
+   green.
+
+One test demonstrates one behavior and names that behavior. A red test is a
+finding: report its output and never claim the execution step complete until
+the mapped runner is green.

package/plugins/toolu/workflows/commit.md

@@ -0,0 +1,21 @@
+# Commit all changes
+
+Commit the current working tree without broad re-exploration.
+
+1. Delegate this bounded workflow to the configured `quick-task` mechanical
+   agent when that agent is available. Otherwise execute it in the current
+   thread. Use the active host mapping in `workflows/host-mapping.md`.
+2. Run only `git status` and `git diff --stat` to establish scope. Explore more
+   only to fix a reported failure.
+3. Stage all changes with `git add -A`; staged checks depend on index state.
+4. Run the project's prescribed check, lint, and test command when one exists
+   in repository instructions, package scripts, a Makefile, or toolchain
+   configuration. If none exists, record that and continue.
+5. On failure, fix only the reported issue, re-stage, and rerun every required
+   gate until green.
+6. Commit with a concise Conventional Commit subject of at most 72 characters.
+   Group a body by package only when it adds useful context.
+7. If commit hooks fail, fix only their findings, re-stage, and retry. Stop
+   after three failed commit attempts and report the evidence.
+
+Do not bypass hooks. Completion requires a created commit and green gates.

package/plugins/toolu/workflows/host-mapping.md

@@ -0,0 +1,22 @@
+# Host mapping
+
+Use the host-native interface for the same workflow concept:
+
+| Concept | Claude Code | Codex |
+| --- | --- | --- |
+| Invoke a plugin workflow | `/plugin:name` | `$plugin:name` |
+| Delegate bounded work | `Agent` / `Task` with an explicit tier | `spawn_agent` with the matching custom agent when installed |
+| Ask a structured user choice | `AskUserQuestion` | `request_user_input` when available; otherwise ask one concise question |
+| Inspect or steer delegated work | the host's agent controls | Codex subagent thread controls (`/agent` in CLI) |
+| Isolate a write-heavy task | `EnterWorktree` / `ExitWorktree` | native `git worktree` commands with an exact, validated path |
+| Current external information | `WebSearch` / `WebFetch` or installed research plugins | Codex web access or installed research plugins |
+
+Never name or call a host interface that is unavailable in the active host. A
+missing optional interface is a reason to use the mapped fallback, not to
+fabricate a tool call.
+
+Workflow skills default-and-proceed according to materiality triage. Use the
+structured question row only for one question (2–3 options) when prompt and
+repository evidence cannot settle a goal-defining or hard-to-reverse fork. If
+several qualify, ask the highest-blast-radius choice and record defaults and
+risks for the rest; otherwise state the recommended default and proceed.

package/plugins/toolu/workflows/review-and-commit.md

@@ -0,0 +1,54 @@
+# Review, fix, and commit completed work
+
+Run this only after implementation is complete. Review the current branch, fix
+real findings, and commit. Do not merge or push.
+
+## 1. Establish scope
+
+- Resolve the current branch with `git rev-parse --abbrev-ref HEAD`.
+- Resolve the default base through `refs/remotes/origin/HEAD`, falling back to
+  `main` only when the remote default is unavailable.
+- Inspect committed scope with `git log <base>..HEAD --oneline` and
+  `git diff <base>...HEAD --stat`.
+- Inspect uncommitted scope with `git status --short` and
+  `git diff --stat HEAD`.
+- Stop with `nothing to review` if both scopes are empty. Otherwise group
+  changed files by package or crate.
+
+## 2. Review each package
+
+Use the host mapping in `workflows/host-mapping.md`. Independent packages may
+be reviewed concurrently; within one package, passes are sequential so every
+reviewer sees the latest diff.
+
+Prefer the installed toolu reviewer (`toolu-review:review` in the active host's
+invocation syntax). An installed repository-specific reviewer may be used when
+it writes a compatible push-review attestation. Optional clarity/simplification
+passes run before correctness review, never concurrently with it.
+
+Review correctness, security, boundary error handling, regressions, missing
+tests, dead code, unnecessary abstraction, unclear naming, and tests that mock
+the integration instead of using real data. Every finding must cite a file and
+line; discard vague feedback.
+
+## 3. Fix findings
+
+- Verify each finding against the code before changing it.
+- Apply every valid finding and rerun relevant tests after each batch.
+- Fix existing errors or warnings in touched files.
+- If the same approach fails twice, stop and change the hypothesis.
+
+## 4. Run full gates
+
+Run the project's full check, lint, typecheck, and test commands as defined by
+repository instructions and toolchain configuration. If none exist, say so.
+Fix failures and rerun all required gates until green.
+
+## 5. Commit intentionally
+
+Stage only files belonging to each logical commit. Use Conventional Commit
+messages and split unrelated changes. Never use `--no-verify`; fix hook
+failures instead.
+
+Report reviewed scope, fixes, final gate results, and produced commit hashes.
+Completion requires green gates and a clean working tree.

package/plugins/toolu/workflows/semantic-judgments.md

@@ -0,0 +1,35 @@
+# Jev workflow
+
+**Mandatory for semantic decisions when available.** Explore → gather evidence →
+call Jev before the informed decision → act. Reassess after new evidence, failed
+hypotheses, or changed requirements. Batch independent questions over shared
+state; reuse results while evidence, questions, and criteria are unchanged.
+Dependent questions wait for their inputs. No quotas or ceremonial calls.
+
+No semantic decision → say so once. Unavailable → state limitation once/task;
+continue from explicit evidence/reasoning. Do not install tools to satisfy this
+rule or invent results.
+
+## Judgment opportunities
+
+| Stage | Ask about supplied evidence |
+| --- | --- |
+| Brainstorm | Compare concrete alternatives per user preference. |
+| Spec | Requirement ambiguity; one observable outcome. |
+| Spec review | Requirement/evidence alignment. |
+| Plan | Classification that changes a step's handling. |
+| Plan review | Step outcome vs. linked requirement. |
+| Search/research | Excerpt relevance, answer existence, claim/source support. |
+| Debug | Hypothesis fit; next experiment; reassess after results. |
+| Execution/review | Finding triage; expected vs. observed behavior. |
+| Test design | Semantic boundaries in supplied examples. |
+
+Use relevant rows, not a stage checklist. Agent/tools own architecture,
+feasibility, exact checks, arithmetic, reproduction, tests, correctness, and
+approval. Jev never waives verification or authorization.
+
+Read the installed `jev` skill for host path, CLI, question contract, and
+uncertainty handling. Load only the needed section of its linked
+`references/problem-solving.md`. Keep state to named, relevant excerpts and
+candidates. Record useful evidence → question → answer → next action; retain
+model/usage with `--raw` during evaluation.

package/plugins/toolu-review/.claude-plugin/plugin.json

@@ -0,0 +1,18 @@
+{
+  "name": "toolu-review",
+  "version": "6.8.0",
+  "description": "Project-tuned pre-push code review mirroring CI falconiere/toolu-ghactions/code-review@v8 (Jev-enabled), writing the toolu push-review state so the gate passes. Standalone.",
+  "author": {
+    "name": "Falconiere Barbosa",
+    "email": "hello@falconiere.io"
+  },
+  "homepage": "https://github.com/falconiere/toolu",
+  "repository": "https://github.com/falconiere/toolu.git",
+  "license": "MIT",
+  "keywords": [
+    "claude-code",
+    "toolu-review",
+    "push-review",
+    "quality"
+  ]
+}

package/plugins/toolu-review/.codex-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "toolu-review",
+  "version": "6.8.0",
+  "description": "Project-tuned pre-push code review mirroring CI falconiere/toolu-ghactions/code-review@v8 (Jev-enabled), writing the toolu push-review state so the gate passes. Standalone.",
+  "skills": "./skills/",
+  "hooks": "./hooks/hooks.json"
+}

package/plugins/toolu-review/README.md

@@ -0,0 +1,17 @@
+# toolu-review
+
+Project-tuned pre-push code review mirroring this repo's CI Toolu Code Review action (`falconiere/toolu-ghactions/code-review@v8`, with Jev assessment enabled), writing the toolu `push-review` state so the gate passes.
+
+## Install
+
+```
+/plugin install toolu-review@toolu
+```
+
+Standalone, no dependencies.
+
+## What it provides
+
+- **`toolu-review:review` skill** — reviews the branch diff against what the CI Toolu Code Review action (`github-actions[bot]` verdict comment, optionally App-branded) flags, so the first-push verdict is clean instead of bouncing low/nit findings back as rework. It also records a clean `push-review` state, satisfying toolu's `push-review` gate.
+
+Explicit — it does not auto-fire on edits. Run it before pushing a feature branch, or when `pr-babysit` needs a reviewer.

package/plugins/toolu-review/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/toolu-review/hooks/session-start.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# SessionStart hook — publish the toolu-review write-state helper at a STABLE,
+# env-independent path. See context7's session-start.sh for the same fix
+# rationale: ${CLAUDE_PLUGIN_ROOT} is exported to hook subprocesses only —
+# NOT to the agent's Bash tool subshell — so a SKILL.md path of
+# "${CLAUDE_PLUGIN_ROOT}/skills/review/scripts/write-state.sh" expands to
+# "/skills/.../write-state.sh: No such file" when an agent pastes it.
+# Mirror the statusline plugin: symlink the helper to
+#   ${CLAUDE_CONFIG_DIR:-$HOME/.claude}/toolu-review/write-state.sh
+# Refreshed every session; silent on success; every step non-fatal.
+
+# Consume stdin so Claude Code's hook IPC never stalls.
+cat > /dev/null 2>&1 || true
+
+plugin_dir="$(cd "$(dirname "$0")/.." 2>/dev/null && pwd)"
+src="${plugin_dir:+$plugin_dir/skills/review/scripts/write-state.sh}"
+[ -n "$src" ] && [ -f "$src" ] || exit 0
+
+if [ -n "${TOOLU_CONFIG_DIR:-}" ]; then
+  config_root="$TOOLU_CONFIG_DIR"
+elif [ "${TOOLU_HOST_OVERRIDE:-}" = codex ] || { [ -z "${TOOLU_HOST_OVERRIDE:-}" ] && [ -n "${PLUGIN_ROOT:-}" ]; }; then
+  config_root="${CODEX_HOME:-$HOME/.codex}"
+else
+  config_root="${CLAUDE_CONFIG_DIR:-$HOME/.claude}"
+fi
+reg_root="$config_root/toolu-review"
+mkdir -p "$reg_root" 2>/dev/null || { echo "toolu-review: cannot create $reg_root — helper not published" >&2; exit 0; }
+
+dst="$reg_root/write-state.sh"
+if [ -L "$dst" ] || [ ! -e "$dst" ]; then
+  ln -sf "$src" "$dst" 2>/dev/null || true
+fi
+
+exit 0