@toolu/opencode 6.8.0

package/plugins/rust-quality/hooks/concerns/99-finalize.sh

@@ -0,0 +1,36 @@
+# --- Output ---
+
+if [[ -n "$MESSAGES" ]]; then
+  # Record this file's violation in the gate status file (entry keyed by file
+  # path — does not clobber failures recorded for other files or hooks).
+  GATE_DIR="$(toolu_project_state_root "$PROJECT_ROOT")"
+  GATE_FILE="$GATE_DIR/quality-gate-status.json"
+  mkdir -p "$GATE_DIR"
+  gate_record_failure "$GATE_FILE" "$FILE_PATH" "rust-quality-hook" \
+    "Post-edit Rust quality violation(s) detected" "$MESSAGES"
+
+  jq -n --arg ctx "$MESSAGES" '{
+    "hookSpecificOutput": {
+      "hookEventName": "PostToolUse",
+      "additionalContext": ("QUALITY VIOLATION — fix before proceeding:\n" + $ctx)
+    }
+  }'
+else
+  # Clear this file's entry now that it passes (only if this hook set it).
+  # Other files' failures stay recorded; the gate only flips to passing when
+  # no entry remains.
+  GATE_FILE="$(toolu_project_state_root "$PROJECT_ROOT")/quality-gate-status.json"
+  gate_clear_file "$GATE_FILE" "$FILE_PATH" "rust-quality-hook"
+
+  # Docs advisory (non-blocking — no gate write).
+  if [[ -n "$DOC_ADVISORY" ]]; then
+    jq -n --arg ctx "$DOC_ADVISORY" '{
+      "hookSpecificOutput": {
+        "hookEventName": "PostToolUse",
+        "additionalContext": $ctx
+      }
+    }'
+  fi
+fi
+
+exit 0

package/plugins/rust-quality/hooks/hooks.json

@@ -0,0 +1,19 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/register.sh"
+          },
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/check-toolu.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/rust-quality/hooks/register.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# SessionStart registry sync for the rust-quality plugin.
+#
+# Assembles hooks/concerns/[0-9][0-9]-*.sh (ordered preamble → concern partials
+# → finalize) into ONE runtime module in the toolu registry
+# (${TOOLU_CONFIG_DIR:-${CLAUDE_CONFIG_DIR:-$HOME/.claude}}/toolu/post-tools.d/) under the
+# namespaced filename rust-quality@toolu__rust-quality.sh. The fragments are
+# partials of a single script; concatenating them in numeric order rebuilds the
+# original monolith so one process does one gate write (preserving
+# byte-identical behavior). Prunes any stale entry bearing OUR prefix, and
+# clears our own crashed tmp residue. Other plugins' entries are never touched.
+#
+# Silent on success (SessionStart stdout becomes context); errors are
+# non-fatal — a failed sync means the registry copy is stale, not broken.
+
+SPEC="rust-quality@toolu"
+OUT="rust-quality.sh"
+SELF_DIR="$(cd "$(dirname "$0")" && pwd)"
+SRC_DIR="$SELF_DIR/concerns"
+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_DIR="$CONFIG_ROOT/toolu/post-tools.d"
+
+# Consume stdin so Claude Code's hook IPC never stalls.
+cat > /dev/null 2>&1 || true
+
+[ -d "$SRC_DIR" ] || exit 0
+mkdir -p "$REG_DIR" 2>/dev/null || exit 0
+
+# Clear OUR orphaned atomic-write residue from prior crashed runs. Age-gated
+# so a concurrent SessionStart's in-flight tmp (seconds old) is never clobbered.
+find "$REG_DIR" -maxdepth 1 -name "${SPEC}__*.sh.tmp.*" -mmin +1 -delete 2>/dev/null
+
+# Assemble: concatenate the numeric-prefixed fragments in lexical order into one
+# module. A newline guard between fragments keeps a fragment that lacks a
+# trailing newline from running into the next. __tests__/ and any non-prefixed
+# .sh are skipped by the glob.
+dst="$REG_DIR/${SPEC}__${OUT}"
+tmp="${dst}.tmp.$$"
+: > "$tmp"
+for src in "$SRC_DIR"/[0-9][0-9]-*.sh; do
+  [ -f "$src" ] || continue
+  cat "$src" >> "$tmp" 2>/dev/null || { rm -f "$tmp"; exit 0; }
+  printf '\n' >> "$tmp" 2>/dev/null || { rm -f "$tmp"; exit 0; }
+done
+if [ -s "$tmp" ] && { [ ! -f "$dst" ] || ! cmp -s "$tmp" "$dst"; }; then
+  mv "$tmp" "$dst" 2>/dev/null || rm -f "$tmp"
+else
+  rm -f "$tmp"
+fi
+
+# Prune: remove any entry bearing OUR prefix that is not the current assembled
+# module (e.g. per-concern files left by an older version). Never glob outside
+# our own spec prefix.
+for old in "$REG_DIR/${SPEC}__"*.sh; do
+  [ -f "$old" ] || continue
+  [ "$(basename "$old")" = "${SPEC}__${OUT}" ] || rm -f "$old"
+done
+
+exit 0

