okstra 0.86.0 → 0.87.0

package/runtime/python/okstra_ctl/error_report.py

@@ -0,0 +1,185 @@
+"""Read-side aggregator for okstra-run error logs.
+
+task 의 모든 run errors-<type>-<seq>.jsonl 을 모아 phase / worker / errorType
+별로 집계하고 timestamp 누적 .md 리포트로 렌더한다. task 산출물을 mutate 하지
+않는다.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import json
+import sys
+from pathlib import Path
+
+from okstra_ctl.task_target import resolve_task_root, project_rel
+
+
+def _glob_error_logs(task_root: Path) -> list[Path]:
+    runs = task_root / "runs"
+    if not runs.exists():
+        return []
+    flat = runs.glob("*/logs/errors-*.jsonl")
+    staged = runs.glob("*/stage-*/logs/errors-*.jsonl")
+    return sorted(set(flat) | set(staged))
+
+
+def _parse_records(paths: list[Path]) -> tuple[list[dict], int]:
+    records: list[dict] = []
+    skipped = 0
+    for path in paths:
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rec = json.loads(line)
+            except Exception:
+                skipped += 1
+                continue
+            if isinstance(rec, dict):
+                rec["_sourceLog"] = str(path)
+                records.append(rec)
+            else:
+                skipped += 1
+    return records, skipped
+
+
+def _tally(records: list[dict], key: str) -> dict:
+    out: dict[str, int] = {}
+    for rec in records:
+        out[str(rec.get(key, ""))] = out.get(str(rec.get(key, "")), 0) + 1
+    return out
+
+
+def _rows(counts: dict, label: str) -> list[dict]:
+    return [
+        {label: name, "count": n}
+        for name, n in sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
+    ]
+
+
+def _aggregate(records: list[dict]) -> dict:
+    return {
+        "errorCount": len(records),
+        "runCount": len({rec.get("_sourceLog", "") for rec in records}),
+        "byErrorType": _tally(records, "errorType"),
+        "bySource": _tally(records, "source"),
+        "byPhase": _rows(_tally(records, "phase"), "phase"),
+        "byAgent": _rows(_tally(records, "agent"), "agent"),
+    }
+
+
+def _escape_cell(value: object) -> str:
+    return str(value).replace("|", "\\|").replace("\n", " ")
+
+
+def _md_table(header: list[str], rows: list[list[str]]) -> str:
+    line = "| " + " | ".join(_escape_cell(h) for h in header) + " |"
+    sep = "| " + " | ".join("---" for _ in header) + " |"
+    if not rows:
+        empty = "| " + " | ".join(["_없음_"] + [""] * (len(header) - 1)) + " |"
+        return "\n".join([line, sep, empty])
+    body = ["| " + " | ".join(_escape_cell(c) for c in cells) + " |" for cells in rows]
+    return "\n".join([line, sep, *body])
+
+
+def render_markdown(*, task_key, records, agg, parse_skipped, generated_at) -> str:
+    by_type = ", ".join(f"{k}: {v}" for k, v in sorted(agg["byErrorType"].items())) or "_없음_"
+    by_src = ", ".join(f"{k}: {v}" for k, v in sorted(agg["bySource"].items())) or "_없음_"
+    parts = [
+        f"# okstra 에러 리포트 — {task_key}",
+        "",
+        "## 요약",
+        "",
+        f"- 총 에러: {agg['errorCount']}건",
+        f"- 집계된 로그(run) 수: {agg['runCount']}",
+        f"- errorType 별: {by_type}",
+        f"- source 별: {by_src}",
+        f"- 파싱 건너뛴 줄: {parse_skipped}",
+        f"- 생성 시각: {generated_at}",
+        "",
+        "## phase 별 집계",
+        "",
+        _md_table(["Phase", "Count"],
+                  [[r["phase"] or "(없음)", str(r["count"])] for r in agg["byPhase"]]),
+        "",
+        "## worker(agent) 별 집계",
+        "",
+        _md_table(["Agent", "Count"],
+                  [[r["agent"] or "(없음)", str(r["count"])] for r in agg["byAgent"]]),
+        "",
+        "## 개별 에러 이벤트",
+        "",
+        _md_table(
+            ["ts", "phase", "agent", "errorType", "command", "exitCode", "message"],
+            [[
+                str(r.get("ts", "")), str(r.get("phase", "")), str(r.get("agent", "")),
+                str(r.get("errorType", "")), f"`{r.get('command', '')}`",
+                str(r.get("exitCode", "")),
+                str(r.get("message", "")),
+            ] for r in sorted(records, key=lambda x: str(x.get("ts", "")))],
+        ),
+        "",
+    ]
+    return "\n".join(parts)
+
+
+def _timestamp_segment(now: dt.datetime) -> str:
+    return now.strftime("%Y-%m-%d_%H-%M-%S")
+
+
+def build_and_write(task_root: Path, project_root: Path, now: dt.datetime) -> dict:
+    manifest_path = task_root / "task-manifest.json"
+    task_key = ""
+    if manifest_path.is_file():
+        try:
+            task_key = json.loads(manifest_path.read_text(encoding="utf-8")).get("taskKey", "")
+        except Exception:
+            task_key = ""
+    paths = _glob_error_logs(task_root)
+    records, skipped = _parse_records(paths)
+    agg = _aggregate(records)
+    report_rel = ""
+    if paths:
+        md = render_markdown(
+            task_key=task_key, records=records, agg=agg,
+            parse_skipped=skipped, generated_at=now.isoformat(),
+        )
+        out_dir = task_root / "error-reports"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_path = out_dir / f"error-report-{_timestamp_segment(now)}.md"
+        out_path.write_text(md, encoding="utf-8")
+        report_rel = project_rel(out_path, project_root)
+    return {
+        "taskKey": task_key,
+        "reportPath": report_rel,
+        "parseSkipped": skipped,
+        "totals": {
+            "errorCount": agg["errorCount"],
+            "runCount": agg["runCount"],
+            "byErrorType": agg["byErrorType"],
+            "bySource": agg["bySource"],
+        },
+        "byPhase": agg["byPhase"],
+        "byAgent": agg["byAgent"],
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Aggregate okstra-run error logs into a task-level report."
+    )
+    parser.add_argument("target", help="task root path or task-key")
+    parser.add_argument("--project-root", default="", help="project root for task-key lookup")
+    parser.add_argument("--cwd", default=".", help="cwd for project root resolution")
+    args = parser.parse_args(argv)
+
+    task_root, project_root = resolve_task_root(args.target, args.project_root, args.cwd)
+    result = build_and_write(task_root, project_root, dt.datetime.now(dt.timezone.utc))
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/improvement_lenses.py

@@ -24,7 +24,7 @@ MAX_PRIORITY_LENSES = 4
 
 # report-writer is the AUTHOR of the final report; it never produces source
 # findings. validators reject `report-writer:<id>` entries in Source workers.
-SOURCE_WORKERS: tuple[str, ...] = ("claude", "codex", "gemini")
+SOURCE_WORKERS: tuple[str, ...] = ("claude", "codex", "antigravity")
 
 
 def is_valid_lens(value: str) -> bool:

package/runtime/python/okstra_ctl/models.py

@@ -26,14 +26,14 @@ CLAUDE_MAPPING = {
     "claude-haiku-4-5": ("haiku-4-5", "claude-haiku-4-5"),
     "claude-haiku-4-5-20251001": ("haiku-4-5", "claude-haiku-4-5-20251001"),
 }
-GEMINI_MAPPING = {
-    "auto": ("auto", "auto"),
-    "gemini auto": ("auto", "auto"),
-    "pro": ("pro", "pro"),
-    "gemini pro": ("pro", "pro"),
-    "gemini 3 flash preview": ("Gemini 3 Flash Preview", "gemini-3-flash-preview"),
-    "gemini-3-flash-preview": ("Gemini 3 Flash Preview", "gemini-3-flash-preview"),
-    "gemini-3-pro-preview": ("Gemini 3 Pro Preview", "gemini-3-pro-preview"),
+# Antigravity worker runs the `agy` CLI, which executes Gemini-family models.
+# The execution values stay `gemini-3.x` (agy accepts those slugs); only the
+# okstra provider/worker identity is "antigravity".
+ANTIGRAVITY_MAPPING = {
+    "gemini 3.1 pro": ("Gemini 3.1 Pro", "gemini-3.1-pro"),
+    "gemini-3.1-pro": ("Gemini 3.1 Pro", "gemini-3.1-pro"),
+    "gemini 3.5 flash": ("Gemini 3.5 Flash", "gemini-3.5-flash"),
+    "gemini-3.5-flash": ("Gemini 3.5 Flash", "gemini-3.5-flash"),
 }
 CODEX_MAPPING = {
     "gpt-5.5": ("gpt-5.5", "gpt-5.5"),
@@ -43,7 +43,7 @@ CODEX_MAPPING = {
     "gpt-5.2": ("gpt-5.2", "gpt-5.2"),
     "codex-auto-review": ("codex-auto-review", "codex-auto-review"),
 }
-PROVIDER_MAPPINGS = {"claude": CLAUDE_MAPPING, "gemini": GEMINI_MAPPING, "codex": CODEX_MAPPING}
+PROVIDER_MAPPINGS = {"claude": CLAUDE_MAPPING, "antigravity": ANTIGRAVITY_MAPPING, "codex": CODEX_MAPPING}
 
 
 @dataclass
@@ -61,7 +61,7 @@ def resolve_model_metadata(
 ) -> ModelAssignment:
     """alias → (display, execution_value).
 
