okstra 0.163.2 → 0.165.0

package/runtime/bin/okstra-antigravity-exec.sh

@@ -1,344 +1,5 @@
 #!/usr/bin/env bash
-# okstra-antigravity-exec.sh — wrapper around `agy --print` for okstra antigravity-worker
-#
-# Purpose: Claude Code's Bash permission matcher requires explicit approval for
-# commands that contain shell metacharacters (stdout/stderr redirects, pipes).
-# `agy --print "<prompt>" --model <model> --add-dir <root> 2>>log > <fifo>`
-# therefore triggers a permission prompt every dispatch even when `Bash(agy:*)`
-# is allowlisted, because the redirect tokens disqualify the simple-prefix match.
-#
-# This wrapper accepts positional arguments and performs the redirect inside
-# the script body, so the caller can allowlist a single non-redirect form:
-#
-#   Bash($HOME/.okstra/bin/okstra-antigravity-exec.sh:*)
-#
-# Usage:
-#   okstra-antigravity-exec.sh <project-root> <model-execution-value> <prompt-path> [worktree-path] [role] [idle-timeout-seconds]
-#
-# project-root / model-execution-value / prompt-path are required.
-#
-# idle-timeout-seconds is optional (default 600s, or 1500s for the build-running
-# executor/verifier roles — see the role case below). When > 0, an
-# in-process watchdog polls the live-log mtime; if no stdout/stderr write
-# occurs for that many seconds, the underlying `agy` is SIGTERM'd (then
-# SIGKILL'd after a 5-second grace), the status sidecar gets a
-# `{timeout: true, idle_seconds, idle_at_ts, terminated_by: "idle-watchdog"}`
-# marker, and the wrapper exits non-zero. Pass `0` to disable. Kept in
-# lock-step with `okstra-codex-exec.sh` — see that wrapper for the full
-# design rationale.
-#
-# worktree-path is optional and used for okstra implementation phase, where the
-# executor must mutate files inside a git worktree that lives outside
-# project-root. When supplied (non-empty), it is added to agy's `--add-dir`
-# workspace list so the model can see and operate on the worktree alongside the
-# primary workspace. When omitted or empty, only project-root is added (existing
-# analysis-phase behavior).
-#
-# For linked worktrees, the per-worktree git metadata (index, HEAD, refs) and
-# the shared object database live in the main repository's `.git` directory —
-# OUTSIDE the worktree-path. Without access there, `git add` / `git commit`
-# from inside the worktree fails on `.git/worktrees/<name>/index.lock`. The
-# wrapper resolves the main repo's git-common-dir via `git rev-parse` against
-# the supplied worktree-path and adds it via `--add-dir`. If resolution fails
-# (not a linked worktree, or git unavailable), the extra dir is silently
-# omitted.
-#
-# The wrapper exits non-zero on any preflight failure.
 set -euo pipefail
 
