okstra 0.86.0 → 0.87.1

package/runtime/python/okstra_ctl/run.py

@@ -294,7 +294,7 @@ class PrepareInputs:
     lead_model: str = ""
     claude_model: str = ""
     codex_model: str = ""
-    gemini_model: str = ""
+    antigravity_model: str = ""
     report_writer_model: str = ""
     lead_runtime: str = "claude-code"
     lead_runtime_request: str = ""
@@ -989,7 +989,7 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
         ("--lead-model", inp.lead_model or ctx.get("LEAD_MODEL", "")),
         ("--claude-model", inp.claude_model or ctx.get("CLAUDE_WORKER_MODEL", "")),
         ("--codex-model", inp.codex_model or ctx.get("CODEX_WORKER_MODEL", "")),
-        ("--gemini-model", inp.gemini_model or ctx.get("GEMINI_WORKER_MODEL", "")),
+        ("--antigravity-model", inp.antigravity_model or ctx.get("ANTIGRAVITY_WORKER_MODEL", "")),
         ("--report-writer-model", inp.report_writer_model or ctx.get("REPORT_WRITER_MODEL", "")),
         ("--lead-runtime", inp.lead_runtime if inp.lead_runtime != "claude-code" else ""),
         ("--executor", inp.executor or ctx.get("EXECUTOR_PROVIDER", "")),
@@ -1441,11 +1441,11 @@ class _ModelBindings:
 
 
 def _resolve_worker_models(inp: PrepareInputs) -> dict:
-    """lead/claude/codex/gemini/report-writer 모델을 alias → (display, execution) 로 해소."""
+    """lead/claude/codex/antigravity/report-writer 모델을 alias → (display, execution) 로 해소."""
     lead_default = _default("OKSTRA_DEFAULT_LEAD_MODEL", "opus")
     claude_default = _default("OKSTRA_DEFAULT_CLAUDE_MODEL", "opus")
     codex_default = _default("OKSTRA_DEFAULT_CODEX_MODEL", "gpt-5.5")