package/plugins/statusline/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "statusline",
+  "version": "6.8.0",
+  "description": "Host-native project status: a persistent Claude Code statusline plus an explicit Codex status skill for repository, gate, git, comemory, and Jev readiness. Standalone, no dependencies.",
+  "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",
+    "statusline",
+    "quality-gate",
+    "comemory",
+    "jev"
+  ]
+}

package/plugins/statusline/.codex-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "statusline",
+  "version": "6.8.0",
+  "description": "Host-native project status: a persistent Claude Code statusline plus an explicit Codex status skill for repository, gate, git, comemory, and Jev readiness. Standalone, no dependencies.",
+  "skills": "./skills/",
+  "hooks": "./hooks/hooks.json"
+}

package/plugins/statusline/README.md

@@ -0,0 +1,108 @@
+# statusline
+
+Host-native project status. Claude Code gets an optional persistent one-line
+statusline assembled defensively from the JSON Claude sends on stdin:
+
+```
+model | effort:high | ctx:45k/200k (22%) | example.com | ✗ gate:failing | my-folder | main ↑2↓1 [+2 ~1 ?3] | [COMEMORY:42] | [JEV:READY]
+```
+
+| Segment | Source | Shows when |
+|---------|--------|------------|
+| model | `.model.display_name` | always |
+| effort | `.effort.level` | the model reports an effort level |
+| ctx | `.context_window.*` | always |
+| `example.com` | `.oauthAccount.emailAddress` in `~/.claude.json` (or `$CLAUDE_CONFIG_DIR/.claude.json`) | logged in via Claude OAuth — shows only the email domain, not the full address |
+| `✗ gate:failing` | host-native `.claude/tmp/quality-gate-status.json` at the git root | a **gate writer** (e.g. the `rust-quality` / `ts-quality` / `python-quality` / `toolu` plugins) marks the gate failing |
+| folder + branch + status | git, from the workspace dir | inside a git repo — `↑N↓M` shows ahead/behind of the tracked remote, `[+N ~N ?N]` shows staged/unstaged/untracked file counts (both omitted when clean and up-to-date) |
+| `[COMEMORY:N]` | `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/comemory-status/<repo>.json` | the **comemory** plugin published a memory count this session |
+| `[JEV:READY]` / `[JEV:UNAVAILABLE: reason]` | `<config-dir>/jev/jev.sh`, curl, and `TYPESAFE_API_KEY` in the environment | Jev published a wrapper; green when locally ready, yellow with the reason when unavailable |
+
+Codex exposes `$statusline:status` instead of a persistent bar. It reports the
+repository, branch/ahead/behind state, working-tree counts, quality gate from
+`<repo>/.codex/tmp/quality-gate-status.json`, comemory count, and Jev readiness
+(`Jev: ready` or `Jev: unavailable — reason`). It deliberately
+omits account, model, effort, and context-window fields that Codex does not make
+available to the skill.
+
+Jev readiness uses the active host's config directory (`CLAUDE_CONFIG_DIR` or
+`CODEX_HOME`, with `TOOLU_CONFIG_DIR` taking priority). It checks for an executable
+wrapper, curl, and a nonempty API key without line breaks. It never prints the
+key, reads `.env`, executes the wrapper, or makes an API call. **Ready means local
+prerequisites are present**; it does not verify authentication or service health.
+An unpublished wrapper hides the segment; a broken published wrapper shows
+`missing executable wrapper`. Other reasons include `missing curl`,
+`missing TYPESAFE_API_KEY`, and `invalid TYPESAFE_API_KEY`. Multiple reasons are
+separated by semicolons. As with the rest of the status display, jq is required.
+
+The account, gate, comemory, and git status segments degrade gracefully — if the file
+they read is absent, the segment simply doesn't render. So statusline is
+**standalone**: it declares no plugin dependencies. Those segments just light up
+automatically when the relevant plugins are also installed (or, for the account
+segment, when you're logged in via Claude OAuth rather than an API key).
+
+## Codex install
+
+```bash
+codex plugin add statusline@toolu
+```
+
+Run `$statusline:status` whenever you want a current report. No setup or
+persistent renderer is required.
+
+## Claude Code install & wire up
+
+Claude Code does not let a plugin declare `statusLine` in its manifest, so the
+SessionStart hook symlinks the script to a stable, version-independent path:
+
+```
+~/.claude/statusline/statusline.sh   (→ the installed plugin's statusline.sh)
+```
+
+1. Install the plugin:
+
+   ```
+   /plugin install statusline@toolu
+   ```
+
+2. Wire it once. Easiest — run the bundled command:
+
+   ```
+   /statusline:setup
+   ```
+
+   It adds the `statusLine` key below to your `settings.json` idempotently:
+   it backs the file up first, never clobbers an existing custom statusLine
+   (re-run `/statusline:setup --force` if you do want to replace one), and is a
+   no-op once wired. Restart the session afterwards for the bar to appear.
+
+   Or wire it by hand:
+
+   ```json
+   {
+     "statusLine": {
+       "type": "command",
+       "command": "bash ~/.claude/statusline/statusline.sh"
+     }
+   }
+   ```
+
+   (Use `$CLAUDE_CONFIG_DIR/statusline/statusline.sh` if you run with a custom
+   config dir.) The symlink is refreshed every session, so plugin updates are
+   picked up automatically with no settings change. The hook never clobbers a
+   real file you place at that path — it only owns its own symlink.
+
+## Migrating from toolu ≤ 1.5.0
+
+The statusline used to ship inside the `toolu` plugin and auto-symlinked to
+`~/.claude/toolu/statusline.sh`. It now lives here. To keep your statusline:
+
+- `/plugin install statusline@toolu`, and
+- re-point `settings.json` from `~/.claude/toolu/statusline.sh` to
+  `~/.claude/statusline/statusline.sh` — `/statusline:setup --force` does this
+  for you (the old path is a custom value to it, so plain `/statusline:setup`
+  would refuse).
+
+Toolu no longer creates the old symlink and sweeps away the dangling one it
+used to own, so an un-migrated `settings.json` will fail loudly (missing file)
+rather than silently pointing into a cleaned plugin cache.

package/plugins/statusline/commands/setup.md

@@ -0,0 +1,30 @@
+# Set up the statusline
+
+Wire the statusline into the user's Claude Code `settings.json` so the status
+bar renders. The plugin's SessionStart hook already maintains the script
+symlink, but Claude Code reads `statusLine` only from `settings.json` and a
+plugin cannot declare it — this command adds that one key, safely and
+idempotently. It never clobbers an existing custom statusLine and backs the
+file up before any write.
+
+## Steps
+
+1. Run the setup script. Pass `--force` through **only** if the user explicitly
+   asked to replace an existing custom statusLine:
+
+   ```bash
+   bash "${CLAUDE_PLUGIN_ROOT}/scripts/setup.sh" $ARGUMENTS
+   ```
+
+2. Read the first word of the output (the STATUS token) and report:
+   - **WIRED** / **CREATED** — success. Tell the user to **restart the session**
+     (or `/clear`) for the status bar to appear; `statusLine` loads at session
+     start.
+   - **ALREADY** — already wired; nothing to do.
+   - **REFUSED** — a different statusLine is already set. Show the current value
+     the script printed, and tell the user to re-run `/statusline:setup --force`
+     to replace it (or wire it by hand).
+   - **ERROR** — relay the message; do not retry blindly.
+
+Do not hand-edit `settings.json` — the script round-trips the JSON and keeps a
+`settings.json.bak` backup.

package/plugins/statusline/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/statusline/hooks/session-start.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# SessionStart hook for the statusline plugin.
+#
+# Claude Code does not let a plugin declare `statusLine` in its manifest, so we
+# symlink the script to a stable, version-independent path that settings.json
+# can point at without hardcoding the version-specific plugin cache dir:
+#   ${CLAUDE_CONFIG_DIR:-$HOME/.claude}/statusline/statusline.sh
+# The symlink is refreshed every session, so plugin updates are picked up with
+# no settings change. statusline is self-contained — this hook sources no
+# toolu libs; the registry root is just the config dir + /statusline.
+#
+# Silent on success; every step is non-fatal (a failed symlink means the
+# statusline is stale, not that the session breaks).
+
+# Consume stdin so Claude Code's hook IPC never stalls.
+cat > /dev/null 2>&1 || true
+
+# Resolve the plugin dir from this hook's location: hooks/.. = plugin root.
+# If the cd fails, skip rather than symlinking a bogus "/statusline.sh" path.
+plugin_dir="$(cd "$(dirname "$0")/.." 2>/dev/null && pwd)"
+statusline_src="${plugin_dir:+$plugin_dir/statusline.sh}"
+[ -n "$statusline_src" ] && [ -f "$statusline_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/statusline"
+# Non-fatal hook: a failure here (e.g. a non-directory file occupies $reg_root)
+# must not break the session, but leave one stderr breadcrumb so the otherwise-
+# silent no-op is debuggable.
+mkdir -p "$reg_root" 2>/dev/null || { echo "statusline: cannot create $reg_root — statusline not wired" >&2; exit 0; }
+
+# Own the path only when it is already our symlink or absent — never clobber a
+# real file a user may have placed at $reg_root/statusline.sh. (-L catches a
+# broken/relinked symlink that -e would report as missing.)
+dst="$reg_root/statusline.sh"
+if [ -L "$dst" ] || [ ! -e "$dst" ]; then
+  ln -sf "$statusline_src" "$dst" 2>/dev/null || true
+fi
+
+exit 0

package/plugins/statusline/scripts/collect-status.sh

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# Collect host-neutral project status as JSON for renderers and explicit skills.
+set -euo pipefail
+
+command -v jq >/dev/null 2>&1 || {
+  printf '%s\n' 'collect-status: jq is required' >&2
+  exit 1
+}
+
+# Omitted cwd uses the current directory; an explicit empty cwd is profile-only.
+cwd="${1-$PWD}"
+if [ "${TOOLU_HOST_OVERRIDE:-}" = codex ] || {
+  [ -z "${TOOLU_HOST_OVERRIDE:-}" ] && [ -n "${PLUGIN_ROOT:-}" ]
+}; then
+  host=codex
+  config_root="${TOOLU_CONFIG_DIR:-${CODEX_HOME:-$HOME/.codex}}"
+  project_state=.codex
+else
+  host=claude
+  config_root="${TOOLU_CONFIG_DIR:-${CLAUDE_CONFIG_DIR:-$HOME/.claude}}"
+  project_state=.claude
+fi
+
+repo_root=""
+branch=""
+folder=""
+ahead=0
+behind=0
+staged=0
+unstaged=0
+untracked=0
+if [ -d "$cwd" ]; then
+  folder=$(basename "$cwd")
+  repo_root=$(git -C "$cwd" --no-optional-locks rev-parse --show-toplevel 2>/dev/null || true)
+fi
+
+if [ -n "$repo_root" ]; then
+  branch=$(git -C "$cwd" --no-optional-locks symbolic-ref --short HEAD 2>/dev/null || true)
+  first=1
+  while IFS= read -r line; do
+    if [ "$first" -eq 1 ]; then
+      first=0
+      case "$line" in
+        "## "*)
+          rest="${line:3}"
+          case "$rest" in
+            *ahead*)
+              value="${rest#*ahead }"
+              ahead="${value%%,*}"
+              ahead="${ahead%% *}"
+              ahead="${ahead%]}"
+              ;;
+          esac
+          case "$rest" in
+            *behind*)
+              value="${rest#*behind }"
+              behind="${value%%,*}"
+              behind="${behind%% *}"
+              behind="${behind%]}"
+              ;;
+          esac
+          ;;
+      esac
+      continue
+    fi
+    [ "${#line}" -ge 2 ] || continue
+    case "${line:0:2}" in
+      "??") untracked=$((untracked + 1)) ;;
+      "!!") ;;
+      *)
+        [ "${line:0:1}" = " " ] || staged=$((staged + 1))
+        [ "${line:1:1}" = " " ] || unstaged=$((unstaged + 1))
+        ;;
+    esac
+  done < <(git -C "$cwd" --no-optional-locks status --porcelain --branch 2>/dev/null || true)
+fi
+
+gate_status=""
+gate_reason=""
+gate_file="${repo_root:-$cwd}/$project_state/tmp/quality-gate-status.json"
+if [ -n "$cwd" ] && [ -f "$gate_file" ]; then
+  gate_status=$(jq -r '.status | strings // empty' "$gate_file" 2>/dev/null || true)
+  gate_reason=$(jq -r '.reason | strings // empty' "$gate_file" 2>/dev/null || true)
+fi
+
+comemory_count=""
+if [ -n "$repo_root" ]; then
+  common_dir=$(git -C "$cwd" --no-optional-locks rev-parse --git-common-dir 2>/dev/null || true)
+  if [ -n "$common_dir" ]; then
+    case "$common_dir" in
+      /*) ;;
+      *) common_dir=$(cd "$cwd" 2>/dev/null && cd "$common_dir" 2>/dev/null && pwd) || common_dir="" ;;
+    esac
+    if [ -n "$common_dir" ]; then
+      marker="$config_root/comemory-status/$(basename "$(dirname "$common_dir")").json"
+      if [ -f "$marker" ]; then
+        comemory_count=$(jq -r '.count | numbers // empty' "$marker" 2>/dev/null || true)
+      fi
+    fi
+  fi
+fi
+
+# Readiness is local configuration, not a service health check. Never execute
+# the wrapper or send a request on the statusline's per-prompt hot path.
+jev_status=""
+jev_reason=""
+jev_wrapper="$config_root/jev/jev.sh"
+if [ -e "$jev_wrapper" ] || [ -L "$jev_wrapper" ]; then
+  if [ ! -f "$jev_wrapper" ] || [ ! -x "$jev_wrapper" ]; then
+    jev_reason="missing executable wrapper; "
+  fi
+  command -v curl >/dev/null 2>&1 || jev_reason="${jev_reason}missing curl; "
+  if [ -z "${TYPESAFE_API_KEY:-}" ]; then
+    jev_reason="${jev_reason}missing TYPESAFE_API_KEY; "
+  elif [[ "$TYPESAFE_API_KEY" == *$'\r'* || "$TYPESAFE_API_KEY" == *$'\n'* ]]; then
+    jev_reason="${jev_reason}invalid TYPESAFE_API_KEY; "
+  fi
+  jev_reason="${jev_reason%; }"
+  if [ -n "$jev_reason" ]; then
+    jev_status=unavailable
+  else
+    jev_status=ready
+  fi
+fi
+
+jq -cn \
+  --arg host "$host" \
+  --arg cwd "$cwd" \
+  --arg repo_root "$repo_root" \
+  --arg folder "$folder" \
+  --arg branch "$branch" \
+  --arg gate_status "$gate_status" \
+  --arg gate_reason "$gate_reason" \
+  --arg comemory_count "$comemory_count" \
+  --arg jev_status "$jev_status" \
+  --arg jev_reason "$jev_reason" \
+  --argjson ahead "${ahead:-0}" \
+  --argjson behind "${behind:-0}" \
+  --argjson staged "$staged" \
+  --argjson unstaged "$unstaged" \
+  --argjson untracked "$untracked" \
+  '{host:$host,cwd:$cwd,repo_root:$repo_root,folder:$folder,branch:$branch,
+    ahead:$ahead,behind:$behind,
+    working_tree:{staged:$staged,unstaged:$unstaged,untracked:$untracked},
+    gate:{status:$gate_status,reason:$gate_reason},
+    jev:{status:$jev_status,reason:$jev_reason},
+    comemory_count:(if $comemory_count == "" then null else ($comemory_count | tonumber) end)}'

package/plugins/statusline/scripts/setup.sh

@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+# /statusline:setup — idempotently wire the statusline into settings.json.
+#
+# Claude Code reads `statusLine` only from settings.json, and a plugin may not
+# declare it in its manifest. So installing the plugin maintains the symlink
+# but cannot turn the status bar on by itself. This script adds the one key,
+# safely:
+#   - never clobbers an existing custom statusLine (pass --force to override)
+#   - backs settings.json up to settings.json.bak before any write
+#   - idempotent: re-running once wired is a no-op
+#
+# Requires python3 for the JSON edit (a half-written settings.json would brick
+# the session — worth the one dependency to round-trip it correctly). Prints a
+# leading STATUS token (WIRED/CREATED/ALREADY/REFUSED/ERROR) the command reads.
+
+set -euo pipefail
+
+force=0
+for arg in "$@"; do
+  case "$arg" in
+    --force | -f) force=1 ;;
+    *) ;;
+  esac
+done
+
+cfg_dir="${CLAUDE_CONFIG_DIR:-$HOME/.claude}"
+settings="$cfg_dir/settings.json"
+
+# Point at the stable symlink the SessionStart hook maintains. Mirror the path
+# style the README documents: a literal ~ for the default dir (Claude Code runs
+# the statusLine command through a shell, so ~ expands), else the explicit dir.
+if [ -n "${CLAUDE_CONFIG_DIR:-}" ]; then
+  desired_cmd="bash \"$CLAUDE_CONFIG_DIR/statusline/statusline.sh\""
+else
+  desired_cmd="bash ~/.claude/statusline/statusline.sh"
+fi
+
+if ! command -v python3 >/dev/null 2>&1; then
+  echo "ERROR python3 not found — add this to $settings manually:"
+  echo "  \"statusLine\": { \"type\": \"command\", \"command\": \"$desired_cmd\" }"
+  exit 1
+fi
+
+python3 - "$settings" "$desired_cmd" "$force" <<'PY'
+import json, os, shutil, sys
+
+settings, desired_cmd, force = sys.argv[1], sys.argv[2], sys.argv[3] == "1"
+marker = "statusline/statusline.sh"
+block = {"type": "command", "command": desired_cmd}
+
+created = False
+if os.path.exists(settings) and os.path.getsize(settings) > 0:
+    try:
+        with open(settings) as f:
+            data = json.load(f)
+    except (ValueError, OSError) as e:
+        print(f"ERROR could not parse {settings}: {e} — not touching it")
+        sys.exit(1)
+    if not isinstance(data, dict):
+        print(f"ERROR {settings} is not a JSON object — not touching it")
+        sys.exit(1)
+else:
+    data, created = {}, True
+
+cur = data.get("statusLine")
+
+# Already ours (matches whether it was wired via ~ or an explicit config dir).
+if isinstance(cur, dict) and marker in str(cur.get("command", "")):
+    print("ALREADY statusLine already points at the statusline plugin — nothing to do.")
+    sys.exit(0)
+
+# A different statusLine is present: refuse rather than overwrite, unless forced.
+if cur is not None and not force:
+    print("REFUSED a different statusLine is already set in settings.json.")
+    print("  current: " + json.dumps(cur))
+    print("  re-run with --force to replace it, or set it manually:")
+    print('    "statusLine": ' + json.dumps(block))
+    sys.exit(3)
+
+os.makedirs(os.path.dirname(settings) or ".", exist_ok=True)
+if os.path.exists(settings):
+    shutil.copy2(settings, settings + ".bak")
+
+data["statusLine"] = block
+with open(settings, "w") as f:
+    json.dump(data, f, indent=2)
+    f.write("\n")
+
+if created:
+    print(f"CREATED wrote {settings} with the statusLine wired. Restart the session to see it.")
+else:
+    print(f"WIRED added statusLine to {settings} (backup: settings.json.bak). Restart the session to see it.")
+PY

package/plugins/statusline/scripts/status.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Print the explicit status report used by the Codex status skill.
+set -euo pipefail
+
+SCRIPT_DIR=$(cd "${BASH_SOURCE[0]%/*}" && pwd)
+status_json=$(TOOLU_HOST_OVERRIDE=codex \
+  bash "$SCRIPT_DIR/collect-status.sh" "${1:-$PWD}")
+
+host=$(jq -r '.host' <<<"$status_json")
+repo_root=$(jq -r '.repo_root' <<<"$status_json")
+folder=$(jq -r '.folder' <<<"$status_json")
+branch=$(jq -r '.branch' <<<"$status_json")
+ahead=$(jq -r '.ahead' <<<"$status_json")
+behind=$(jq -r '.behind' <<<"$status_json")
+staged=$(jq -r '.working_tree.staged' <<<"$status_json")
+unstaged=$(jq -r '.working_tree.unstaged' <<<"$status_json")
+untracked=$(jq -r '.working_tree.untracked' <<<"$status_json")
+gate_status=$(jq -r '.gate.status' <<<"$status_json")
+gate_reason=$(jq -r '.gate.reason' <<<"$status_json")
+comemory=$(jq -r '.comemory_count // empty' <<<"$status_json")
+jev_status=$(jq -r '.jev.status // empty' <<<"$status_json")
+jev_reason=$(jq -r '.jev.reason // empty' <<<"$status_json")
+
+[ "$host" = codex ] && host_label=Codex || host_label='Claude Code'
+printf 'Host: %s\n' "$host_label"
+if [ -n "$repo_root" ]; then
+  printf 'Repository: %s\n' "$repo_root"
+  [ -n "$branch" ] && printf 'Branch: %s' "$branch" || printf 'Branch: detached HEAD'
+  [ "$ahead" -gt 0 ] && printf ' (ahead %s)' "$ahead"
+  [ "$behind" -gt 0 ] && printf ' (behind %s)' "$behind"
+  printf '\n'
+  if [ "$staged" -eq 0 ] && [ "$unstaged" -eq 0 ] && [ "$untracked" -eq 0 ]; then
+    printf 'Working tree: clean\n'
+  else
+    printf 'Working tree: staged %s, unstaged %s, untracked %s\n' \
+      "$staged" "$unstaged" "$untracked"
+  fi
+else
+  printf 'Folder: %s (not a git repository)\n' "$folder"
+fi
+
+case "$gate_status" in
+  failing)
+    printf 'Quality gate: failing'
+    [ -z "$gate_reason" ] || printf ' — %s' "$gate_reason"
+    printf '\n'
+    ;;
+  passing) printf 'Quality gate: passing\n' ;;
+  *) printf 'Quality gate: no recorded state\n' ;;
+esac
+[ -z "$comemory" ] || printf 'Comemory: %s memories\n' "$comemory"
+case "$jev_status" in
+  ready) printf 'Jev: ready\n' ;;
+  unavailable) printf 'Jev: unavailable — %s\n' "$jev_reason" ;;
+esac

package/plugins/statusline/skills/status/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: status
+description: Use when the user asks for current repository, branch, working-tree, quality-gate, comemory, or Jev readiness status in Codex.
+---
+
+# Status
+
+Run `TOOLU_HOST_OVERRIDE=codex bash ../../scripts/status.sh` resolved from this
+skill directory and return its output verbatim. The explicit override is
+required because lifecycle-only plugin variables are not exported to ordinary
+skill shell calls. The report includes only fields available from local
+repository and toolu state. Do not invent Claude-only account, model, effort,
+or context-window values when the active host does not expose them.