-# Hard ceiling for agy's print-mode wait (Go duration). The idle watchdog below
-# is the primary stall detector; this is a backstop against a run that never
-# stalls but also never finishes.
-PRINT_TIMEOUT="7200s"
-
-if [[ $# -lt 3 || $# -gt 6 ]]; then
-  printf 'usage: %s <project-root> <model-execution-value> <prompt-path> [worktree-path] [role] [idle-timeout-seconds]\n' "$(basename "$0")" >&2
-  exit 64
-fi
-
-project_root="$1"
-model="$2"
-prompt_path="$3"
-worktree_path="${4-}"
-role="${5:-worker}"
-# Implementation executor / verifier dispatches run whole build + test suites
-# that legitimately emit no stdout for many minutes; the 600s idle cap reaps
-# them mid-suite (observed: a silent jest + tsc build TERM'd at ~929s). Default
-# those roles to a longer idle cap that still sits below the 1800s wall-clock
-# polling cap so a genuine hang is reaped early. An explicit 6th arg wins.
-case "$role" in
-  executor | verifier) default_idle_timeout_secs=1500 ;;
-  *) default_idle_timeout_secs=600 ;;
-esac
-idle_timeout_secs="${6:-$default_idle_timeout_secs}"
-
-if ! [[ "$idle_timeout_secs" =~ ^[0-9]+$ ]]; then
-  printf 'okstra-antigravity-exec: idle-timeout-seconds must be a non-negative integer: %q\n' "$idle_timeout_secs" >&2
-  exit 69
-fi
-
-if [[ -z "$project_root" || ! -d "$project_root" ]]; then
-  printf 'okstra-antigravity-exec: project-root is missing or not a directory: %q\n' "$project_root" >&2
-  exit 65
-fi
-
-if [[ -z "$model" ]]; then
-  printf 'okstra-antigravity-exec: model-execution-value is empty\n' >&2
-  exit 66
-fi
-
-if [[ -z "$prompt_path" || ! -f "$prompt_path" ]]; then
-  printf 'okstra-antigravity-exec: prompt-path is missing or not a file: %q\n' "$prompt_path" >&2
-  exit 67
-fi
-
-if ! command -v agy >/dev/null 2>&1; then
-  printf 'okstra-antigravity-exec: agy (Antigravity CLI) is not installed on PATH\n' >&2
-  exit 127
-fi
-
-if [[ -n "$worktree_path" && ! -d "$worktree_path" ]]; then
-  printf 'okstra-antigravity-exec: worktree-path was provided but is not a directory: %q\n' "$worktree_path" >&2
-  exit 68
-fi
-
-# agy has no `--cd` flag, so workspace correctness is anchored via repeatable
-# `--add-dir` plus the Project Root referenced in the prompt body itself.
-add_dir_args=(--add-dir "$project_root")
-if [[ -n "$worktree_path" ]]; then
-  add_dir_args+=(--add-dir "$worktree_path")
-  # For linked worktrees, also open the main repo's `.git` so `git add` /
-  # `git commit` can write the per-worktree index/refs and the shared
-  # object DB. `--git-common-dir` resolves to the main repo's `.git` for
-  # any worktree (linked or main); for a main checkout it equals
-  # `<worktree>/.git` and is redundant-but-harmless. Failures are tolerated
-  # silently so analysis-phase callers stay unaffected.
-  if command -v git >/dev/null 2>&1; then
-    common_git_dir=$(git -C "$worktree_path" rev-parse --git-common-dir 2>/dev/null || true)
-    if [[ -n "$common_git_dir" ]]; then
-      if [[ "$common_git_dir" != /* ]]; then
-        common_git_dir="$worktree_path/$common_git_dir"
-      fi
-      if [[ -d "$common_git_dir" ]]; then
-        common_git_dir=$(cd "$common_git_dir" && pwd -P)
-        add_dir_args+=(--add-dir "$common_git_dir")
-      fi
-    fi
-  fi
-fi
-
-# Derive a live-progress log path next to the prompt. agy streams its progress
-# over stdout/stderr, but the caller (antigravity-worker subagent) only polls
-# `BashOutput` on a 60s cadence — so without a sideband, a long implementation
-# run produces no visible output until the very end. Mirroring both streams into
-# a file alongside the prompt lets the human operator `tail -f <log-path>` from a
-# separate pane and watch progress in real time, and leaves a post-mortem record
-# on disk.
-log_path="${prompt_path%.md}.log"
-[[ "$log_path" == "$prompt_path" ]] && log_path="${prompt_path}.log"
-: > "$log_path"
-
-# stdout-mirror FIFO path (created at the dispatch block below). Declared here,
-# before the EXIT trap is defined, so the trap's cleanup reference is always set
-# under `set -u`.
-stdout_fifo=""
-
-# Heartbeat sidecar (`<prompt>.status.json`). See `okstra-codex-exec.sh` for
-# the full design comment — kept in lock-step. Two consumers:
-#   1. `antigravity-worker` step 8c reads `log_path` to capture a diagnostic
-#      tail when `exit_code == 0` but no Result file was produced.
-#   2. Lead's redispatch policy distinguishes "wrapper never started"
-#      from "CLI ran but produced no artifact" via `stage`/`started_ts`.
-# Writes are best-effort.
-status_path="${prompt_path}.status.json"
-started_ts=$(date +%s)
 script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-# Trace-pane caller resolution helper (okstra_resolve_caller_pane). The lib dir
-# is a bin-sibling in both repo (scripts/lib/...) and installed
-# (~/.okstra/bin/lib/...) layouts; degrade silently if absent.
-[ -r "$script_dir/lib/okstra/tmux-pane.sh" ] && . "$script_dir/lib/okstra/tmux-pane.sh"
-python3 "$script_dir/okstra-wrapper-status.py" \
-  init "$status_path" "$(basename "$0")" "$role" "$$" "$started_ts" "$log_path" \
-  >>"$log_path" 2>&1 || true
-
-# Resolve the run dir and the trace-split anchor pane. See
-# `okstra-codex-exec.sh` / `lib/okstra/tmux-pane.sh` for the full rationale —
-# kept in lock-step: derive `<RUN_DIR>` from the prompt path (paths.py SSOT) to
-# tag the trace pane, and resolve the caller pane by walking our ancestor PIDs
-# against tmux pane_pids (reliable even though `$TMUX`/`$TMUX_PANE` are stripped
-# and the wrapper runs backgrounded). Empty = not inside a tmux pane → skip.
-run_dir="$(cd "$(dirname "$prompt_path")/.." 2>/dev/null && pwd -P || true)"
-
-caller_pane=""
-if type okstra_resolve_caller_pane >/dev/null 2>&1; then
-  caller_pane="$(okstra_resolve_caller_pane)"
-fi
-
-# Pane titles: the caller (worker) pane gets `agy-<role>`; the sibling trace
-# pane is that same caller title with a `-tail` suffix, so the operator can
-# visually pair `<caller> ↔ <caller>-tail`. `role` carries the dispatched Agent
-# name minus the `antigravity-` prefix (e.g. `worker-reverify-r1`, `executor`), so
-# the pane title equals the FleetView teammate name instead of a generic `worker`.
-pane_label="agy-${role}"
-trace_label="${pane_label}-tail"
-
-# Capture the caller pane's current title so the EXIT trap can restore it
-# once the wrapper returns. Empty when not in tmux or capture fails — the
-# restore step degrades to a no-op in that case.
-original_caller_title=""
-if [[ -n "$caller_pane" ]]; then
-  original_caller_title=$(tmux display-message -p -t "$caller_pane" '#{pane_title}' 2>/dev/null || true)
-fi
-
-_okstra_status_finish() {
-  local exit_code=$?
-  local ended_ts
-  ended_ts=$(date +%s)
-  local duration_ms=$(( (ended_ts - started_ts) * 1000 ))
-  python3 "$script_dir/okstra-wrapper-status.py" \
-    finish "$status_path" "$exit_code" "$ended_ts" "$duration_ms" \
-    >>"$log_path" 2>&1 || true
-  if [[ -n "$caller_pane" && -n "$original_caller_title" ]]; then
-    tmux select-pane -t "$caller_pane" -T "$original_caller_title" 2>/dev/null || true
-  fi
-  [[ -n "$stdout_fifo" ]] && rm -f "$stdout_fifo" 2>/dev/null || true
-}
-trap _okstra_status_finish EXIT
-
-# Label the caller (worker) pane now that the restore trap is armed. Any
-# failure after this point still rewinds the title to its prior value.
-if [[ -n "$caller_pane" ]]; then
-  tmux select-pane -t "$caller_pane" -T "$pane_label" 2>/dev/null || true
-fi
-
-# When a tmux session is reachable, split a sibling pane tailing the log so
-# the operator can watch progress live. This fires in every phase the
-# wrapper is invoked from — long-running agy dispatches are not
-# implementation-specific. Title `agy-<role>-tail` so the operator
-# can pair it with its caller pane (`agy-<role>`). The split is
-# explicitly anchored to the caller pane to avoid attaching to tmux's idle
-# active pane. `role` is the optional 5th positional arg (defaults to
-# `worker`); callers that dispatch a different role (e.g. `worker-reverify-r1`)
-# must pass it explicitly so the pane title names the actual job.
-# We gate on a resolved `$caller_pane`
-# (non-empty only when tmux is reachable) rather than the now-stripped
-# `$TMUX`. See the codex wrapper for the full design rationale and the
-# silent-degrade failure model.
-if [[ -n "$caller_pane" ]]; then
-  split_args=(-h -P -F '#{pane_id}' -c "$(dirname "$log_path")" -t "$caller_pane")
-  trace_pane=$(tmux split-window "${split_args[@]}" \
-    "tail -F $(printf '%q' "$log_path")" 2>/dev/null || true)
-  if [[ -n "$trace_pane" ]]; then
-    tmux select-pane -t "$trace_pane" -T "$trace_label" 2>/dev/null || true
-    # Tag with this run's dir for `okstra-trace-cleanup.sh --run-dir`. See
-    # `okstra-codex-exec.sh` for the rationale — kept in lock-step.
-    [[ -n "$run_dir" ]] && tmux set-option -p -t "$trace_pane" @okstra_trace_run "$run_dir" 2>/dev/null || true
-    [[ -n "$status_path" ]] && tmux set-option -p -t "$trace_pane" @okstra_status "$status_path" 2>/dev/null || true
-    tmux last-pane 2>/dev/null || true
-  fi
-fi
-
-# stdout/stderr capture and pipeline mirroring are intentionally inside the
-# wrapper — this is the entire reason this script exists. agy reads the prompt
-# as the `--print` argument (it does not read stdin), so the prompt file is
-# inlined via command substitution; `--dangerously-skip-permissions` keeps the
-# non-interactive dispatch from blocking on tool-permission prompts (the worker
-# is sandboxed to the supplied `--add-dir` workspace).
-#
-# stdout: agy runs in `stream-json` so the live log records the tool calls it
-#         made — in the default `text` format agy prints only its closing
-#         summary, leaving ~2KB of self-report where codex leaves ~487KB of
-#         trace, and no way to check from outside whether the worker opened the
-#         evidence it was asked to verify. `okstra-wrapper-agy-stream.py`
-#         appends every event to the log and forwards ONLY the final response
-#         text to the wrapper's own stdout, so what the subagent's `BashOutput`
-#         captures for Phase 5 synthesis is unchanged by the format switch.
-#         agy stays a single addressable PID we can SIGTERM from the watchdog.
-# stderr: appended to the live log only — keeps the wrapper's stderr clean.
-# exit:   agy's own exit code is preserved by `wait`.
-# stdout mirror via a named FIFO instead of a `> >(tee …)` process substitution:
-# bash opens the substituted `/dev/fd/<n>` by pathname, which the macOS seatbelt
-# sandbox around a non-tmux subagent's Bash tool denies (EPERM), so agy would
-# never start. A FIFO under `.okstra/` is opened by an ordinary sandbox-writable
-# path and works in every dispatch context while keeping agy a single
-# addressable PID for the watchdog. See `okstra-codex-exec.sh` for the full note.
-stdout_fifo="${log_path}.stdout.fifo"
-rm -f "$stdout_fifo"
-mkfifo "$stdout_fifo"
-python3 "$script_dir/okstra-wrapper-agy-stream.py" "$log_path" < "$stdout_fifo" &
-stdout_tee_pid=$!
-
-# Disable git's fsmonitor for every git command agy runs in this process tree —
-# the main worktree's fsmonitor daemon leaks its IPC socket into task worktrees,
-# so git status/commit here intermittently fail with `fsmonitor_ipc__send_query`
-# errors. GIT_CONFIG_* scopes the override to this process tree without touching
-# the user's repo config. See `okstra-codex-exec.sh` for the full rationale.
-_gc_idx="${GIT_CONFIG_COUNT:-0}"
-export "GIT_CONFIG_KEY_${_gc_idx}=core.fsmonitor"
-export "GIT_CONFIG_VALUE_${_gc_idx}=false"
-export GIT_CONFIG_COUNT="$(( _gc_idx + 1 ))"
-
-agy --print "$(cat "$prompt_path")" --model "$model" "${add_dir_args[@]}" \
-  --output-format stream-json \
-  --print-timeout "$PRINT_TIMEOUT" --dangerously-skip-permissions \
-  2>> "$log_path" \
-  > "$stdout_fifo" &
-agy_pid=$!
-
-# Idle watchdog — see `okstra-codex-exec.sh` for the full rationale.
-watchdog_pid=""
-if (( idle_timeout_secs > 0 )); then
-  poll_interval=$(( idle_timeout_secs / 20 ))
-  (( poll_interval < 5 )) && poll_interval=5
-  (( poll_interval > 30 )) && poll_interval=30
-  (
-    while kill -0 "$agy_pid" 2>/dev/null; do
-      sleep "$poll_interval"
-      kill -0 "$agy_pid" 2>/dev/null || exit 0
-      # Portable mtime probe: GNU (stat -c %Y) first, macOS/BSD (stat -f %m) as
-      # the fallback, 0 as the floor. Validate each result as a bare integer
-      # before accepting it — on Linux the BSD-ism `stat -f %m` does NOT fail
-      # cleanly; it succeeds and prints non-numeric filesystem output, which
-      # would break the arithmetic below under `set -u`.
-      #
-      # `|| true` is mandatory. macOS has no GNU `stat -c`, so that call exits 1,
-      # and `2>/dev/null` suppresses stderr but not the exit code. This watchdog
-      # is an explicit `( ) &` subshell, so it inherits whatever errexit setting
-      # is in force; under `set -e` a single failed assignment kills the whole
-      # watchdog on the first poll — silently, without a log line.
-      last_mtime="$(stat -c %Y "$log_path" 2>/dev/null || true)"
-      [[ "$last_mtime" =~ ^[0-9]+$ ]] || last_mtime="$(stat -f %m "$log_path" 2>/dev/null || true)"
-      [[ "$last_mtime" =~ ^[0-9]+$ ]] || last_mtime=0
-      now=$(date +%s)
-      idle=$(( now - last_mtime ))
-      if (( idle >= idle_timeout_secs )); then
-        printf '\n[okstra wrapper] idle-watchdog: %ds without stdout — terminating agy (pid=%d)\n' \
-          "$idle" "$agy_pid" >> "$log_path" 2>&1 || true
-        python3 "$script_dir/okstra-wrapper-status.py" \
-          timeout "$status_path" "$now" "$idle" >>"$log_path" 2>&1 || true
-        kill -TERM "$agy_pid" 2>/dev/null || true
-        sleep 5
-        kill -KILL "$agy_pid" 2>/dev/null || true
-        exit 0
-      fi
-    done
-  ) &
-  watchdog_pid=$!
-fi
-
-set +e
-wait "$agy_pid"
-agy_exit=$?
-set -e
-
-if [[ -n "$watchdog_pid" ]]; then
-  kill "$watchdog_pid" 2>/dev/null || true
-  wait "$watchdog_pid" 2>/dev/null || true
-fi
-
-# Drain the stdout-mirror tee (agy's closed write end gives it EOF), then remove
-# the FIFO (the EXIT trap also clears it on an abnormal exit).
-wait "$stdout_tee_pid" 2>/dev/null || true
-rm -f "$stdout_fifo"
-
-exit "$agy_exit"
+exec python3 "$script_dir/okstra-provider-exec.py" antigravity "$@"

package/runtime/bin/okstra-claude-exec.sh

@@ -1,182 +1,5 @@
 #!/usr/bin/env bash
-# okstra-claude-exec.sh — wrapper around Claude Code non-interactive print mode.
 set -euo pipefail
 
-if [[ $# -lt 3 || $# -gt 6 ]]; then
-  printf 'usage: %s <project-root> <model-execution-value> <prompt-path> [worktree-path] [role] [idle-timeout-seconds]\n' "$(basename "$0")" >&2
-  exit 64
-fi
-
-project_root="$1"
-model="$2"
-prompt_path="$3"
-worktree_path="${4-}"
-role="${5:-worker}"
-# Implementation executor / verifier dispatches run whole build + test suites
-# that legitimately emit no stdout for many minutes; the 600s idle cap reaps
-# them mid-suite (observed: a silent jest + tsc build TERM'd at ~929s). Default
-# those roles to a longer idle cap that still sits below the 1800s wall-clock
-# polling cap so a genuine hang is reaped early. An explicit 6th arg wins.
-case "$role" in
-  executor | verifier) default_idle_timeout_secs=1500 ;;
-  *) default_idle_timeout_secs=600 ;;
-esac
-idle_timeout_secs="${6:-$default_idle_timeout_secs}"
-
-if [[ ! -d "$project_root" ]]; then
-  printf 'okstra-claude-exec.sh: project root not found: %s\n' "$project_root" >&2
-  exit 65
-fi
-if [[ -z "$model" ]]; then
-  printf 'okstra-claude-exec.sh: model is required\n' >&2
-  exit 66
-fi
-if [[ ! -f "$prompt_path" ]]; then
-  printf 'okstra-claude-exec.sh: prompt not found: %s\n' "$prompt_path" >&2
-  exit 67
-fi
-if [[ -n "$worktree_path" && ! -d "$worktree_path" ]]; then
-  printf 'okstra-claude-exec.sh: worktree not found: %s\n' "$worktree_path" >&2
-  exit 68
-fi
-if ! [[ "$idle_timeout_secs" =~ ^[0-9]+$ ]]; then
-  printf 'okstra-claude-exec.sh: idle timeout must be a non-negative integer\n' >&2
-  exit 69
-fi
-if ! command -v claude >/dev/null 2>&1; then
-  printf 'okstra-claude-exec.sh: claude CLI not found\n' >&2
-  exit 127
-fi
-
-# Grant tool access to the implementation worktree (and the main repo's shared
-# .git for linked-worktree commits) when one is supplied. The executor mutates
-# a git worktree that lives outside project-root; without --add-dir Claude
-# Code's Edit/Write tools cannot reach it. Mirrors okstra-codex-exec.sh.
-extra_args=()
-if [[ -n "$worktree_path" ]]; then
-  extra_args+=(--add-dir "$worktree_path")
-  if command -v git >/dev/null 2>&1; then
-    common_git_dir=$(git -C "$worktree_path" rev-parse --git-common-dir 2>/dev/null || true)
-    if [[ -n "$common_git_dir" ]]; then
-      [[ "$common_git_dir" != /* ]] && common_git_dir="$worktree_path/$common_git_dir"
-      if [[ -d "$common_git_dir" ]]; then
-        common_git_dir=$(cd "$common_git_dir" && pwd -P)
-        extra_args+=(--add-dir "$common_git_dir")
-      fi
-    fi
-  fi
-fi
-
-log_path="${prompt_path%.md}.log"
-[[ "$log_path" == "$prompt_path" ]] && log_path="${prompt_path}.log"
-: > "$log_path"
-# stdout/stderr mirror FIFO paths (created at the dispatch block below). Declared
-# here, before the EXIT trap is defined, so the trap's cleanup references are
-# always set under `set -u`.
-stdout_fifo=""
-stderr_fifo=""
-status_path="${prompt_path}.status.json"
-started_ts=$(date +%s)
 script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-python3 "$script_dir/okstra-wrapper-status.py" \
-  init "$status_path" "$(basename "$0")" "$role" "$$" "$started_ts" "$log_path" \
-  >>"$log_path" 2>&1 || true
-
-_okstra_status_finish() {
-  local exit_code=$?
-  local ended_ts
-  ended_ts=$(date +%s)
-  local duration_ms=$(( (ended_ts - started_ts) * 1000 ))
-  python3 "$script_dir/okstra-wrapper-status.py" \
-    finish "$status_path" "$exit_code" "$ended_ts" "$duration_ms" \
-    >>"$log_path" 2>&1 || true
-  { [[ -n "$stdout_fifo" ]] && rm -f "$stdout_fifo"; [[ -n "$stderr_fifo" ]] && rm -f "$stderr_fifo"; } 2>/dev/null || true
-}
-trap _okstra_status_finish EXIT
-
-cd "$project_root"
-set +e
-# stdout and stderr are each mirrored to the live log AND the wrapper's own
-# stdout/stderr. Process substitutions (`> >(tee …)`) do this, but bash opens the
-# substituted `/dev/fd/<n>` by pathname, and the macOS seatbelt sandbox around a
-# non-tmux subagent's Bash tool denies that open (EPERM) — claude then never
-# starts and the wrapper exits with no output. Named FIFOs under `.okstra/` are
-# opened by ordinary sandbox-writable paths, so the mirror works in every
-# dispatch context (real tmux pane OR sandboxed subagent) while keeping claude a
-# single addressable PID for the watchdog. See `okstra-codex-exec.sh` for the
-# full note.
-stdout_fifo="${log_path}.stdout.fifo"
-stderr_fifo="${log_path}.stderr.fifo"
-rm -f "$stdout_fifo" "$stderr_fifo"
-mkfifo "$stdout_fifo" "$stderr_fifo"
-tee -a "$log_path" < "$stdout_fifo" &
-stdout_tee_pid=$!
-tee -a "$log_path" < "$stderr_fifo" >&2 &
-stderr_tee_pid=$!
-
-# `--verbose` is mandatory, not cosmetic: Claude Code rejects `--print` combined
-# with `--output-format=stream-json` without it ("requires --verbose") and exits
-# 1 in under a second, so every CLI-wrapper claude worker dies before starting.
-claude -p --model "$model" ${extra_args[@]+"${extra_args[@]}"} --output-format=stream-json --verbose \
-  < "$prompt_path" \
-  > "$stdout_fifo" \
-  2> "$stderr_fifo" &
-claude_pid=$!
-
-# Idle watchdog: if the live log sees no write for $idle_timeout_secs, SIGTERM
-# claude (5s grace, then SIGKILL) and mark the status sidecar timed out, so a
-# silent hang is bounded instead of stalling the lead. Pass 0 to disable.
-watchdog_pid=""
-if (( idle_timeout_secs > 0 )); then
-  poll_interval=$(( idle_timeout_secs / 20 ))
-  (( poll_interval < 5 )) && poll_interval=5
-  (( poll_interval > 30 )) && poll_interval=30
-  (
-    while kill -0 "$claude_pid" 2>/dev/null; do
-      sleep "$poll_interval"
-      kill -0 "$claude_pid" 2>/dev/null || exit 0
-      # Portable mtime probe: GNU (stat -c %Y) first, macOS/BSD (stat -f %m) as
-      # the fallback, 0 as the floor. Validate each result as a bare integer
-      # before accepting it — on Linux the BSD-ism `stat -f %m` does NOT fail
-      # cleanly; it succeeds and prints non-numeric filesystem output, which
-      # would break the arithmetic below under `set -u`.
-      #
-      # `|| true` is mandatory. macOS has no GNU `stat -c`, so that call exits 1,
-      # and `2>/dev/null` suppresses stderr but not the exit code. This watchdog
-      # is an explicit `( ) &` subshell, so it inherits whatever errexit setting
-      # is in force; under `set -e` a single failed assignment kills the whole
-      # watchdog on the first poll — silently, without a log line.
-      last_mtime="$(stat -c %Y "$log_path" 2>/dev/null || true)"
-      [[ "$last_mtime" =~ ^[0-9]+$ ]] || last_mtime="$(stat -f %m "$log_path" 2>/dev/null || true)"
-      [[ "$last_mtime" =~ ^[0-9]+$ ]] || last_mtime=0
-      now=$(date +%s)
-      idle=$(( now - last_mtime ))
-      if (( idle >= idle_timeout_secs )); then
-        printf '\n[okstra wrapper] idle-watchdog: %ds without stdout — terminating claude (pid=%d)\n' \
-          "$idle" "$claude_pid" >> "$log_path" 2>&1 || true
-        python3 "$script_dir/okstra-wrapper-status.py" \
-          timeout "$status_path" "$now" "$idle" >>"$log_path" 2>&1 || true
-        kill -TERM "$claude_pid" 2>/dev/null || true
-        sleep 5
-        kill -KILL "$claude_pid" 2>/dev/null || true
-        exit 0
-      fi
-    done
-  ) &
-  watchdog_pid=$!
-fi
-
-wait "$claude_pid"
-claude_exit=$?
-set -e
-
-if [[ -n "$watchdog_pid" ]]; then
-  kill "$watchdog_pid" 2>/dev/null || true
-  wait "$watchdog_pid" 2>/dev/null || true
-fi
-# Drain the stdout/stderr mirror tees (claude's closed write ends give them EOF),
-# then remove the FIFOs (the EXIT trap also clears them on an abnormal exit).
-wait "$stdout_tee_pid" "$stderr_tee_pid" 2>/dev/null || true
-rm -f "$stdout_fifo" "$stderr_fifo"
-
-exit "$claude_exit"
+exec python3 "$script_dir/okstra-provider-exec.py" claude "$@"