okstra 0.86.0 → 0.87.1

package/runtime/bin/lib/okstra/globals.sh

@@ -20,7 +20,7 @@ WORKERS_OVERRIDE=""
 LEAD_MODEL_OVERRIDE=""
 CLAUDE_MODEL_OVERRIDE=""
 CODEX_MODEL_OVERRIDE=""
-GEMINI_MODEL_OVERRIDE=""
+ANTIGRAVITY_MODEL_OVERRIDE=""
 REPORT_WRITER_MODEL_OVERRIDE=""
 LEAD_RUNTIME="claude-code"
 EXECUTOR_OVERRIDE=""
@@ -82,8 +82,8 @@ CLAUDE_WORKER_PROMPT_FILE=""
 CLAUDE_WORKER_PROMPT_RELATIVE_PATH=""
 CODEX_WORKER_PROMPT_FILE=""
 CODEX_WORKER_PROMPT_RELATIVE_PATH=""
-GEMINI_WORKER_PROMPT_FILE=""
-GEMINI_WORKER_PROMPT_RELATIVE_PATH=""
+ANTIGRAVITY_WORKER_PROMPT_FILE=""
+ANTIGRAVITY_WORKER_PROMPT_RELATIVE_PATH=""
 REPORT_WRITER_WORKER_PROMPT_FILE=""
 REPORT_WRITER_WORKER_PROMPT_RELATIVE_PATH=""
 FINAL_REPORT_PATH=""
@@ -103,8 +103,8 @@ CLAUDE_WORKER_RESULT_FILE=""
 CLAUDE_WORKER_RESULT_RELATIVE_PATH=""
 CODEX_WORKER_RESULT_FILE=""
 CODEX_WORKER_RESULT_RELATIVE_PATH=""
-GEMINI_WORKER_RESULT_FILE=""
-GEMINI_WORKER_RESULT_RELATIVE_PATH=""
+ANTIGRAVITY_WORKER_RESULT_FILE=""
+ANTIGRAVITY_WORKER_RESULT_RELATIVE_PATH=""
 REPORT_WRITER_WORKER_RESULT_FILE=""
 REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH=""
 CLAUDE_SESSION_ID=""
@@ -154,15 +154,15 @@ CLAUDE_WORKER_MODEL=""
 CLAUDE_WORKER_MODEL_EXECUTION_VALUE=""
 CODEX_WORKER_MODEL=""
 CODEX_WORKER_MODEL_EXECUTION_VALUE=""
-GEMINI_WORKER_MODEL=""
-GEMINI_WORKER_MODEL_EXECUTION_VALUE=""
+ANTIGRAVITY_WORKER_MODEL=""
+ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE=""
 REPORT_WRITER_MODEL=""
 REPORT_WRITER_MODEL_EXECUTION_VALUE=""
 DEFAULT_WORKERS="claude,codex,report-writer"
 DEFAULT_LEAD_MODEL_NAME="${OKSTRA_DEFAULT_LEAD_MODEL:-opus}"
 DEFAULT_CLAUDE_WORKER_MODEL_NAME="${OKSTRA_DEFAULT_CLAUDE_MODEL:-opus}"
 DEFAULT_CODEX_WORKER_MODEL_NAME="${OKSTRA_DEFAULT_CODEX_MODEL:-gpt-5.5}"
-DEFAULT_GEMINI_WORKER_MODEL_NAME="${OKSTRA_DEFAULT_GEMINI_MODEL:-auto}"
+DEFAULT_ANTIGRAVITY_WORKER_MODEL_NAME="${OKSTRA_DEFAULT_ANTIGRAVITY_MODEL:-gemini-3.1-pro}"
 DEFAULT_REPORT_WRITER_MODEL_NAME="${OKSTRA_DEFAULT_REPORT_WRITER_MODEL:-$DEFAULT_LEAD_MODEL_NAME}"
 DISPLAY_COMMAND_NAME="${OKSTRA_COMMAND_NAME:-$(basename "$0")}"
 DISPLAY_TOOL_NAME="${OKSTRA_TOOL_NAME:-okstra}"

package/runtime/bin/lib/okstra/interactive.sh

@@ -434,7 +434,7 @@ emit("--workers", workers)
 emit("--lead-model", model(inputs.get("leadModel")))
 emit("--claude-model", model(inputs.get("claudeModel")))
 emit("--codex-model", model(inputs.get("codexModel")))
-emit("--gemini-model", model(inputs.get("geminiModel")))
+emit("--antigravity-model", model(inputs.get("antigravityModel")))
 emit("--report-writer-model", model(inputs.get("reportWriterModel")))
 directive = inputs.get("directive")
 emit("--directive", directive if isinstance(directive, str) else "")