-    provider: "claude" | "codex" | "gemini" (그 외는 mapping 미적용)
+    provider: "claude" | "codex" | "antigravity" (그 외는 mapping 미적용)
 
     Mapping 이 정의된 provider 에 대해 사용자가 빈 값이 아닌 raw_value 를 줬는데
     mapping 에 없는 경우 `UnknownModelError` 를 발생시킨다. 이는 manifest 에

package/runtime/python/okstra_ctl/paths.py

@@ -175,7 +175,7 @@ def compute_run_paths(
     run_prompt_snapshot = run_prompts / f"claude-execution-prompt{suffixes['prompts']}.md"
     claude_worker_prompt = run_prompts / f"claude-worker-prompt{suffixes['prompts']}.md"
     codex_worker_prompt = run_prompts / f"codex-worker-prompt{suffixes['prompts']}.md"
-    gemini_worker_prompt = run_prompts / f"gemini-worker-prompt{suffixes['prompts']}.md"
+    antigravity_worker_prompt = run_prompts / f"antigravity-worker-prompt{suffixes['prompts']}.md"
     report_writer_worker_prompt = run_prompts / f"report-writer-worker-prompt{suffixes['prompts']}.md"
     final_report = run_reports / f"final-report{suffixes['reports']}.md"
     final_status = run_status / f"final{suffixes['status']}.status"
@@ -190,7 +190,7 @@ def compute_run_paths(
     task_catalog_file = discovery_dir / "task-catalog.json"
     claude_worker_result = worker_results / f"claude-worker{suffixes['worker_results']}.md"
     codex_worker_result = worker_results / f"codex-worker{suffixes['worker_results']}.md"
-    gemini_worker_result = worker_results / f"gemini-worker{suffixes['worker_results']}.md"
+    antigravity_worker_result = worker_results / f"antigravity-worker{suffixes['worker_results']}.md"
     report_writer_worker_result = worker_results / f"report-writer-worker{suffixes['worker_results']}.md"
 
     run_errors_log = run_logs / f"errors-{task_type_segment}-{seqs['state']}.jsonl"
@@ -198,7 +198,7 @@ def compute_run_paths(
 
     claude_worker_errors_sidecar = worker_results / f"claude-worker-errors{suffixes['worker_results']}.json"
     codex_worker_errors_sidecar = worker_results / f"codex-worker-errors{suffixes['worker_results']}.json"
-    gemini_worker_errors_sidecar = worker_results / f"gemini-worker-errors{suffixes['worker_results']}.json"
+    antigravity_worker_errors_sidecar = worker_results / f"antigravity-worker-errors{suffixes['worker_results']}.json"
     report_writer_worker_errors_sidecar = worker_results / f"report-writer-worker-errors{suffixes['worker_results']}.json"
 
     run_validator_script = workspace_root / "validators" / "validate-run.py"
@@ -262,7 +262,7 @@ def compute_run_paths(
         "RUN_PROMPT_SNAPSHOT_FILE": str(run_prompt_snapshot),
         "CLAUDE_WORKER_PROMPT_FILE": str(claude_worker_prompt),
         "CODEX_WORKER_PROMPT_FILE": str(codex_worker_prompt),
-        "GEMINI_WORKER_PROMPT_FILE": str(gemini_worker_prompt),
+        "ANTIGRAVITY_WORKER_PROMPT_FILE": str(antigravity_worker_prompt),
         "REPORT_WRITER_WORKER_PROMPT_FILE": str(report_writer_worker_prompt),
         "FINAL_REPORT_PATH": str(final_report),
         "FINAL_STATUS_PATH": str(final_status),
@@ -277,12 +277,12 @@ def compute_run_paths(
         "OKSTRA_TASK_CATALOG_FILE": str(task_catalog_file),
         "CLAUDE_WORKER_RESULT_FILE": str(claude_worker_result),
         "CODEX_WORKER_RESULT_FILE": str(codex_worker_result),
-        "GEMINI_WORKER_RESULT_FILE": str(gemini_worker_result),
+        "ANTIGRAVITY_WORKER_RESULT_FILE": str(antigravity_worker_result),
         "REPORT_WRITER_WORKER_RESULT_FILE": str(report_writer_worker_result),
         "RUN_ERRORS_LOG_PATH": str(run_errors_log),
         "CLAUDE_WORKER_ERRORS_SIDECAR_PATH": str(claude_worker_errors_sidecar),
         "CODEX_WORKER_ERRORS_SIDECAR_PATH": str(codex_worker_errors_sidecar),
-        "GEMINI_WORKER_ERRORS_SIDECAR_PATH": str(gemini_worker_errors_sidecar),
+        "ANTIGRAVITY_WORKER_ERRORS_SIDECAR_PATH": str(antigravity_worker_errors_sidecar),
         "REPORT_WRITER_WORKER_ERRORS_SIDECAR_PATH": str(report_writer_worker_errors_sidecar),
         "RUN_VALIDATOR_PATH": str(run_validator_script),
         "RUN_MANIFEST_FILENAME": run_manifest_file.name,
@@ -323,7 +323,7 @@ def compute_run_paths(
         ("RUN_PROMPT_SNAPSHOT_RELATIVE_PATH", run_prompt_snapshot),
         ("CLAUDE_WORKER_PROMPT_RELATIVE_PATH", claude_worker_prompt),
         ("CODEX_WORKER_PROMPT_RELATIVE_PATH", codex_worker_prompt),
-        ("GEMINI_WORKER_PROMPT_RELATIVE_PATH", gemini_worker_prompt),
+        ("ANTIGRAVITY_WORKER_PROMPT_RELATIVE_PATH", antigravity_worker_prompt),
         ("REPORT_WRITER_WORKER_PROMPT_RELATIVE_PATH", report_writer_worker_prompt),
         ("FINAL_REPORT_RELATIVE_PATH", final_report),
         ("FINAL_STATUS_RELATIVE_PATH", final_status),
@@ -339,12 +339,12 @@ def compute_run_paths(
         ("RUN_VALIDATOR_RELATIVE_PATH", run_validator_script),
         ("CLAUDE_WORKER_RESULT_RELATIVE_PATH", claude_worker_result),
         ("CODEX_WORKER_RESULT_RELATIVE_PATH", codex_worker_result),
-        ("GEMINI_WORKER_RESULT_RELATIVE_PATH", gemini_worker_result),
+        ("ANTIGRAVITY_WORKER_RESULT_RELATIVE_PATH", antigravity_worker_result),
         ("REPORT_WRITER_WORKER_RESULT_RELATIVE_PATH", report_writer_worker_result),
         ("RUN_ERRORS_LOG_RELATIVE_PATH", run_errors_log),
         ("CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", claude_worker_errors_sidecar),
         ("CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", codex_worker_errors_sidecar),
-        ("GEMINI_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", gemini_worker_errors_sidecar),
+        ("ANTIGRAVITY_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", antigravity_worker_errors_sidecar),
         ("REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", report_writer_worker_errors_sidecar),
         ("LATEST_RUN_RELATIVE_PATH", run_dir),
     ]

package/runtime/python/okstra_ctl/reconcile.py

@@ -14,6 +14,10 @@ from .project_meta import upsert_project_meta
 
 DEFAULT_ABORT_AFTER_SECONDS = 12 * 3600  # 12시간 무진척이면 aborted 로 간주
 
+# recent.jsonl 에서 디스크 manifest 로 재조정 대상이 되는 비종결 상태.
+# completed/failed/aborted 는 이미 종결이라 건드리지 않는다.
+NON_TERMINAL_RECENT_STATUSES = {"prepared", "running", "in-progress"}
+
 
 def _now_iso() -> str:
     return datetime.now(timezone.utc).replace(tzinfo=None).strftime("%Y-%m-%dT%H:%M:%SZ")
@@ -74,6 +78,26 @@ def _read_run_manifest_validation(project_root: Path, run_dir_rel: str,
     return "not-run"
 
 
+def _sync_project_index(home: Path, project_id: str, updated_rows: list) -> None:
+    """updated_rows 의 (status/finishedAt/validation) 를 프로젝트 index.jsonl 의
+    동일 runId 행에 반영한다. reconcile_active(promote) 와 reconcile_recent
+    (in-place refresh) 가 공유하는 단일 인덱스 갱신 경로."""
+    proj_index = home / "projects" / project_id / "index.jsonl"
+    if not proj_index.is_file():
+        return
+    by_id = {r["runId"]: r for r in updated_rows}
+    existing = read_jsonl(proj_index)
+    for er in existing:
+        src = by_id.get(er.get("runId"))
+        if src:
+            er.update({k: src[k] for k in ("status", "finishedAt", "validation")})
+    tmp = proj_index.with_suffix(".jsonl.tmp")
+    with tmp.open("w") as f:
+        for er in existing:
+            f.write(json.dumps(er, separators=(",", ":")) + "\n")
+    os.replace(tmp, proj_index)
+
+
 def reconcile_active(home: Path, *,
                      abort_after_seconds: int = DEFAULT_ABORT_AFTER_SECONDS,
                      project: Optional[str] = None) -> dict:
@@ -148,19 +172,58 @@ def _reconcile_active_locked(home: Path, *,
     os.replace(tmp, active)
     for row in promoted:
         append_jsonl(home / "recent.jsonl", row)
-        proj_index = home / "projects" / row["projectId"] / "index.jsonl"
-        if proj_index.is_file():
-            existing = read_jsonl(proj_index)
-            for er in existing:
-                if er.get("runId") == row["runId"]:
-                    er.update({k: row[k] for k in ("status", "finishedAt", "validation")})
-            tmp = proj_index.with_suffix(".jsonl.tmp")
-            with tmp.open("w") as f:
-                for er in existing:
-                    f.write(json.dumps(er, separators=(",", ":")) + "\n")
-            os.replace(tmp, proj_index)
+        _sync_project_index(home, row["projectId"], [row])
         upsert_project_meta(home, row["projectId"],
                             project_root=row["projectRoot"],
                             when=row["finishedAt"], finished=True)
     rotate_recent_if_needed(home)
     return summary
+
+
+def reconcile_recent(home: Path, *, project: Optional[str] = None) -> dict:
+    """recent.jsonl 의 비종결(prepared 등) 행을 디스크 run-manifest 로 in-place 갱신.
+
+    `--render-only` 로 prepared 로 박힌 행은 record_start 가 terminal 로 취급해
+    recent 에 직접 쓰므로 reconcile_active(active.jsonl 전용) 의 promote 경로를
+    타지 않고, backfill 도 이미 인덱싱된 runId 라 skip 한다. 실행이 끝나
+    manifest 가 terminal(passed/failed) 로 바뀌어도 recent 의 status 가 prepared
+    로 영영 고착되는 갭을 메운다. 중앙 락 안에서 read-modify-write 한다."""
+    with central_lock(home):
+        return _reconcile_recent_locked(home, project=project)
+
+
+def _reconcile_recent_locked(home: Path, *, project: Optional[str] = None) -> dict:
+    recent = home / "recent.jsonl"
+    summary = {"completed": 0, "failed": 0, "unchanged": 0}
+    rows = read_jsonl(recent)
+    updated_by_project: dict = {}
+    for row in rows:
+        if (project and row.get("projectId") != project) or \
+                row.get("status") not in NON_TERMINAL_RECENT_STATUSES:
+            summary["unchanged"] += 1
+            continue
+        validation_status = _read_run_manifest_validation(
+            Path(row.get("projectRoot", "")), row.get("runDirRel", ""),
+            row.get("taskType", ""), int(row.get("runSeq", 0) or 0))
+        if not validation_status or validation_status == "not-run":
+            summary["unchanged"] += 1
+            continue
+        new_status = normalize_reconciled_report_status(validation_status)
+        if new_status in NON_TERMINAL_RECENT_STATUSES:
+            summary["unchanged"] += 1
+            continue
+        row["status"] = new_status
+        row["finishedAt"] = row.get("finishedAt") or _now_iso()
+        row["validation"] = validation_status
+        updated_by_project.setdefault(row["projectId"], []).append(row)
+        summary["completed" if new_status == "completed" else "failed"] += 1
+    if not updated_by_project:
+        return summary
+    tmp = recent.with_suffix(".jsonl.tmp")
+    with tmp.open("w") as f:
+        for row in rows:
+            f.write(json.dumps(row, separators=(",", ":")) + "\n")
+    os.replace(tmp, recent)
+    for pid, urows in updated_by_project.items():
+        _sync_project_index(home, pid, urows)
+    return summary

package/runtime/python/okstra_ctl/render.py

@@ -256,15 +256,15 @@ def _worker_catalog(ctx: dict) -> dict:
             "resultPath": ctx.get("CODEX_WORKER_RESULT_RELATIVE_PATH", ""),
             "promptPath": ctx.get("CODEX_WORKER_PROMPT_RELATIVE_PATH", ""),
         },
-        "gemini": {
-            "workerId": "gemini",
-            "role": "Gemini worker",
-            "agent": "gemini",
-            "agentLabel": "Gemini",
-            "model": ctx.get("GEMINI_WORKER_MODEL", ""),
-            "modelExecutionValue": ctx.get("GEMINI_WORKER_MODEL_EXECUTION_VALUE", ""),
-            "resultPath": ctx.get("GEMINI_WORKER_RESULT_RELATIVE_PATH", ""),
-            "promptPath": ctx.get("GEMINI_WORKER_PROMPT_RELATIVE_PATH", ""),
+        "antigravity": {
+            "workerId": "antigravity",
+            "role": "Antigravity worker",
+            "agent": "antigravity",
+            "agentLabel": "Antigravity",
+            "model": ctx.get("ANTIGRAVITY_WORKER_MODEL", ""),
+            "modelExecutionValue": ctx.get("ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE", ""),
+            "resultPath": ctx.get("ANTIGRAVITY_WORKER_RESULT_RELATIVE_PATH", ""),
+            "promptPath": ctx.get("ANTIGRAVITY_WORKER_PROMPT_RELATIVE_PATH", ""),
         },
         "report-writer": {
             "workerId": "report-writer",
@@ -364,7 +364,7 @@ def _active_error_logs(ctx: dict) -> dict:
         "sidecarsByWorkerId": {
             "claude": ctx.get("CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
             "codex": ctx.get("CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
-            "gemini": ctx.get("GEMINI_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
+            "antigravity": ctx.get("ANTIGRAVITY_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
             "report-writer": ctx.get("REPORT_WRITER_WORKER_ERRORS_SIDECAR_RELATIVE_PATH", ""),
         },
     }
@@ -1057,7 +1057,7 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
             "requiredAgentStatusEntries": required_agent_status_entries,
             "requireDistinctLeadFromClaudeWorker": True,
             "requireAllRequiredWorkerAttempts": True,
-            "requireGeminiWorkerAttempt": "gemini" in reviewers,
+            "requireAntigravityWorkerAttempt": "antigravity" in reviewers,
             "requireCollectedWorkerStatusesBeforeFinalVerdict": True,
             "disallowLeadSoloAnalysisAsWorkerResult": True,
             "disallowGenericParallelOnlyExecution": True,
@@ -1127,7 +1127,7 @@ def _build_convergence_block(ctx: dict) -> dict:
     ctx knobs honoured:
     - `OKSTRA_PLAN_VERIFICATION`: "true" | "false" | "" (empty → default True).
       Wired from CLI `--no-plan-verification` (sets "false").
-    - `CRITIC_CHOICE`: "" | "off" | "claude" | "codex" | "gemini" — critic
+    - `CRITIC_CHOICE`: "" | "off" | "claude" | "codex" | "antigravity" — critic
       backing provider (enabled only for requirements-discovery / error-analysis /
       implementation-planning / final-verification); model taken from that
       provider's execution value.
@@ -1145,7 +1145,7 @@ def _build_convergence_block(ctx: dict) -> dict:
     critic_exec_key = {
         "claude": "CLAUDE_WORKER_MODEL_EXECUTION_VALUE",
         "codex": "CODEX_WORKER_MODEL_EXECUTION_VALUE",
-        "gemini": "GEMINI_WORKER_MODEL_EXECUTION_VALUE",
+        "antigravity": "ANTIGRAVITY_WORKER_MODEL_EXECUTION_VALUE",
     }
     critic_enabled = critic_choice in critic_exec_key and task_type in critic_phases
     critic_block = {
@@ -1287,7 +1287,7 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
             + [catalog[item]["role"] for item in reviewers],
             "requireDistinctLeadFromClaudeWorker": True,
             "requireAllRequiredWorkerAttempts": True,
-            "requireGeminiWorkerAttempt": "gemini" in reviewers,
+            "requireAntigravityWorkerAttempt": "antigravity" in reviewers,
             "requireCollectedWorkerStatusesBeforeFinalVerdict": True,
             "disallowLeadSoloAnalysisAsWorkerResult": True,
             "disallowGenericParallelOnlyExecution": True,
@@ -1329,7 +1329,7 @@ def render_timeline(timeline_path: str, ctx: dict) -> None:
     worker_prompt_paths = {
         "claude": ctx.get("CLAUDE_WORKER_PROMPT_RELATIVE_PATH", ""),
         "codex": ctx.get("CODEX_WORKER_PROMPT_RELATIVE_PATH", ""),
-        "gemini": ctx.get("GEMINI_WORKER_PROMPT_RELATIVE_PATH", ""),
+        "antigravity": ctx.get("ANTIGRAVITY_WORKER_PROMPT_RELATIVE_PATH", ""),
         "report-writer": ctx.get("REPORT_WRITER_WORKER_PROMPT_RELATIVE_PATH", ""),
     }
     path = Path(timeline_path)
@@ -1527,7 +1527,7 @@ def render_task_index(template_path: str, output_path: str, ctx: dict) -> None:
                 f"- `{lead_role}`: `{rc.get('leadModel', ctx.get('LEAD_MODEL', ''))}`",
                 f"- `Claude worker`: `{ctx.get('CLAUDE_WORKER_MODEL', '')}`",
                 f"- `Codex worker`: `{ctx.get('CODEX_WORKER_MODEL', '')}`",
-                f"- `Gemini worker`: `{ctx.get('GEMINI_WORKER_MODEL', '')}`",
+                f"- `Antigravity worker`: `{ctx.get('ANTIGRAVITY_WORKER_MODEL', '')}`",
                 f"- `Report writer worker`: `{ctx.get('REPORT_WRITER_MODEL', '')}`",
             ]
         ),
@@ -1759,9 +1759,9 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
         worker_role_sentence = "- No worker roles were selected for this run."
         preferred_results_sentence = "- No worker results are expected for this run."
     worker_attempt_sentence = (
-        "- `Gemini worker` is mandatory to attempt for this workflow."
-        if "gemini" in selected
-        else "- `Gemini worker` is not selected for this run, so no Gemini attempt is required."
+        "- `Antigravity worker` is mandatory to attempt for this workflow."
+        if "antigravity" in selected
+        else "- `Antigravity worker` is not selected for this run, so no Antigravity attempt is required."
     )
 
     # Team creation gate block: phase-conditional.
@@ -1998,7 +1998,7 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
             "\n"
             "- The `runs/<phase>/prompts/<worker>-worker-prompt-*.md` files referenced in `task-manifest.json → artifacts.workerPromptPathByWorkerId` are **NOT** rendered by the okstra runtime. Those paths are the *assigned* locations where the prompt history MUST be written at dispatch time.\n"
             "- Therefore: at the start of every phase the prompts/ directory is normally empty (or contains only previously-dispatched workers' files). This is expected. Do NOT narrate it as \"missing\", \"누락\", or \"not yet rendered\" — it just means dispatch has not happened yet.\n"
-            "- Before dispatching any required worker, **you (the lead) construct the worker prompt and persist it to the assigned absolute path using `Write`** (per `team-contract` rule 6). Only after persisting do you call the worker subagent (Agent tool / Codex / Gemini wrapper). The wrapper subagents will also re-write the same file on their end; the double-write is intentional and idempotent.\n"
+            "- Before dispatching any required worker, **you (the lead) construct the worker prompt and persist it to the assigned absolute path using `Write`** (per `team-contract` rule 6). Only after persisting do you call the worker subagent (Agent tool / Codex / Antigravity wrapper). The wrapper subagents will also re-write the same file on their end; the double-write is intentional and idempotent.\n"
             "- Do not \"check if the file exists and skip dispatch\" — file presence is not a signal to skip. Worker selection and skipping rules come from team-state, never from prompts/ directory contents.\n"
             f"- **Worker Preamble Path (single anchor — replaces inlined `[Required reading]` and `[Error reporting]` blocks).** Every worker prompt you construct MUST include the anchor header `**Worker Preamble Path:** {ctx.get('WORKER_PROMPT_PREAMBLE_PATH', str(okstra_home() / 'templates' / 'worker-prompt-preamble.md'))}`. The file at that path is the canonical SSOT for Required Reading + Error Reporting + Output sections; workers Read it end-to-end before producing output. Do NOT re-inline those blocks into worker prompt bodies — that is the legacy ~80-line dispatch boilerplate that this anchor is designed to replace."
         )
@@ -2014,7 +2014,7 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     ctx["MODEL_ASSIGNMENT_LINES"] = "\n".join(model_assignment_lines)
     ctx["TEAM_ROLE_LINES"] = "\n".join(team_role_lines)
     ctx["REQUIRED_WORKER_ROLE_SENTENCE"] = worker_role_sentence
-    ctx["GEMINI_ATTEMPT_SENTENCE"] = worker_attempt_sentence
+    ctx["ANTIGRAVITY_ATTEMPT_SENTENCE"] = worker_attempt_sentence
     ctx["PREFERRED_WORKER_RESULTS_SENTENCE"] = preferred_results_sentence
     ctx["EXECUTION_STATUS_EXACT_ENTRIES"] = ", ".join(execution_status_entries)
     ctx["EXECUTION_STATUS_TABLE_ROWS"] = "\n".join(execution_status_table_lines)

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,