-    gemini_default = _default("OKSTRA_DEFAULT_GEMINI_MODEL", "auto")
+    antigravity_default = _default("OKSTRA_DEFAULT_ANTIGRAVITY_MODEL", "auto")
     report_writer_default = _default("OKSTRA_DEFAULT_REPORT_WRITER_MODEL", lead_default)
     return {
         "lead": resolve_model_metadata(
@@ -1461,8 +1461,8 @@ def _resolve_worker_models(inp: PrepareInputs) -> dict:
             default_display=codex_default, default_execution=codex_default,
         ),
         "ge": resolve_model_metadata(
-            provider="gemini", raw_value=inp.gemini_model,
-            default_display=gemini_default, default_execution=gemini_default,
+            provider="antigravity", raw_value=inp.antigravity_model,
+            default_display=antigravity_default, default_execution=antigravity_default,
         ),
         "rw": resolve_model_metadata(
             provider="claude", raw_value=inp.report_writer_model,
@@ -1475,15 +1475,15 @@ def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBin
     """worker 모델 + critic 선택 + executor 바인딩을 한 묶음으로 해소·검증한다."""
     m = _resolve_worker_models(inp)
     critic_choice = (inp.critic or "").strip().lower()
-    if critic_choice not in ("", "off", "claude", "codex", "gemini"):
+    if critic_choice not in ("", "off", "claude", "codex", "antigravity"):
         raise PrepareError(
-            f"--critic must be one of: off, claude, codex, gemini (got: {critic_choice!r})"
+            f"--critic must be one of: off, claude, codex, antigravity (got: {critic_choice!r})"
         )
     executor_default = _default("OKSTRA_DEFAULT_EXECUTOR", "claude")
     executor_provider = (inp.executor or executor_default).strip().lower()
-    if executor_provider not in ("claude", "codex", "gemini"):
+    if executor_provider not in ("claude", "codex", "antigravity"):
         raise PrepareError(
-            f"--executor must be one of: claude, codex, gemini (got: {executor_provider!r})"
+            f"--executor must be one of: claude, codex, antigravity (got: {executor_provider!r})"
         )
     if inp.task_type == "implementation" and executor_provider not in workers:
         raise PrepareError(
@@ -1494,7 +1494,7 @@ def _resolve_model_bindings(inp: PrepareInputs, workers: list[str]) -> _ModelBin
     provider_to_meta = {
         "claude": ("Claude executor", "claude-worker", m["cw"]),
         "codex": ("Codex executor", "codex-worker", m["co"]),
-        "gemini": ("Gemini executor", "gemini-worker", m["ge"]),
+        "antigravity": ("Antigravity executor", "antigravity-worker", m["ge"]),
     }
     display_name, worker_agent, model_meta = provider_to_meta[executor_provider]
     return _ModelBindings(
@@ -1916,7 +1916,7 @@ def _persist_run_inputs(
             "leadModel": models.lead.display,
             "claudeModel": models.cw.display,
             "codexModel": models.co.display,
-            "geminiModel": models.ge.display,
+            "antigravityModel": models.ge.display,
             "reportWriterModel": models.rw.display,
             "executor": models.executor_provider,
             "relatedTasks": inp.related_tasks_raw,
@@ -2273,8 +2273,8 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         "CLAUDE_WORKER_MODEL_EXECUTION_VALUE": cw.execution,
         "CODEX_WORKER_MODEL": co.display,
         "CODEX_WORKER_MODEL_EXECUTION_VALUE": co.execution,
-        "GEMINI_WORKER_MODEL": ge.display,
-        "GEMINI_WORKER_MODEL_EXECUTION_VALUE": ge.execution,
+        "ANTIGRAVITY_WORKER_MODEL": ge.display,
+        "ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE": ge.execution,
         "REPORT_WRITER_MODEL": rw.display,
         "REPORT_WRITER_MODEL_EXECUTION_VALUE": rw.execution,
         "EXECUTOR_PROVIDER": executor_provider,
@@ -2423,7 +2423,7 @@ def main(argv: list[str]) -> int:
     p.add_argument("--lead-model", default="")
     p.add_argument("--claude-model", default="")
     p.add_argument("--codex-model", default="")
-    p.add_argument("--gemini-model", default="")
+    p.add_argument("--antigravity-model", default="")
     p.add_argument("--report-writer-model", default="")
     p.add_argument(
         "--lead-runtime",
@@ -2582,7 +2582,7 @@ def main(argv: list[str]) -> int:
         lead_model=args.lead_model,
         claude_model=args.claude_model,
         codex_model=args.codex_model,
-        gemini_model=args.gemini_model,
+        antigravity_model=args.antigravity_model,
         report_writer_model=args.report_writer_model,
         lead_runtime=args.lead_runtime,
         lead_runtime_request=args.lead_runtime_request,

package/runtime/python/okstra_ctl/run_context.py

@@ -205,7 +205,7 @@ def write_run_inputs(
 
     inputs schema (모든 키 optional):
       taskBriefPath, directive, workers, leadModel, claudeModel, codexModel,
-      geminiModel, reportWriterModel, relatedTasks, approvedPlanPath,
+      antigravityModel, reportWriterModel, relatedTasks, approvedPlanPath,
       clarificationResponsePath, renderOnly
     """
     run_manifests_dir = Path(run_manifests_dir)

package/runtime/python/okstra_ctl/seeding.py

@@ -135,7 +135,7 @@ def ensure_project_settings_symlink(*, project_root: Path) -> Optional[Path]:
 
     Claude Code 가 그 프로젝트에서 host 세션으로 실행될 때 이 파일을
     자동으로 로드하므로, okstra worker wrapper 호출(`okstra-codex-exec.sh`,
-    `okstra-gemini-exec.sh`) 이 별도 `--settings` 인자 없이도 허용된다.
+    `okstra-antigravity-exec.sh`) 이 별도 `--settings` 인자 없이도 허용된다.
 
     반환값:
       - target Path: symlink 가 새로 생성되었거나 이미 올바른 위치를

package/runtime/python/okstra_ctl/task_target.py

@@ -0,0 +1,44 @@
+"""task-key → (task_root, project_root) 해석 공유 헬퍼.
+
+read-side CLI(context-cost, error-report)가 동일한 입력 계약을 공유하기 위한
+SSOT. target 은 task-root 경로 / task-key 둘 다 받는다.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from okstra_project import ResolverError, find_task_root, resolve_project_root
+
+
+def resolve_task_root(target: str, project_root: str, cwd: str) -> tuple[Path, Path]:
+    target_path = Path(target).expanduser()
+    if target_path.exists():
+        task_root = target_path.resolve()
+        return task_root, infer_project_root(task_root)
+
+    try:
+        resolved_project = Path(
+            resolve_project_root(explicit_root=project_root, cwd=cwd)
+        ).resolve()
+    except ResolverError as exc:
+        raise SystemExit(f"project root resolution failed: {exc}") from exc
+
+    task_root = find_task_root(resolved_project, target)
+    if task_root is None:
+        raise SystemExit(f"no task root for task key: {target}")
+    return task_root.resolve(), resolved_project
+
+
+def infer_project_root(task_root: Path) -> Path:
+    parts = task_root.parts
+    if ".okstra" not in parts:
+        return task_root
+    idx = parts.index(".okstra")
+    return Path(*parts[:idx]).resolve()
+
+
+def project_rel(path: Path, project_root: Path) -> str:
+    try:
+        return str(path.resolve().relative_to(project_root.resolve()))
+    except ValueError:
+        return str(path)

package/runtime/python/okstra_ctl/team.py

@@ -20,7 +20,7 @@ from .dispatch_core import (
 _SUPPORTED_WRAPPERS = {
     "claude": "okstra-claude-exec.sh",
     "codex": "okstra-codex-exec.sh",
-    "gemini": "okstra-gemini-exec.sh",
+    "antigravity": "okstra-antigravity-exec.sh",
     "report-writer": "okstra-claude-exec.sh",
 }
 _TERMINAL_STATUSES = {"completed", "timeout", "error", "not-run"}

package/runtime/python/okstra_ctl/wizard.py

@@ -31,7 +31,7 @@ from okstra_ctl.models import (
     UnknownModelError,
     resolve_model_metadata,
 )
-from okstra_ctl.clarification_items import scan_approval_gate
+from okstra_ctl.clarification_items import scan_approval_gate, user_response_sidecars
 from okstra_ctl.pr_template import PrTemplateError, resolve_pr_template_path
 from okstra_ctl.run import (
     APPROVED_FRONTMATTER_PATTERN,
@@ -89,7 +89,7 @@ TASK_TYPES: list[tuple[str, str]] = [
 ]
 TASK_TYPE_VALUES = [tt for tt, _ in TASK_TYPES]
 
-EXECUTORS = ["claude", "codex", "gemini"]
+EXECUTORS = ["claude", "codex", "antigravity"]
 
 # Task types that consume an approved plan and need a stage-scope pick:
 # implementation executes a stage, final-verification verifies a stage
@@ -108,7 +108,7 @@ BASE_REF_FREE_INPUT_TOKEN = "__free_input__"
 
 CLAUDE_MODEL_OPTIONS = ["default", "fable", "opus", "sonnet", "haiku"]
 CODEX_MODEL_OPTIONS = ["default", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini"]
-GEMINI_MODEL_OPTIONS = ["default", "gemini-3-pro-preview", "gemini-3-flash-preview", "auto"]
+ANTIGRAVITY_MODEL_OPTIONS = ["default", "gemini-3.1-pro", "gemini-3.5-flash"]
 
 # special pick value: start a brand-new task
 TASK_PICK_NEW_TOKEN = "__new__"
@@ -263,7 +263,7 @@ S_LEAD_MODEL = "lead_model"
 S_EXECUTOR_MODEL = "executor_model"
 S_CLAUDE_MODEL = "claude_model"
 S_CODEX_MODEL = "codex_model"
-S_GEMINI_MODEL = "gemini_model"
+S_ANTIGRAVITY_MODEL = "antigravity_model"
 S_REPORT_WRITER_MODEL = "report_writer_model"
 S_DIRECTIVE_PICK = "directive_pick"
 S_DIRECTIVE = "directive"
@@ -291,7 +291,7 @@ GROUP_MAX_TABS = 4  # AskUserQuestion 의 질문(탭) 수 한도
 # *_TEXT 후속 / workers_override / pr_template_scope 는 의존성 때문에 개별 유지.
 PROMPT_GROUPS: dict[str, tuple[str, ...]] = {
     GROUP_MODELS: (S_LEAD_MODEL, S_EXECUTOR_MODEL, S_CLAUDE_MODEL,
-                   S_CODEX_MODEL, S_GEMINI_MODEL, S_REPORT_WRITER_MODEL),
+                   S_CODEX_MODEL, S_ANTIGRAVITY_MODEL, S_REPORT_WRITER_MODEL),
     GROUP_OPTIONS: (S_DIRECTIVE_PICK, S_RELATED_TASKS_PICK,
                     S_CLARIFICATION_PICK, S_PR_TEMPLATE_PICK),
 }
@@ -371,7 +371,7 @@ class WizardState:
     lead_model: str = ""
     claude_model: str = ""
     codex_model: str = ""
-    gemini_model: str = ""
+    antigravity_model: str = ""
     report_writer_model: str = ""
     directive: str = ""
     directive_pending_text: bool = False
@@ -689,13 +689,13 @@ def _validate_model(provider: str, raw: str) -> str:
 def _executor_model_field(executor: str) -> str:
     return {"claude": "claude_model",
             "codex": "codex_model",
-            "gemini": "gemini_model"}[executor]
+            "antigravity": "antigravity_model"}[executor]
 
 
 def _executor_model_options(executor: str) -> list[str]:
     return {"claude": CLAUDE_MODEL_OPTIONS,
             "codex": CODEX_MODEL_OPTIONS,
-            "gemini": GEMINI_MODEL_OPTIONS}[executor]
+            "antigravity": ANTIGRAVITY_MODEL_OPTIONS}[executor]
 
 
 # ---- Roster / profile helpers -------------------------------------------
@@ -797,6 +797,7 @@ def _p(workspace_root: str, step_id: str, **vars: str) -> dict:
         "echo_variants": raw.get("echo_variants", {}),
         "errors": raw.get("errors", {}),
         "labels": raw.get("labels", {}),
+        "sidecar_note": raw.get("sidecar_note", {}),
         "echo_suffixes": raw.get("echo_suffixes", {}),
         "recent_label_prefix": raw.get("recent_label_prefix", ""),
     }
@@ -1951,6 +1952,20 @@ def _suggest_latest_final_report(state: WizardState) -> str:
         return str(best)
 
 
+def _clarification_sidecar_note(state: WizardState, suggestion: str) -> str:
+    """추천 final-report 와 함께 carry-in 될 ``user-responses/`` 사이드카 현황 문구.
+
+    "final-report 만 물어보니 user-responses 파일이 쓰이는지 불확실하다" 는 혼선을
+    없애기 위해, picker 단계에서 실제 첨부될 답변 파일 개수를 그 자리에서 보여준다.
+    """
+    p = Path(suggestion)
+    if not p.is_absolute() and state.project_root:
+        p = Path(state.project_root) / p
+    count = len(user_response_sidecars(p))
+    note = _p(state.workspace_root, "clarification_pick")["sidecar_note"]
+    return note["attached"].format(count=count) if count else note["empty"]
+
+
 def _latest_run_inputs(
     state: WizardState, *, phase_segment: str = ""
 ) -> dict:
@@ -1991,6 +2006,9 @@ class _OptionalCachedPickSpec:
     target_attr: str         # 확정값을 쓸 state 속성
     pending_attr: str        # 직접 입력 대기 플래그 state 속성
     extra_clear_attrs: tuple[str, ...] = ()  # skip 시 추가로 비울 속성
+    # 추천 옵션 라벨·echo 뒤에 덧붙일 동적 안내(예: 함께 첨부될 사이드카 개수).
+    # (state, 추천 relpath) -> note. 미설정 picker 는 영향 없음.
+    recommend_note: Optional[Callable[["WizardState", str], str]] = None
 
 
 def _pick_snippet(value: str, style: str) -> str:
@@ -2007,7 +2025,10 @@ def _build_optional_cached_pick(state: WizardState, spec: _OptionalCachedPickSpe
     options: list[Option] = []
     if suggestion:
         snippet = _pick_snippet(suggestion, spec.snippet_style)
-        options.append(_opt(spec.recommend_token, t["labels"][spec.label_key].format(snippet=snippet)))
+        label = t["labels"][spec.label_key].format(snippet=snippet)
+        if spec.recommend_note:
+            label += spec.recommend_note(state, suggestion)
+        options.append(_opt(spec.recommend_token, label))
         setattr(state, spec.cache_attr, suggestion)
     options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
     options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
@@ -2032,7 +2053,10 @@ def _submit_optional_cached_pick(
         cached = getattr(state, spec.cache_attr)
         setattr(state, spec.target_attr, cached)
         setattr(state, spec.pending_attr, False)
-        return t["echo_suffixes"][spec.echo_suffix_key].format(value=cached)
+        echo = t["echo_suffixes"][spec.echo_suffix_key].format(value=cached)
+        if spec.recommend_note:
+            echo += spec.recommend_note(state, cached)
+        return echo
     if value == PICK_TYPE_CUSTOM:
         setattr(state, spec.pending_attr, True)
         return None
@@ -2104,6 +2128,7 @@ _CLARIFICATION_PICK_SPEC = _OptionalCachedPickSpec(
     suggest=_suggest_latest_final_report, snippet_style="suffix",
     cache_attr="last_final_report_cached", target_attr="clarification_response_path",
     pending_attr="clarification_pending_text",
+    recommend_note=_clarification_sidecar_note,
 )
 
 
@@ -2251,7 +2276,7 @@ _RESUME_REUSE_PHASES = (
 # YES 선택 시 prefill 로 충족되어 다시 묻지 않는 설정 단계들.
 _REUSE_FILLED_STEPS = (
     S_DEFAULTS_OR_CUSTOM, S_WORKERS_OVERRIDE, S_LEAD_MODEL, S_EXECUTOR_MODEL,
-    S_CLAUDE_MODEL, S_CODEX_MODEL, S_GEMINI_MODEL, S_REPORT_WRITER_MODEL,
+    S_CLAUDE_MODEL, S_CODEX_MODEL, S_ANTIGRAVITY_MODEL, S_REPORT_WRITER_MODEL,
     S_DIRECTIVE_PICK, S_DIRECTIVE, S_RELATED_TASKS_PICK, S_RELATED_TASKS,
     S_CLARIFICATION_PICK, S_CLARIFICATION)
 
@@ -2299,7 +2324,7 @@ def _submit_reuse_previous(state: WizardState, value: str) -> Optional[str]:
     state.lead_model = _safe_model("claude", inputs.get("leadModel"))
     state.claude_model = _safe_model("claude", inputs.get("claudeModel"))
     state.codex_model = _safe_model("codex", inputs.get("codexModel"))
-    state.gemini_model = _safe_model("gemini", inputs.get("geminiModel"))
+    state.antigravity_model = _safe_model("antigravity", inputs.get("antigravityModel"))
     state.report_writer_model = _safe_model(
         "claude", inputs.get("reportWriterModel"))
     directive = inputs.get("directive")
@@ -2445,15 +2470,15 @@ def _submit_codex_model(state: WizardState, value: str) -> Optional[str]:
     return f"codex-model: {state.codex_model or 'default'}"
 
 
-def _build_gemini_model(state: WizardState) -> Prompt:
-    t = _p(state.workspace_root, "gemini_model")
-    return _model_pick(S_GEMINI_MODEL, t["label"],
-                       GEMINI_MODEL_OPTIONS, t["echo_template"])
+def _build_antigravity_model(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "antigravity_model")
+    return _model_pick(S_ANTIGRAVITY_MODEL, t["label"],
+                       ANTIGRAVITY_MODEL_OPTIONS, t["echo_template"])
 
 
-def _submit_gemini_model(state: WizardState, value: str) -> Optional[str]:
-    state.gemini_model = _validate_model("gemini", value)
-    return f"gemini-model: {state.gemini_model or 'default'}"
+def _submit_antigravity_model(state: WizardState, value: str) -> Optional[str]:
+    state.antigravity_model = _validate_model("antigravity", value)
+    return f"antigravity-model: {state.antigravity_model or 'default'}"
 
 
 def _build_report_writer_model(state: WizardState) -> Prompt:
@@ -2930,7 +2955,7 @@ STEPS: list[Step] = [
                             and s.task_type == "implementation"
                             and S_EXECUTOR_MODEL not in s.answered),
          build=_build_executor_model, submit=_submit_executor_model,
-         owns=("claude_model", "codex_model", "gemini_model")),
+         owns=("claude_model", "codex_model", "antigravity_model")),
     Step(S_CLAUDE_MODEL,
          applies=lambda s: (s.use_defaults is False
                             and s.task_type != "implementation"
@@ -2945,13 +2970,13 @@ STEPS: list[Step] = [
                             and S_CODEX_MODEL not in s.answered),
          build=_build_codex_model, submit=_submit_codex_model,
          owns=("codex_model",)),
-    Step(S_GEMINI_MODEL,
+    Step(S_ANTIGRAVITY_MODEL,
          applies=lambda s: (s.use_defaults is False
                             and s.task_type != "implementation"
-                            and "gemini" in _resolved_roster(s)
-                            and S_GEMINI_MODEL not in s.answered),
-         build=_build_gemini_model, submit=_submit_gemini_model,
-         owns=("gemini_model",)),
+                            and "antigravity" in _resolved_roster(s)
+                            and S_ANTIGRAVITY_MODEL not in s.answered),
+         build=_build_antigravity_model, submit=_submit_antigravity_model,
+         owns=("antigravity_model",)),
     Step(S_REPORT_WRITER_MODEL,
          applies=lambda s: (s.use_defaults is False
                             and (s.task_type == "implementation"
@@ -3088,7 +3113,7 @@ def _ready_for_confirm(s: WizardState) -> bool:
         return True
     # customize: every customize-branch step must be answered or not-applicable.
     custom_ids = [S_LEAD_MODEL, S_EXECUTOR_MODEL,
-                  S_CLAUDE_MODEL, S_CODEX_MODEL, S_GEMINI_MODEL,
+                  S_CLAUDE_MODEL, S_CODEX_MODEL, S_ANTIGRAVITY_MODEL,
                   S_REPORT_WRITER_MODEL, S_DIRECTIVE, S_RELATED_TASKS,
                   S_CLARIFICATION, S_PR_TEMPLATE, S_PR_TEMPLATE_SCOPE]
     for sid in custom_ids:
@@ -3130,7 +3155,7 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "reuse_previous": None,
     "use_defaults": None, "workers_override": "",
     "lead_model": "", "claude_model": "", "codex_model": "",
-    "gemini_model": "", "report_writer_model": "", "directive": "",
+    "antigravity_model": "", "report_writer_model": "", "directive": "",
     "directive_pending_text": False,
     "related_tasks_raw": "", "related_tasks_pending_text": False,
     "clarification_response_path": "", "clarification_pending_text": False,
@@ -3299,7 +3324,7 @@ def render_args(state: WizardState) -> dict[str, str]:
         "lead-model": state.lead_model,
         "claude-model": state.claude_model,
         "codex-model": state.codex_model,
-        "gemini-model": state.gemini_model,
+        "antigravity-model": state.antigravity_model,
         "report-writer-model": state.report_writer_model,
         "related-tasks": state.related_tasks_raw,
         "clarification-response": state.clarification_response_path,
@@ -3339,8 +3364,8 @@ def confirmation_block(state: WizardState) -> str:
         lines.append(f"  claude-model  : {state.claude_model}")
     if state.codex_model:
         lines.append(f"  codex-model   : {state.codex_model}")
-    if state.gemini_model:
-        lines.append(f"  gemini-model  : {state.gemini_model}")
+    if state.antigravity_model:
+        lines.append(f"  antigravity-model  : {state.antigravity_model}")
     if state.report_writer_model:
         lines.append(f"  report-writer : {state.report_writer_model}")
     lines.append(f"  directive     : {state.directive or '(none)'}")

package/runtime/python/okstra_ctl/workers.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
-ALLOWED_WORKERS = ["claude", "codex", "gemini", "report-writer"]
+ALLOWED_WORKERS = ["claude", "codex", "antigravity", "report-writer"]
 DEFAULT_WORKERS = ["claude", "codex", "report-writer"]
 PROFILE_BULLET_HEADERS = {
     "- Workers:",
@@ -64,7 +64,7 @@ def resolve_profile_workers(profile_path: Path) -> list[str]:
 
 def resolve_optional_workers(profile_path: Path) -> list[str]:
     r"""`- Optional workers (opt-in via \`--workers\`):` 섹션 아래 sub-bullet
-    들에서 worker id 만 추출한다. (`  - gemini — when added …` → `gemini`)
+    들에서 worker id 만 추출한다. (`  - antigravity — when added …` → `antigravity`)
     Required 와 중복되는 항목은 제거. ALLOWED_WORKERS 밖 토큰도 제거.
     """
     raw = _resolve_workers_under(profile_path, PROFILE_BULLET_HEADERS_OPTIONAL)
@@ -83,7 +83,7 @@ def normalize_workers(value: str) -> list[str]:
     """CSV 입력을 정규화한다.
 
     - 공백 strip, 소문자화, 중복 제거(첫 출현 우선).
-    - 빈 입력이면 `DEFAULT_WORKERS` 를 default 로 사용 (gemini 제외).
+    - 빈 입력이면 `DEFAULT_WORKERS` 를 default 로 사용 (antigravity 제외).
     - 허용 외 worker 가 포함되면 `WorkersError`.
     """
     items = [v.strip().lower() for v in (value or "").split(",") if v.strip()]

package/runtime/python/okstra_ctl/workflow.py

@@ -83,7 +83,7 @@ PHASE_RULES: dict[str, dict[str, str]] = {
             "  - `Out-of-plan edits` block listing every file touched outside the approved plan with rationale (empty block preferred)\n"
             '  - validation evidence: actual stdout/stderr and exit code for every pre / mid / post command from the plan (no paraphrased "tests pass")\n'
             "  - TDD evidence for TDD-applicable steps: failing-test output before implementation commit and passing-test output after, with framing SHAs\n"
-            "  - per-verifier sections (`Gemini verifier`, `Codex verifier`, `Claude verifier`) with independent verdict (PASS / CONCERNS / FAIL) and cited diff snippets; dissent is preserved by `Claude lead`\n"
+            "  - per-verifier sections (`Antigravity verifier`, `Codex verifier`, `Claude verifier`) with independent verdict (PASS / CONCERNS / FAIL) and cited diff snippets; dissent is preserved by `Claude lead`\n"
             "  - rollback verification (revert SHA reachable, feature flag toggle works, migration down step valid; dry-run preferred)\n"
             "  - routing recommendation for `final-verification` (ready / needs new error-analysis or planning loop)"
         ),

package/runtime/python/okstra_ctl/worktree.py

@@ -479,7 +479,7 @@ def _link_sync_files(source_root: Path, worktree_path: Path) -> list[str]:
 
 def _seed_worktree_settings_symlink(worktree_path: Path) -> None:
     """Seed `.claude/settings.local.json` in the worker worktree so dispatched
-    Claude / codex / gemini sessions inherit the okstra read-only / write
+    Claude / codex / antigravity sessions inherit the okstra read-only / write
     allowlist. Mirrors the main-project seeding done in `run.py` — needed
     because `_link_sync_dirs` skips `.claude/` whenever `git worktree add`
     already materialised the directory (e.g. tracked `.claude/handoff-*.md`).

package/runtime/python/okstra_token_usage/__init__.py

@@ -5,12 +5,11 @@ from .blocks import na_block, usage_block
 from .claude import claude_session_totals, find_claude_team_sessions
 from .codex import codex_session_total, find_codex_session
 from .collect import collect
-from .gemini import find_gemini_session, gemini_session_total
+from .antigravity import antigravity_session_total, find_antigravity_session
 from .jsonl_io import iter_jsonl
 from .paths import (
     CLAUDE_PROJECTS,
     CODEX_SESSIONS,
-    GEMINI_TMP,
     claude_project_dir,
     utc_now,
 )
@@ -21,7 +20,7 @@ from .pricing import (
     claude_billable_equivalent,
     claude_cost_usd,
     codex_cost_usd,
-    gemini_cost_usd,
+    antigravity_cost_usd,
 )
 from .report import (
     SubstituteRefusedError,

package/runtime/python/okstra_token_usage/antigravity.py

@@ -0,0 +1,26 @@
+"""Antigravity (`agy`) CLI usage collector.
+
+okstra dispatches the antigravity-worker via `agy --print` (see
+`okstra-antigravity-exec.sh`). That non-interactive print mode does not persist
+a parseable transcript with per-call token counts to any known location, so
+per-run token/cost usage cannot be attributed to the antigravity worker. These
+collectors therefore report "unavailable" rather than fabricating numbers — the
+worker's usage block degrades to `na` and `/okstra-inspect context-cost` shows
+N/A for antigravity. If a future `agy` build exposes a transcript, wire its
+parser here (model ids stay `gemini-*`, so `antigravity_cost_usd` already prices it).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def antigravity_session_total(json_path: Path) -> dict:
+    return {"totalTokens": 0, "available": False}
+
+
+def find_antigravity_session(project_root: Path, started_at: str, ended_at: str) -> Path | None:
+    return None
+
+
+def find_antigravity_sessions(project_root: Path, started_at: str, ended_at: str) -> list[Path]:
+    return []

package/runtime/python/okstra_token_usage/blocks.py

@@ -15,6 +15,8 @@ def usage_block(totals: dict, source: str, note: str | None = None) -> dict:
         "outputTokens": totals.get("outputTokens", 0) or 0,
         "toolUses": totals.get("toolUses", 0) or 0,
         "durationMs": totals.get("durationMs", 0) or 0,
+        "startedAt": totals.get("startedAt"),
+        "endedAt": totals.get("endedAt"),
         "source": source,
         "collectedAt": utc_now(),
     }
@@ -57,6 +59,8 @@ def na_block(reason: str) -> dict:
         "totalTokens": 0,
         "toolUses": 0,
         "durationMs": 0,
+        "startedAt": None,
+        "endedAt": None,
         "source": "unavailable",
         "collectedAt": utc_now(),
         "note": reason,

package/runtime/python/okstra_token_usage/collect.py

@@ -14,9 +14,13 @@ from .claude import (
     find_claude_team_sessions,
 )
 from .codex import codex_session_total, find_codex_session, find_codex_sessions
-from .gemini import find_gemini_session, find_gemini_sessions, gemini_session_total
+from .antigravity import (
+    antigravity_session_total,
+    find_antigravity_session,
+    find_antigravity_sessions,
+)
 from .paths import claude_project_dir, utc_now
-from .pricing import codex_cost_usd, gemini_cost_usd
+from .pricing import codex_cost_usd, antigravity_cost_usd
 
 
 def match_prefixes(worker_id: str) -> list[str]:
@@ -275,7 +279,7 @@ def _codex_runtime_provider(worker: dict) -> str:
     agent = str(worker.get("agent") or "").strip()
     if worker_id == "report-writer":
         return "codex"
-    if agent in {"codex", "gemini"}:
+    if agent in {"codex", "antigravity"}:
         return agent
     return ""
 
@@ -290,8 +294,8 @@ def _cli_sessions_for_windows(
     for started_at, ended_at in windows:
         if provider == "codex":
             matches = find_codex_sessions(project_root, started_at, ended_at)
-        elif provider == "gemini":
-            matches = find_gemini_sessions(project_root, started_at, ended_at)
+        elif provider == "antigravity":
+            matches = find_antigravity_sessions(project_root, started_at, ended_at)
         else:
             matches = []
         for path in matches:
@@ -307,7 +311,7 @@ def _cli_session_totals(provider: str, session_paths: list[Path]) -> list[dict]:
         if provider == "codex":
             total = codex_session_total(session_path)
         else:
-            total = gemini_session_total(session_path)
+            total = antigravity_session_total(session_path)
         if total.get("available"):
             totals.append(total)
     return totals
@@ -328,7 +332,7 @@ def _cli_usage_block(provider: str, totals: dict, session_paths: list[Path]) ->
             totals.get("outputTokens", 0) or 0,
         )
     else:
-        cost = gemini_cost_usd(
+        cost = antigravity_cost_usd(
             totals.get("model"),
             totals.get("inputTokens", 0) or 0,
             totals.get("outputTokens", 0) or 0,
@@ -403,7 +407,7 @@ def _populate_usage_summary(
     for w in workers:
         u = w.get("usage") or {}
         if (
-            u.get("source") not in {"codex-cli", "gemini-cli"}
+            u.get("source") not in {"codex-cli", "agy-cli"}
             and u.get("model")
             and u.get("estimatedCostUsd") is None
             and (u.get("totalTokens") or 0) > 0
@@ -433,7 +437,7 @@ def _populate_usage_summary(
         "definitions": {
             "totalTokens": "Sum of input + output + cache_creation + cache_read tokens (raw processed volume; matches Anthropic API breakdown). Cache reads are 95%+ in long sessions.",
             "billableEquivalentTokens": "Tokens normalized to base-input-price units (cache_creation_5m x1.25, cache_creation_1h x2.0, cache_read x0.1, output x5). 5m vs 1h is split from usage.cache_creation when the API breakdown is present; otherwise all cache_creation falls into 5m.",
-            "estimatedCostUsd": "USD cost using public list pricing for the model recorded in the session. cliWorkers covers Codex/Gemini CLI calls billed under those providers.",
+            "estimatedCostUsd": "USD cost using public list pricing for the model recorded in the session. cliWorkers covers Codex/Antigravity CLI calls billed under those providers.",
         },
     }
 
@@ -547,17 +551,18 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
             block["additionalSessionIds"] = [sid for sid, _, _ in matched[1:]]
             block["matchedAgentNames"] = sorted({t.get("agentName") for _, _, t in matched if t.get("agentName")})
 
-        # For codex/gemini workers, find every CLI session that fell inside the
-        # aggregated wrapper window.
+        # For codex/antigravity workers, find every CLI session that fell inside
+        # the aggregated wrapper window. (agy print mode leaves no transcript, so
+        # the antigravity path always resolves to "session not found" → na cost.)
         wrapper_start = aggregate.get("startedAt") or ""
         wrapper_end = aggregate.get("endedAt") or ""
-        if agent in ("codex", "gemini"):
+        if agent in ("codex", "antigravity"):
             if agent == "codex":
                 cli = find_codex_session(cwd, wrapper_start, wrapper_end)
                 cli_totals = codex_session_total(cli) if cli else None
             else:
-                cli = find_gemini_session(cwd, wrapper_start, wrapper_end)
-                cli_totals = gemini_session_total(cli) if cli else None
+                cli = find_antigravity_session(cwd, wrapper_start, wrapper_end)
+                cli_totals = antigravity_session_total(cli) if cli else None
             if cli is None:
                 block["cliNote"] = f"{agent} CLI session not found in wrapper window (fallback or never invoked)"
             else:
@@ -574,7 +579,7 @@ def collect(team_state_path: Path, project_root: Path | None = None, *,
                             cli_totals.get("outputTokens", 0) or 0,
                         )
                     else:
-                        cost = gemini_cost_usd(
+                        cost = antigravity_cost_usd(
                             cli_totals.get("model"),
                             cli_totals.get("inputTokens", 0) or 0,
                             cli_totals.get("outputTokens", 0) or 0,