package/runtime/bin/lib/okstra/usage.sh

@@ -3,7 +3,7 @@
 usage() {
   cat >&2 <<USAGE_EOF
 usage:
-  $DISPLAY_COMMAND_NAME [--render-only] [--yes] [--no-plan-verification] --task-type <task-type> [--workers worker1,worker2] [--lead-model <model>] [--claude-model <model>] [--codex-model <model>] [--gemini-model <model>] [--report-writer-model <model>] [--lead-runtime claude-code|codex] [--executor claude|codex|gemini] [--critic off|claude|codex|gemini] [--related-tasks taskA,taskB] --project-id <project-id> [--project-root <path>] --task-group <task-group> --task-id <task-id> --task-brief <brief-path> [--directive <directive>] [--fix-cycle <yes|no>]
+  $DISPLAY_COMMAND_NAME [--render-only] [--yes] [--no-plan-verification] --task-type <task-type> [--workers worker1,worker2] [--lead-model <model>] [--claude-model <model>] [--codex-model <model>] [--antigravity-model <model>] [--report-writer-model <model>] [--lead-runtime claude-code|codex] [--executor claude|codex|antigravity] [--critic off|claude|codex|antigravity] [--related-tasks taskA,taskB] --project-id <project-id> [--project-root <path>] --task-group <task-group> --task-id <task-id> --task-brief <brief-path> [--directive <directive>] [--fix-cycle <yes|no>]
 
 summary:
   $DISPLAY_TOOL_NAME prepares a task-keyed instruction bundle for Claude Code and launches an interactive Claude session by default.
@@ -87,23 +87,23 @@ options:
                        exclusive with --clarification-response and --approved-plan.
   --yes                Skip interactive prompting and confirmation. Requires all required arguments.
   --workers            Comma-separated worker list for this run. Default: claude,codex,report-writer
-                      (Gemini worker is optional; add \`gemini\` explicitly, e.g. --workers claude,codex,gemini,report-writer)
+                      (Antigravity worker is optional; add \`antigravity\` explicitly, e.g. --workers claude,codex,antigravity,report-writer)
   --lead-model         Model for Claude lead. Default: OKSTRA_DEFAULT_LEAD_MODEL or opus
   --claude-model       Model for Claude worker. Default: OKSTRA_DEFAULT_CLAUDE_MODEL or opus
   --codex-model        Model for Codex worker. Default: OKSTRA_DEFAULT_CODEX_MODEL or gpt-5.5
-  --gemini-model       Model for Gemini worker. Default: OKSTRA_DEFAULT_GEMINI_MODEL or auto
+  --antigravity-model       Model for Antigravity worker. Default: OKSTRA_DEFAULT_ANTIGRAVITY_MODEL or auto
   --report-writer-model
                       Model for report writer worker. Default: OKSTRA_DEFAULT_REPORT_WRITER_MODEL or lead model default
   --lead-runtime      Lead runtime adapter. Default: claude-code.
                       codex is currently render-only and records Codex adapter
                       metadata in prepared artifacts without dispatching workers.
   --executor           Provider that performs the Executor role during --task-type=implementation.
-                      One of: claude | codex | gemini. Default: OKSTRA_DEFAULT_EXECUTOR or claude.
+                      One of: claude | codex | antigravity. Default: OKSTRA_DEFAULT_EXECUTOR or claude.
                       The Executor is the only worker allowed to mutate project files; the other two
                       providers are dispatched as read-only verifiers regardless of this selection.
                       Has no effect on other task types.
   --critic             Provider for the opt-in Phase 5.6 critic pass (coverage gaps /
-                      acceptance devil's-advocate). One of: off | claude | codex | gemini.
+                      acceptance devil's-advocate). One of: off | claude | codex | antigravity.
                       Default: off.
   --related-tasks      Optional comma-separated related task identifiers. Example: auth-token-refresh,frontend-login-ui
   --work-category      Work-category classification for this task. One of:
@@ -125,8 +125,8 @@ model defaults:
   Report writer worker: OKSTRA_DEFAULT_REPORT_WRITER_MODEL or Claude lead default
   Claude worker: OKSTRA_DEFAULT_CLAUDE_MODEL or opus
   Codex worker: OKSTRA_DEFAULT_CODEX_MODEL or gpt-5.5
-  Gemini worker: OKSTRA_DEFAULT_GEMINI_MODEL or auto
-  Implementation executor: OKSTRA_DEFAULT_EXECUTOR or claude (one of: claude | codex | gemini)
+  Antigravity worker: OKSTRA_DEFAULT_ANTIGRAVITY_MODEL or auto
+  Implementation executor: OKSTRA_DEFAULT_EXECUTOR or claude (one of: claude | codex | antigravity)
 
 output:
   Stable task bundles are stored under:

package/runtime/bin/lib/okstra-ctl/cmd-reconcile.sh

@@ -18,10 +18,12 @@ _okstra_ctl_reconcile() {
 import os, sys
 sys.path.insert(0, os.environ["OKSTRA_CTL_LIB_DIR"])
 from pathlib import Path
-from okstra_ctl import reconcile_active
+from okstra_ctl import reconcile_active, reconcile_recent
 target = os.environ["OK_PROJECT"]
-reconcile_active(Path(os.environ["OKSTRA_HOME_RESOLVED"]),
-                 project=None if target == "all" else target)
+home = Path(os.environ["OKSTRA_HOME_RESOLVED"])
+scope = None if target == "all" else target
+reconcile_active(home, project=scope)
+reconcile_recent(home, project=scope)
 PY
   printf 'reconcile complete\n'
 }

package/runtime/bin/lib/okstra-ctl/prepare.sh

@@ -23,7 +23,9 @@ sys.exit(0 if data.get("backfilledAt") else 1)
 import os, sys
 sys.path.insert(0, os.environ["OKSTRA_CTL_LIB_DIR"])
 from pathlib import Path
-from okstra_ctl import reconcile_active
-reconcile_active(Path(os.environ["OKSTRA_HOME_RESOLVED"]))
+from okstra_ctl import reconcile_active, reconcile_recent
+home = Path(os.environ["OKSTRA_HOME_RESOLVED"])
+reconcile_active(home)
+reconcile_recent(home)
 PY
 }

package/runtime/bin/{okstra-gemini-exec.sh → okstra-antigravity-exec.sh}

@@ -1,25 +1,25 @@
 #!/usr/bin/env bash
-# okstra-gemini-exec.sh — wrapper around `gemini -p -` for okstra gemini-worker
+# 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 (stdin/stderr redirects, pipes).
-# `gemini -p - -m <model> -o text --include-directories <root> < <prompt-path> 2>/dev/null`
-# therefore triggers a permission prompt every dispatch even when `Bash(gemini:*)`
+# commands that contain shell metacharacters (stdout/stderr redirects, pipes).
+# `agy --print "<prompt>" --model <model> --add-dir <root> 2>>log > >(tee)`
+# 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-gemini-exec.sh:*)
+#   Bash($HOME/.okstra/bin/okstra-antigravity-exec.sh:*)
 #
 # Usage:
-#   okstra-gemini-exec.sh <project-root> <model-execution-value> <prompt-path> [worktree-path] [role] [idle-timeout-seconds]
+#   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 600 = 10 minutes). When > 0, an
 # in-process watchdog polls the live-log mtime; if no stdout/stderr write
-# occurs for that many seconds, the underlying `gemini` is SIGTERM'd (then
+# 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
@@ -28,23 +28,28 @@
 #
 # 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 appended to gemini's
-# `--include-directories` list (comma-separated) so the model can see and
-# operate on the worktree alongside the primary workspace. When omitted or
-# empty, only project-root is included (existing analysis-phase behavior).
+# 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 appends it to `--include-directories`. If
-# resolution fails (not a linked worktree, or git unavailable), the extra
-# include is silently omitted.
+# 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
@@ -58,38 +63,40 @@ role="${5:-worker}"
 idle_timeout_secs="${6:-600}"
 
 if ! [[ "$idle_timeout_secs" =~ ^[0-9]+$ ]]; then
-  printf 'okstra-gemini-exec: idle-timeout-seconds must be a non-negative integer: %q\n' "$idle_timeout_secs" >&2
+  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-gemini-exec: project-root is missing or not a directory: %q\n' "$project_root" >&2
+  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-gemini-exec: model-execution-value is empty\n' >&2
+  printf 'okstra-antigravity-exec: model-execution-value is empty\n' >&2
   exit 66
 fi
 
 if [[ -z "$prompt_path" || ! -f "$prompt_path" ]]; then
-  printf 'okstra-gemini-exec: prompt-path is missing or not a file: %q\n' "$prompt_path" >&2
+  printf 'okstra-antigravity-exec: prompt-path is missing or not a file: %q\n' "$prompt_path" >&2
   exit 67
 fi
 
-if ! command -v gemini >/dev/null 2>&1; then
-  printf 'okstra-gemini-exec: gemini CLI is not installed on PATH\n' >&2
+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-gemini-exec: worktree-path was provided but is not a directory: %q\n' "$worktree_path" >&2
+  printf 'okstra-antigravity-exec: worktree-path was provided but is not a directory: %q\n' "$worktree_path" >&2
   exit 68
 fi
 
-include_dirs="$project_root"
+# 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
-  include_dirs="$project_root,$worktree_path"
+  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
@@ -104,26 +111,26 @@ if [[ -n "$worktree_path" ]]; then
       fi
       if [[ -d "$common_git_dir" ]]; then
         common_git_dir=$(cd "$common_git_dir" && pwd -P)
-        include_dirs="$include_dirs,$common_git_dir"
+        add_dir_args+=(--add-dir "$common_git_dir")
       fi
     fi
   fi
 fi
 
-# Derive a live-progress log path next to the prompt. The gemini CLI streams
-# its progress over stdout/stderr, but the caller (gemini-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.
+# 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"
 
 # Heartbeat sidecar (`<prompt>.status.json`). See `okstra-codex-exec.sh` for
 # the full design comment — kept in lock-step. Two consumers:
-#   1. `gemini-worker` step 8c reads `log_path` to capture a diagnostic
+#   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`.
@@ -153,12 +160,12 @@ 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 `gemini-<role>`; the sibling trace
+# 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 `gemini-` prefix (e.g. `worker-reverify-r1`, `executor`), so the
-# pane title equals the FleetView teammate name instead of a generic `worker`.
-pane_label="gemini-${role}"
+# 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
@@ -191,9 +198,9 @@ 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 gemini dispatches are not
-# implementation-specific. Title `gemini-<role>-tail` so the operator
-# can pair it with its caller pane (`gemini-<role>`). The split is
+# 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`)
@@ -215,25 +222,25 @@ if [[ -n "$caller_pane" ]]; then
   fi
 fi
 
-# stdin redirect, stderr capture, and pipeline mirroring are intentionally
-# inside the wrapper — this is the entire reason this script exists. Gemini
-# CLI has no `--cd` flag, so workspace correctness is anchored via
-# `--include-directories` plus the Project Root referenced in the prompt
-# body itself.
+# 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: tee'd to both the live log (for `tail -f`) AND the wrapper's own
 #         stdout (so the subagent's `BashOutput` still captures the final
 #         text verbatim for Phase 5 synthesis). Implemented via process
-#         substitution so gemini itself stays a single addressable PID we
+#         substitution so agy itself stays a single addressable PID we
 #         can SIGTERM from the watchdog.
-# stderr: appended to the live log only — mirrors the prior `2>/dev/null`
-#         contract of keeping the wrapper's stderr stream clean.
-# exit:   gemini's own exit code is preserved by `wait`.
-gemini -p - -m "$model" -o text --include-directories "$include_dirs" \
-  < "$prompt_path" \
+# stderr: appended to the live log only — keeps the wrapper's stderr clean.
+# exit:   agy's own exit code is preserved by `wait`.
+agy --print "$(cat "$prompt_path")" --model "$model" "${add_dir_args[@]}" \
+  --print-timeout "$PRINT_TIMEOUT" --dangerously-skip-permissions \
   2>> "$log_path" \
   > >(tee -a "$log_path") &
-gemini_pid=$!
+agy_pid=$!
 
 # Idle watchdog — see `okstra-codex-exec.sh` for the full rationale.
 watchdog_pid=""
@@ -242,20 +249,20 @@ if (( idle_timeout_secs > 0 )); then
   (( poll_interval < 5 )) && poll_interval=5
   (( poll_interval > 30 )) && poll_interval=30
   (
-    while kill -0 "$gemini_pid" 2>/dev/null; do
+    while kill -0 "$agy_pid" 2>/dev/null; do
       sleep "$poll_interval"
-      kill -0 "$gemini_pid" 2>/dev/null || exit 0
+      kill -0 "$agy_pid" 2>/dev/null || exit 0
       last_mtime=$(stat -f %m "$log_path" 2>/dev/null || stat -c %Y "$log_path" 2>/dev/null || printf '0')
       now=$(date +%s)
       idle=$(( now - last_mtime ))
       if (( idle >= idle_timeout_secs )); then
-        printf '\n[okstra wrapper] idle-watchdog: %ds without stdout — terminating gemini (pid=%d)\n' \
-          "$idle" "$gemini_pid" >> "$log_path" 2>&1 || true
+        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 "$gemini_pid" 2>/dev/null || true
+        kill -TERM "$agy_pid" 2>/dev/null || true
         sleep 5
-        kill -KILL "$gemini_pid" 2>/dev/null || true
+        kill -KILL "$agy_pid" 2>/dev/null || true
         exit 0
       fi
     done
@@ -264,8 +271,8 @@ if (( idle_timeout_secs > 0 )); then
 fi
 
 set +e
-wait "$gemini_pid"
-gemini_exit=$?
+wait "$agy_pid"
+agy_exit=$?
 set -e
 
 if [[ -n "$watchdog_pid" ]]; then
@@ -275,4 +282,4 @@ fi
 
 wait 2>/dev/null || true
 
-exit "$gemini_exit"
+exit "$agy_exit"

package/runtime/bin/okstra-error-log.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 """OKSTRA error log helper.
 
 Single writer for runs/<task-type>/logs/errors-<task-type>-<seq>.jsonl.
@@ -17,7 +18,7 @@ PIPE_BUF_BYTES = 4096
 ALLOWED_ERROR_TYPES = {"tool-failure", "cli-failure", "contract-violation"}
 ALLOWED_AGENTS = {
     "claude-lead", "claude-worker", "codex-worker",
-    "gemini-worker", "report-writer",
+    "antigravity-worker", "report-writer",
 }
 ALLOWED_AGENT_ROLES = {"lead", "worker", "report-writer"}
 SUPPORTED_SIDECAR_SCHEMA_VERSIONS = {1}

package/runtime/bin/okstra-token-usage.py

@@ -21,7 +21,6 @@ from okstra_token_usage import (  # noqa: E402,F401
     CODEX_PRICING,
     CODEX_SESSIONS,
     GEMINI_PRICING,
-    GEMINI_TMP,
     claude_billable_equivalent,
     claude_cost_usd,
     claude_project_dir,
@@ -31,9 +30,9 @@ from okstra_token_usage import (  # noqa: E402,F401
     collect,
     find_claude_team_sessions,
     find_codex_session,
-    find_gemini_session,
-    gemini_cost_usd,
-    gemini_session_total,
+    find_antigravity_session,
+    antigravity_session_total,
+    antigravity_cost_usd,
     iter_jsonl,
     na_block,
     populate_and_render,

package/runtime/bin/okstra-trace-cleanup.sh

@@ -2,8 +2,8 @@
 #
 # okstra-trace-cleanup.sh — close tmux panes created during okstra runs.
 #
-# Trace panes are `tail -F` siblings spawned by the codex/gemini wrappers
-# (`okstra-codex-exec.sh`, `okstra-gemini-exec.sh`). Worker-compute panes are
+# Trace panes are `tail -F` siblings spawned by the codex/antigravity wrappers
+# (`okstra-codex-exec.sh`, `okstra-antigravity-exec.sh`). Worker-compute panes are
 # tmux-pane backend siblings. Each wrapper/dispatcher tags the pane it owns with
 # a pane-level user option (`@okstra_trace_run=<RUN_DIR>` or
 # `@okstra_worker_run=<RUN_DIR>`), so panes are found server-wide by tag — no
@@ -16,7 +16,7 @@
 #                         (a) trace panes tagged with this run's dir and
 #                         (b) worker-agent panes the harness gives to dispatched
 #                         subagents (`claude-worker` / `codex-worker` /
-#                         `gemini-worker` / `report-writer-worker`), identified
+#                         `antigravity-worker` / `report-writer-worker`), identified
 #                         by a title allowlist scoped to the LEAD's session. The
 #                         lead pane is read from `<RUN_DIR>/state/lead-pane.id`
 #                         (recorded once by the lead in its own foreground pane —
@@ -139,7 +139,7 @@ collect_okstra_panes() {
       [[ -n "$pid" ]] || continue
       [[ "$pid" == "$lead_pane" ]] && continue
       case "$title" in
-        *claude-worker*|*codex-worker*|*gemini-worker*|*report-writer-worker*)
+        *claude-worker*|*codex-worker*|*antigravity-worker*|*report-writer-worker*)
           panes+=("$pid") ;;
       esac
     done < <(tmux list-panes -s -t "$lead_pane" \

package/runtime/bin/okstra-wrapper-status.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
-"""okstra-wrapper-status.py — heartbeat sidecar writer for codex/gemini wrappers.
+"""okstra-wrapper-status.py — heartbeat sidecar writer for codex/antigravity wrappers.
 
-The codex/gemini wrappers (`okstra-codex-exec.sh`, `okstra-gemini-exec.sh`)
+The codex/antigravity wrappers (`okstra-codex-exec.sh`, `okstra-antigravity-exec.sh`)
 dispatch a long-running CLI under `Bash(run_in_background: true)` and rely on
 `BashOutput` polling for liveness. That polling stream only carries stdout
 plus a binary `running`/`completed` state. Several recovery decisions need
@@ -11,7 +11,7 @@ finish?" — so the wrappers write a small JSON sidecar at
 
 Consumers:
 
-* `codex-worker` / `gemini-worker` step 8c: read `log_path` to capture a
+* `codex-worker` / `antigravity-worker` step 8c: read `log_path` to capture a
   diagnostic tail when `exit_code == 0` but the canonical Result file is
   absent.
 * Lead: cross-check `started_ts` / `ended_ts` to distinguish "wrapper hung

package/runtime/bin/okstra.sh

@@ -113,7 +113,7 @@ PY_ARGS=(
 [[ -n "${LEAD_MODEL_OVERRIDE-}" ]] && PY_ARGS+=(--lead-model "$LEAD_MODEL_OVERRIDE")
 [[ -n "${CLAUDE_MODEL_OVERRIDE-}" ]] && PY_ARGS+=(--claude-model "$CLAUDE_MODEL_OVERRIDE")
 [[ -n "${CODEX_MODEL_OVERRIDE-}" ]] && PY_ARGS+=(--codex-model "$CODEX_MODEL_OVERRIDE")
-[[ -n "${GEMINI_MODEL_OVERRIDE-}" ]] && PY_ARGS+=(--gemini-model "$GEMINI_MODEL_OVERRIDE")
+[[ -n "${ANTIGRAVITY_MODEL_OVERRIDE-}" ]] && PY_ARGS+=(--antigravity-model "$ANTIGRAVITY_MODEL_OVERRIDE")
 [[ -n "${REPORT_WRITER_MODEL_OVERRIDE-}" ]] && PY_ARGS+=(--report-writer-model "$REPORT_WRITER_MODEL_OVERRIDE")
 [[ -n "${LEAD_RUNTIME-}" ]] && PY_ARGS+=(--lead-runtime "$LEAD_RUNTIME")
 [[ -n "${EXECUTOR_OVERRIDE-}" ]] && PY_ARGS+=(--executor "$EXECUTOR_OVERRIDE")

package/runtime/prompts/launch.template.md

@@ -55,7 +55,7 @@ Emit one `PROGRESS: <phase-id> <verb-phrase>` line as plain user-facing text at
 - Worker error sidecars (absolute):
   - Claude worker: `{{CLAUDE_WORKER_ERRORS_SIDECAR_PATH}}`
   - Codex worker: `{{CODEX_WORKER_ERRORS_SIDECAR_PATH}}`
-  - Gemini worker: `{{GEMINI_WORKER_ERRORS_SIDECAR_PATH}}`
+  - Antigravity worker: `{{ANTIGRAVITY_WORKER_ERRORS_SIDECAR_PATH}}`
   - Report writer worker: `{{REPORT_WRITER_WORKER_ERRORS_SIDECAR_PATH}}`
 - When dispatching any worker you MUST inject **two header lines** into the dispatch prompt body so the worker subagent can record errors without guessing paths:
   - `**Errors log path:** <absolute run-level errors log path>`
@@ -79,8 +79,8 @@ Emit one `PROGRESS: <phase-id> <verb-phrase>` line as plain user-facing text at
 
 {{AVAILABLE_MCP_SERVERS}}
 - The full usage policy and per-phase rules live in the analysis packet's `Available MCP Servers` extract. Inject only the one-line pointer below into each analysis-worker prompt: `**MCP servers:** follow the analysis packet's "Available MCP Servers" section (already in your Required reading).`
-- **Invocation rule (forward to every worker prompt)**: MCP tools are addressed by their tool name through the host's tool interface — **never via `Bash`**. Claude-side workers call the tool directly (e.g. `mcp__<server>__<tool>`). Codex/Gemini workers call through their CLI's own MCP transport (e.g. `codex mcp call ...`). Running the tool name as a shell command is a contract violation and will always fail regardless of permission grants.
-- Codex worker and Gemini worker run external CLIs; they can only use these MCP servers if their own CLI configs mirror them. If not, instruct the worker to record `MCP not available in this CLI` in its `Missing Information or Assumptions` block rather than guessing or shell-falling-back.
+- **Invocation rule (forward to every worker prompt)**: MCP tools are addressed by their tool name through the host's tool interface — **never via `Bash`**. Claude-side workers call the tool directly (e.g. `mcp__<server>__<tool>`). Codex/Antigravity workers call through their CLI's own MCP transport (e.g. `codex mcp call ...`). Running the tool name as a shell command is a contract violation and will always fail regardless of permission grants.
+- Codex worker and Antigravity worker run external CLIs; they can only use these MCP servers if their own CLI configs mirror them. If not, instruct the worker to record `MCP not available in this CLI` in its `Missing Information or Assumptions` block rather than guessing or shell-falling-back.
 - MCP queries are evidence-grade. Cite server, table, and the SELECT used in worker output. MCP must NOT be used as a write path in any phase, including `implementation`.
 
 ## Clarification Response Carried In

package/runtime/prompts/lead/context-loader.md

@@ -89,7 +89,7 @@ After identifying the task root in `task-manifest.json`, derive all paths accord
 │       └── worker-results/
 │           ├── claude-worker-<task-type>-<seq>.md
 │           ├── codex-worker-<task-type>-<seq>.md
-│           ├── gemini-worker-<task-type>-<seq>.md
+│           ├── antigravity-worker-<task-type>-<seq>.md
 │           └── report-writer-worker-<task-type>-<seq>.md
 └── history/
     └── timeline.json

package/runtime/prompts/lead/convergence.md

@@ -163,7 +163,7 @@ A reverify dispatch that returns a **terminal non-result** (`timeout`, `error`,
 Rules:
 
 1. For each affected finding, append a `votes[W].verdict = "verification-error"` entry instead of `disagree`, plus the wrapper's captured exit reason in `votes[W].explanation`.
-2. Record one event per failed dispatch via `okstra error-log append-observed --error-type cli-failure --agent <worker> ...` (the worker wrapper does this for Codex/Gemini; for Claude worker timeouts the lead does it).
+2. Record one event per failed dispatch via `okstra error-log append-observed --error-type cli-failure --agent <worker> ...` (the worker wrapper does this for Codex/Antigravity; for Claude worker timeouts the lead does it).
 3. Add an entry to the round's `skippedWorkers[]` with `{worker: <W>, reason: "dispatch-non-result", terminalStatus: <timeout|error|not-run>}`.
 4. If at least one dispatch was issued AND all reverify dispatches in a round terminate as non-result (mirroring the pseudocode's `len(dispatches) > 0` guard), the round is treated as gate-closed: write `round2SkippedReason: "all-reverify-non-result"` (even if the round in question is round 1 — i.e. round 2 never runs because round 1 produced no usable votes), record one `contract-violation` event per non-result dispatch, and exit the WHILE loop.
 5. Section 6 (Specialization Lens) of a worker output is OUT of convergence scope per "Convergence scope" above — its absence is NEVER a `verification-error`.
@@ -266,7 +266,7 @@ Agent(
 
 - Agent Teams mode: Spawn within an existing team
 - Fallback mode: Spawn with `run_in_background: true` and no `team_name`
-- CLI (Codex / Gemini) worker: inject `**Pane role:** worker-reverify-r<N>` (the Agent `name` minus the `<cli>-` prefix) into the reverify prompt body so the tmux trace pane reads `<cli>-worker-reverify-r<N>` per [okstra-lead-contract](./okstra-lead-contract.md) "Agent `name` on dispatch".
+- CLI (Codex / Antigravity) worker: inject `**Pane role:** worker-reverify-r<N>` (the Agent `name` minus the `<cli>-` prefix) into the reverify prompt body so the tmux trace pane reads `<cli>-worker-reverify-r<N>` per [okstra-lead-contract](./okstra-lead-contract.md) "Agent `name` on dispatch".
 
 For `tmux-pane` backend runs, do not use the Agent snippet. For each reverify round, write a jobs file at `runs/<task-type>/state/reverify-jobs-r<N>-<task-type>-<seq>.json` with `dispatchKind: "reverify-r<N>"` and worker entries containing `workerId`, `provider`, `role` (set to `worker-reverify-r<N>` for the pane title), `modelExecutionValue`, `promptPath`, `resultPath`, `workerResultPath`, and `completionPaths`; then run `okstra team dispatch --project-root <dir> --run-manifest <path> --dispatch-kind reverify-r<N> --jobs-file <jobs-file>` followed by `okstra team await --project-root <dir> --run-manifest <path>`.
 
@@ -293,7 +293,7 @@ Assigned worker prompt history path: <Project Root>/<Prompt History Path>
 
 If none of the three is available, **abort the reverify dispatch for that role** and record a `contract-violation` event via `okstra error-log append-observed`. Do NOT guess, do NOT fall back to training-data defaults — for codex this would silently produce `o4-mini` instead of the assigned `gpt-5.5`-class model, which is a real bug class observed in production.
 
-For Codex/Gemini wrapper subagents, the `**Model:** <role>, <modelExecutionValue>` line is what their wrapper extracts to pass into the underlying CLI's `--model` flag. Omitting it forces the wrapper to fall back to its own training-data knowledge of the CLI's historical default.
+For Codex/Antigravity wrapper subagents, the `**Model:** <role>, <modelExecutionValue>` line is what their wrapper extracts to pass into the underlying CLI's `--model` flag. Omitting it forces the wrapper to fall back to its own training-data knowledge of the CLI's historical default.
 
 ### Reverify prompt: required-reading suppression (BLOCKING)
 
@@ -456,11 +456,11 @@ Save it to `runs/<task-type>/state/convergence-<task-type>-<seq>.json`.
           "round": 1,
           "votes": {
             "codex-worker": { "verdict": "agree", "disagreeBasis": null, "explanation": "<brief>" },
-            "gemini-worker": { "verdict": "supplement", "explanation": "<brief>" }
+            "antigravity-worker": { "verdict": "supplement", "explanation": "<brief>" }
           }
         }
       ],
-      "consensusWorkers": ["claude-worker", "codex-worker", "gemini-worker"],
+      "consensusWorkers": ["claude-worker", "codex-worker", "antigravity-worker"],
       "dissentingWorkers": []
     }
   ],
@@ -472,7 +472,7 @@ Save it to `runs/<task-type>/state/convergence-<task-type>-<seq>.json`.
       "carriedForwardCount": 0,
       "dispatches": [
         { "worker": "codex-worker",  "status": "completed", "durationMs": 184221 },
-        { "worker": "gemini-worker", "status": "completed", "durationMs": 201337 }
+        { "worker": "antigravity-worker", "status": "completed", "durationMs": 201337 }
       ],
       "skippedWorkers": [
         { "worker": "claude-worker", "reason": "no items to verify" }
@@ -524,7 +524,7 @@ The critic input is the Round 0 consolidated finding list. Reverify rounds only
 - **Gap verification + merge**: only after BOTH the finding-convergence loop has exited AND the critic result is collected, and BEFORE the Phase 6 report-writer dispatch. If the loop exited `aborted-non-result`, do NOT dispatch a gap-verification round — surface the gaps as unverified `clarification` items per §"Gap verification" and record that fact.
 
 ### Dispatch (reused worker)
-Dispatch ONE pass to the `config.critic.provider`'s existing subagent (`claude-worker` / `codex-worker` / `gemini-worker`) with `model = config.critic.modelExecutionValue` — no new agent type, `name: "<provider>-worker-critic"`. If `config.critic.modelExecutionValue` is null/empty (model could not be resolved), skip the critic pass and record `critic-skipped: model-unresolved` in the convergence state rather than dispatching with no model. For a CLI (Codex / Gemini) critic dispatch, inject `**Pane role:** worker-critic` into the prompt body so the trace pane reads `<cli>-worker-critic` per [okstra-lead-contract](./okstra-lead-contract.md) "Agent `name` on dispatch". Result path: `runs/<task-type>/worker-results/<provider>-critic-<task-type>-<seq>.md`. The critic prompt seeds the consolidated findings and asks ONLY for coverage gaps:
+Dispatch ONE pass to the `config.critic.provider`'s existing subagent (`claude-worker` / `codex-worker` / `antigravity-worker`) with `model = config.critic.modelExecutionValue` — no new agent type, `name: "<provider>-worker-critic"`. If `config.critic.modelExecutionValue` is null/empty (model could not be resolved), skip the critic pass and record `critic-skipped: model-unresolved` in the convergence state rather than dispatching with no model. For a CLI (Codex / Antigravity) critic dispatch, inject `**Pane role:** worker-critic` into the prompt body so the trace pane reads `<cli>-worker-critic` per [okstra-lead-contract](./okstra-lead-contract.md) "Agent `name` on dispatch". Result path: `runs/<task-type>/worker-results/<provider>-critic-<task-type>-<seq>.md`. The critic prompt seeds the consolidated findings and asks ONLY for coverage gaps:
 
 ```
 You are the coverage critic for <task-key>. Below are the consolidated findings
@@ -685,7 +685,7 @@ Plan-body verification stays **lightweight** even under this posture — the `ve
 ### Round protocol (single round at default `maxRounds=1`)
 
 1. Lead parses the report-writer draft and extracts the `P-*` plan items.
-2. For each analyser worker in the roster (`claude`, `codex`, and `gemini` if opted in), lead constructs a reverify prompt using the template in §"Plan-body reverify prompt" below.
+2. For each analyser worker in the roster (`claude`, `codex`, and `antigravity` if opted in), lead constructs a reverify prompt using the template in §"Plan-body reverify prompt" below.
 3. Dispatch uses the same wrapper infrastructure as finding convergence. The `--role-slug` is `<role>-plan-verify-r<N>`. Result file path: `runs/<task-type>/worker-results/<role-slug>-plan-verify-r<N>-implementation-planning-<seq>.md`.
 4. After all dispatches return, lead aggregates verdicts per `P-*` item across workers and classifies each:
    - `full-consensus` — all participating analysers `AGREE` (SUPPLEMENT counts as agree on the item itself).