rakit-cli 2.0.1__py3-none-any.whl

rakit_cli/main.py

@@ -0,0 +1,1397 @@
+"""Titik masuk CLI `rakit` (`init`, `scan`, `start`, `sync`, `verify`, `generate-guides`)."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import socket
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+from rakit_cli.branding import RAKIT_CLI_VERSION, RAKIT_COMPACT_BADGE, render_cli_banner
+from rakit_cli.config import (
+    WorkspaceConfig,
+    compute_workspace_fingerprint,
+    enqueue_offline_sync_event,
+    fetch_and_write_prompt,
+    get_effective_api_token,
+    load_workspace_config,
+    save_workspace_config,
+    write_active_task_prompt,
+)
+from rakit_cli.security import is_safe_workspace_path, redact_sensitive_text
+from rakit_cli.skill_installer import (
+    get_default_global_skill_dir,
+    get_default_workspace_skill_dir,
+    install_skill,
+)
+from rakit_cli.tasks_parser import parse_tasks_markdown
+
+
+def _scan_safe_files(workspace_root: Path) -> list[str]:
+    """Mengumpulkan daftar jalur relatif berkas yang aman dari folder kerja lokal."""
+    discovered: list[str] = []
+    for item in sorted(workspace_root.rglob("*")):
+        if not item.is_file():
+            continue
+        rel = item.relative_to(workspace_root).as_posix()
+        if is_safe_workspace_path(rel):
+            discovered.append(rel)
+    return discovered
+
+
+def _detect_local_modules(safe_files: Sequence[str]) -> list[str]:
+    """Mendeteksi nama modul aplikasi dari daftar jalur berkas lokal (Keranjang 1 Smart Scan)."""
+    modules: set[str] = set()
+    for rel_path in safe_files:
+        parts = rel_path.split("/")
+        if "apps" in parts:
+            idx = parts.index("apps")
+            if idx + 1 < len(parts) and "." not in parts[idx + 1]:
+                modules.add(f"apps.{parts[idx + 1]}")
+        elif "features" in parts:
+            idx = parts.index("features")
+            if idx + 1 < len(parts) and "." not in parts[idx + 1]:
+                modules.add(f"mobile.{parts[idx + 1]}")
+        elif len(parts) >= 2 and parts[0] == "src":
+            modules.add(f"cli.{parts[1]}")
+    return sorted(modules)
+
+
+def _detect_verification_commands(
+    workspace_root: Path,
+    safe_files: Sequence[str],
+) -> dict[str, str]:
+    """Mendeteksi perintah lint, unit test, dan E2E standar sesuai ekosistem proyek target."""
+    has_python = (workspace_root / "pyproject.toml").exists() or any(
+        f.endswith(".py") for f in safe_files
+    )
+    has_node = (workspace_root / "package.json").exists()
+    has_flutter = (workspace_root / "pubspec.yaml").exists()
+
+    has_pytest_e2e = (workspace_root / "tests" / "e2e").is_dir() or any(
+        f.startswith("tests/e2e/") for f in safe_files
+    )
+    has_playwright_ts = (
+        (workspace_root / "playwright.config.ts").exists()
+        or (workspace_root / "playwright.config.js").exists()
+        or (workspace_root / "runners" / "playwright.rakit.config.ts").exists()
+        or any(f.endswith(".spec.ts") for f in safe_files)
+    )
+    has_flutter_it = (workspace_root / "integration_test").is_dir()
+
+    if has_python:
+        lint_cmd = "uv run ruff check ."
+        test_cmd = "uv run pytest"
+    elif has_flutter:
+        lint_cmd = "flutter analyze"
+        test_cmd = "flutter test"
+    elif has_node:
+        lint_cmd = "npm run lint"
+        test_cmd = "npm test"
+    else:
+        lint_cmd = "uv run ruff check ."
+        test_cmd = "uv run pytest"
+
+    if has_pytest_e2e:
+        e2e_dir = "tests/e2e/"
+        e2e_cmd = "uv run pytest tests/e2e/ -m e2e --no-cov"
+    elif has_playwright_ts:
+        e2e_dir = "runners/" if (workspace_root / "runners").is_dir() else "e2e/"
+        e2e_cmd = "npx playwright test"
+    elif has_flutter and has_flutter_it:
+        e2e_dir = "integration_test/"
+        e2e_cmd = "flutter test integration_test"
+    elif has_node and not has_python:
+        e2e_dir = "e2e/"
+        e2e_cmd = "npx playwright test"
+    else:
+        e2e_dir = "tests/e2e/"
+        e2e_cmd = "uv run pytest -m e2e --no-cov"
+
+    return {
+        "lint_command": lint_cmd,
+        "test_command": test_cmd,
+        "e2e_dir": e2e_dir,
+        "e2e_command": e2e_cmd,
+    }
+
+
+def _sync_completed_to_markdown(
+    tasks_markdown: str,
+    completed_titles: Sequence[str],
+) -> tuple[str, list[str]]:
+    """
+    Otomatis mencentang [x] butir to-do di TASKS.md lokal yang tiketnya
+    telah mencapai status DONE di server (US-037).
+    """
+    import re
+
+    if not tasks_markdown.strip() or not completed_titles:
+        return tasks_markdown, []
+
+    updated_lines: list[str] = []
+    synced_items: list[str] = []
+    norm_completed = [
+        re.sub(r"[^\w\s]", "", t.strip().lower()) for t in completed_titles if t.strip()
+    ]
+
+    for line in tasks_markdown.splitlines():
+        match = re.match(r"^(\s*[-*]\s*\[)\s*(\]\s*)(.*)$", line)
+        if match:
+            prefix, bracket, task_content = match.groups()
+            task_clean = re.sub(r"[^\w\s]", "", task_content.strip().lower())
+            matched = any(
+                (c in task_clean or task_clean in c or (len(c) > 15 and c[:25] in task_clean))
+                for c in norm_completed
+                if c
+            )
+            if matched:
+                updated_lines.append(f"{prefix}x{bracket}{task_content}")
+                synced_items.append(task_content.strip())
+                continue
+        updated_lines.append(line)
+
+    return "\n".join(updated_lines), synced_items
+
+
+def _request_json(
+    url: str,
+    *,
+    method: str = "POST",
+    payload: dict[str, Any] | None = None,
+    token: str = "",
+    timeout: int = 5,
+) -> tuple[str, dict[str, Any]]:
+    """Mengirim permintaan JSON via HTTP dan mengembalikan (status_label, body_json)."""
+    import urllib.error
+    import urllib.request
+
+    data = json.dumps(payload).encode("utf-8") if payload is not None else None
+    headers: dict[str, str] = {}
+    if payload is not None:
+        headers["Content-Type"] = "application/json"
+    if token:
+        headers["Authorization"] = f"Token {token}"
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+            parsed = json.loads(raw) if raw.strip() else {}
+            return "synced_to_server", parsed if isinstance(parsed, dict) else {}
+    except urllib.error.HTTPError as err:
+        err_body: dict[str, Any] = {}
+        try:
+            raw_err = err.read().decode("utf-8")
+            parsed_err = json.loads(raw_err) if raw_err.strip() else {}
+            if isinstance(parsed_err, dict):
+                err_body = parsed_err
+        except Exception:
+            pass
+        return f"http_{err.code}", err_body
+    except Exception:
+        return "offline", {}
+
+
+def _post_json(
+    url: str,
+    payload: dict[str, Any],
+    *,
+    token: str = "",
+    timeout: int = 5,
+) -> tuple[str, dict[str, Any]]:
+    """Mengirim JSON via HTTP POST dan mengembalikan (status_label, body_json)."""
+    return _request_json(url, method="POST", payload=payload, token=token, timeout=timeout)
+
+
+def _get_json(
+    url: str,
+    *,
+    token: str = "",
+    timeout: int = 8,
+) -> tuple[str, dict[str, Any]]:
+    """Mengambil JSON via HTTP GET dan mengembalikan (status_label, body_json)."""
+    return _request_json(url, method="GET", token=token, timeout=timeout)
+
+
+_DOC_START_MARKER = "<!-- RAKIT-AUTO-DOCS:START -->"
+_DOC_END_MARKER = "<!-- RAKIT-AUTO-DOCS:END -->"
+
+
+def _upsert_managed_doc_section(
+    target_path: Path,
+    doc_content: str,
+    *,
+    overwrite: bool = False,
+    dry_run: bool = False,
+) -> str:
+    """Menulis atau memperbarui blok dokumentasi terkelola RAKIT tanpa menimpa isi manual."""
+    block = f"{_DOC_START_MARKER}\n{doc_content.strip()}\n{_DOC_END_MARKER}\n"
+    if overwrite or not target_path.exists():
+        action = "written"
+        updated_text = block
+    else:
+        existing = target_path.read_text(encoding="utf-8")
+        if _DOC_START_MARKER in existing and _DOC_END_MARKER in existing:
+            before, _, rest = existing.partition(_DOC_START_MARKER)
+            _, _, after = rest.partition(_DOC_END_MARKER)
+            updated_text = f"{before.rstrip()}\n\n{block.rstrip()}\n{after.lstrip()}"
+            updated_text = updated_text.lstrip("\n")
+            action = "updated_managed_block"
+        else:
+            sep = "\n\n---\n\n" if existing.strip() else ""
+            updated_text = f"{existing.rstrip()}{sep}{block}"
+            action = "appended_managed_block"
+
+    if not dry_run:
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        target_path.write_text(updated_text, encoding="utf-8")
+    return action
+
+
+def _close_ticket_on_server(
+    *,
+    workspace_root: Path,
+    cfg: WorkspaceConfig,
+    ticket_key: str,
+    token: str,
+    approve_g2: bool,
+    pr_url: str,
+    note: str,
+) -> dict[str, Any]:
+    """Mengirim pengesahan G3 lokal/non-PR dan opsi G2 ke `/tickets/<key>/g3-close/`."""
+    sanitized_note = redact_sensitive_text(note.strip())[:1000] if note.strip() else ""
+    srv_status, srv_body = _post_json(
+        f"{cfg.api_base_url}/tickets/{ticket_key}/g3-close/",
+        {
+            "project_slug": cfg.project_slug,
+            "pr_url": pr_url.strip(),
+            "note": sanitized_note,
+            "approve_g2": bool(approve_g2),
+        },
+        token=token,
+        timeout=8,
+    )
+    data_obj = srv_body.get("data") if isinstance(srv_body.get("data"), dict) else {}
+    ticket_obj = data_obj.get("ticket") if isinstance(data_obj.get("ticket"), dict) else {}
+    ticket_status = str(ticket_obj.get("status") or "")
+
+    if srv_status == "synced_to_server":
+        if ticket_status == "DONE" and cfg.active_ticket_key == ticket_key:
+            save_workspace_config(
+                workspace_root,
+                WorkspaceConfig(
+                    project_slug=cfg.project_slug,
+                    api_base_url=cfg.api_base_url,
+                    machine_label=cfg.machine_label,
+                    root_fingerprint=cfg.root_fingerprint,
+                    active_ticket_key="",
+                    api_token=cfg.api_token,
+                    secret_blocklist=cfg.secret_blocklist,
+                ),
+            )
+        return {
+            "status": "closed",
+            "ticket_key": ticket_key,
+            "ticket_status": ticket_status or "DONE",
+            "server_close_status": srv_status,
+            "unlocked_dependents": data_obj.get("unlocked_dependents", []),
+            "documentation_draft_id": data_obj.get("documentation_draft_id"),
+            "message": srv_body.get("message", ""),
+        }
+
+    return {
+        "status": "close_failed",
+        "ticket_key": ticket_key,
+        "ticket_status": ticket_status,
+        "server_close_status": srv_status,
+        "server_message": srv_body.get("message", ""),
+    }
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Membentuk parser argumen CLI `rakit`."""
+    parser = argparse.ArgumentParser(
+        prog="rakit",
+        description=render_cli_banner(),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"rakit-cli {RAKIT_CLI_VERSION} ({RAKIT_COMPACT_BADGE})",
+    )
+    parser.add_argument(
+        "--workspace",
+        type=Path,
+        default=Path.cwd(),
+        help="Jalur folder kerja lokal (bawaan: direktori aktif)",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("banner", help="Tampilkan logo ASCII dan identitas versi RAKIT v2.0")
+
+    init_cmd = subparsers.add_parser("init", help="Ikat folder kerja notebook ke proyek RAKIT")
+    init_cmd.add_argument("--project", required=True, help="Slug proyek di server RAKIT")
+    init_cmd.add_argument(
+        "--api-url",
+        default=os.getenv("RAKIT_API_URL", "http://localhost:8000/api/v1"),
+        help="URL dasar API RAKIT Core (bawaan: http://localhost:8000/api/v1)",
+    )
+    init_cmd.add_argument(
+        "--token",
+        default=os.getenv("RAKIT_API_TOKEN", ""),
+        help="Token autentikasi DRF API RAKIT (opsional untuk sinkronisasi otomatis ke server)",
+    )
+    init_cmd.add_argument(
+        "--machine-label",
+        default=socket.gethostname(),
+        help="Nama identitas mesin notebook ini",
+    )
+    init_cmd.add_argument(
+        "--no-skill",
+        action="store_true",
+        help="Jangan pasang berkas AI Skill (.agents/skills/rakit/SKILL.md) secara otomatis",
+    )
+
+    scan_cmd = subparsers.add_parser(
+        "scan",
+        help="Pindai struktur berkas aman dan TASKS.md serta sinkronkan ke Web Console",
+    )
+    scan_cmd.add_argument(
+        "--token",
+        default="",
+        help="Token API RAKIT (opsional bila memakai RAKIT_API_TOKEN)",
+    )
+    scan_cmd.add_argument(
+        "--persist",
+        action="store_true",
+        default=True,
+        help="Simpan draf tiket langsung ke BACKLOG Web Console (bawaan: True)",
+    )
+    scan_cmd.add_argument(
+        "--no-persist",
+        action="store_false",
+        dest="persist",
+        help="Hanya pindai tanpa menyimpan draf tiket ke BACKLOG",
+    )
+
+    start_cmd = subparsers.add_parser(
+        "start",
+        help="Tandai tiket aktif untuk dikerjakan di notebook",
+    )
+    start_cmd.add_argument("ticket_key", help="Kunci tiket, misal W-001")
+
+    sync_cmd = subparsers.add_parser(
+        "sync",
+        help="Hitung progres TASKS.md, antrekan secara idempoten, & cetak muatan sinkronisasi",
+    )
+    sync_cmd.add_argument("--note", default="", help="Catatan ringkas milestone aktif")
+
+    verify_cmd = subparsers.add_parser(
+        "verify",
+        help="Periksa kesiapan kontrak berkas lokal dan laporkan hasil verifikasi ke server RAKIT",
+    )
+    verify_cmd.add_argument(
+        "--ticket",
+        default="",
+        help="Kunci tiket (bawaan: tiket aktif di .rakit/workspace.json)",
+    )
+    verify_cmd.add_argument(
+        "--note",
+        default="",
+        help="Ringkasan hasil uji / log konsol dari notebook",
+    )
+    verify_cmd.add_argument(
+        "--failed",
+        action="store_true",
+        help="Tandai hasil verifikasi gagal (memicu self-healing kembali ke CODING)",
+    )
+    verify_cmd.add_argument(
+        "--auto-close",
+        action="store_true",
+        help="Mode Auto: bila verifikasi lulus (UAT_REVIEW), otomatis sahkan G2 + G3 hingga DONE",
+    )
+    verify_cmd.add_argument(
+        "--pr-url",
+        default="",
+        help="Tautan PR / referensi commit lokal opsional saat --auto-close aktif",
+    )
+
+    close_cmd = subparsers.add_parser(
+        "close",
+        help="Tutup tiket melalui Gerbang G3 lokal/non-PR hingga DONE (Mode Manual & Auto)",
+    )
+    close_cmd.add_argument(
+        "ticket_key",
+        nargs="?",
+        default="",
+        help="Kunci tiket (bawaan: tiket aktif di .rakit/workspace.json)",
+    )
+    close_cmd.add_argument(
+        "--ticket",
+        dest="ticket_flag",
+        default="",
+        help="Alternatif penulisan kunci tiket (--ticket W-070)",
+    )
+    close_cmd.add_argument(
+        "--approve-g2",
+        action="store_true",
+        help="Sahkan Gerbang G2 (bila bukti E2E lulus) sekaligus sebelum penutupan G3 ke DONE",
+    )
+    close_cmd.add_argument(
+        "--pr-url",
+        default="",
+        help="Tautan PR GitHub atau referensi commit/branch lokal opsional",
+    )
+    close_cmd.add_argument(
+        "--note",
+        default="",
+        help="Catatan keputusan / penutupan tiket",
+    )
+
+    docs_cmd = subparsers.add_parser(
+        "docs",
+        help="Tarik bundel dokumentasi gabungan (User Guide, FAQ, Help, Changelog) dari RAKIT",
+    )
+    docs_sub = docs_cmd.add_subparsers(dest="docs_action", required=True)
+    docs_pull_cmd = docs_sub.add_parser(
+        "pull",
+        help="Unduh dan gabungkan dokumen pasca-G3 ke folder docs/ proyek lokal",
+    )
+    docs_pull_cmd.add_argument(
+        "--out-dir",
+        default="docs",
+        help="Direktori tujuan untuk USER_GUIDE.md, FAQ.md, HELP.md (bawaan: docs)",
+    )
+    docs_pull_cmd.add_argument(
+        "--only",
+        default="",
+        help="Filter berkas opsional, pisah koma (guide,faq,help,changelog)",
+    )
+    docs_pull_cmd.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Timpa penuh isi berkas target alih-alih memperbarui blok terkelola RAKIT",
+    )
+    docs_pull_cmd.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Tampilkan pratinjau berkas yang akan ditulis tanpa mengubah disk",
+    )
+
+    guides_cmd = subparsers.add_parser(
+        "generate-guides",
+        help="Hasilkan draf AGENTS.md dan rakit.yaml untuk proyek (US-004)",
+    )
+    guides_cmd.add_argument(
+        "--write",
+        action="store_true",
+        help="Tulis berkas draf ke .rakit/AGENTS.draft.md dan .rakit/rakit.draft.yaml",
+    )
+
+    subparsers.add_parser(
+        "install-hook",
+        help="Pasang skrip .git/hooks/post-commit untuk menjalankan rakit sync otomatis (US-011)",
+    )
+
+    token_cmd = subparsers.add_parser(
+        "token",
+        help="Simpan atau periksa token API akun RAKIT di .rakit/workspace.json",
+    )
+    token_cmd.add_argument("value", nargs="?", default="", help="Token API akun dari Web Console")
+
+    prompt_cmd = subparsers.add_parser(
+        "prompt",
+        help="Unduh spesifikasi tiket dari peladen dan tulis berkas .rakit/PROMPT.md (US-014)",
+    )
+    prompt_cmd.add_argument(
+        "ticket_key",
+        nargs="?",
+        default="",
+        help="Kunci tiket (opsional jika tiket aktif sudah tersimpan di workspace.json)",
+    )
+
+    skill_cmd = subparsers.add_parser(
+        "skill",
+        help="Kelola berkas AI Assistant Skill RAKIT v2.0 untuk Antigravity/Claude/Cursor",
+    )
+    skill_sub = skill_cmd.add_subparsers(dest="skill_action", required=True)
+    skill_install_cmd = skill_sub.add_parser(
+        "install",
+        help="Pasang berkas SKILL.md ke workspace lokal (.agents/skills/rakit/) atau global",
+    )
+    skill_install_cmd.add_argument(
+        "--global",
+        dest="is_global",
+        action="store_true",
+        help="Pasang ke direktori global (~/.agents/skills/rakit/)",
+    )
+    skill_install_cmd.add_argument(
+        "--force",
+        action="store_true",
+        help="Timpa berkas SKILL.md jika sudah ada sebelumnya",
+    )
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """
+    TUJUAN: Menjalankan sub-perintah `rakit` dan mengeluarkan ringkasan JSON terstruktur.
+
+    DIPANGGIL DARI: Entrypoint konsol `rakit`
+    DEPENDENSI: config, security, tasks_parser
+    """
+    args = build_parser().parse_args(argv)
+    workspace_root: Path = args.workspace.resolve()
+
+    if args.command == "banner":
+        print(
+            json.dumps(
+                {
+                    "status": "ok",
+                    "name": "RAKIT",
+                    "version": RAKIT_CLI_VERSION,
+                    "badge": RAKIT_COMPACT_BADGE,
+                    "ascii_logo": render_cli_banner(),
+                }
+            )
+        )
+        return 0
+
+    if args.command == "init":
+        raw_token = getattr(args, "token", "") or os.getenv("RAKIT_API_TOKEN", "")
+        token = raw_token.strip() if isinstance(raw_token, str) else ""
+
+        cfg = WorkspaceConfig(
+            project_slug=args.project,
+            api_base_url=args.api_url.rstrip("/"),
+            machine_label=args.machine_label,
+            root_fingerprint=compute_workspace_fingerprint(workspace_root),
+            api_token=token,
+        )
+        saved_path = save_workspace_config(workspace_root, cfg)
+
+        safe_files = _scan_safe_files(workspace_root)
+        verification_cmds = _detect_verification_commands(workspace_root, safe_files)
+
+        # 1. Otomatis buat rakit.yaml di root jika belum ada
+        rakit_yaml_path = workspace_root / "rakit.yaml"
+        rakit_yaml_status = "existing"
+        if not rakit_yaml_path.exists():
+            rakit_yaml_content = (
+                f"# rakit.yaml — Konfigurasi Orkestrasi Proyek RAKIT v2.0\n"
+                f"version: 2\n"
+                f"project:\n"
+                f'  slug: "{cfg.project_slug}"\n'
+                f'  name: "{cfg.project_slug}"\n'
+                f'  default_branch: "main"\n'
+                f"  daily_token_limit: 1000000\n"
+                f"security:\n"
+                f"  block_dotenv: true\n"
+                f"  staging_allowlist:\n"
+                f'    - "127.0.0.1"\n'
+                f'    - "localhost"\n'
+                f"verification:\n"
+                f'  lint_command: "{verification_cmds["lint_command"]}"\n'
+                f'  test_command: "{verification_cmds["test_command"]}"\n'
+                f'  e2e_dir: "{verification_cmds["e2e_dir"]}"\n'
+                f'  e2e_command: "{verification_cmds["e2e_command"]}"\n'
+            )
+            rakit_yaml_path.write_text(rakit_yaml_content, encoding="utf-8")
+            rakit_yaml_status = "created"
+
+        # 2. Otomatis buat AGENTS.md jika belum ada, atau simpan snippet jika sudah ada
+        agents_md_path = workspace_root / "AGENTS.md"
+        agents_md_status = "existing_preserved"
+        modules = _detect_local_modules(safe_files)
+        modules_list = (
+            "\n".join(f"- `{m}`" for m in modules) if modules else "- `apps/core` (Modul Inti)"
+        )
+
+        protocol_lines = (
+            "## 0. Protokol Wajib Awal Sesi AI/LLM (Periksa RAKIT Terlebih Dahulu)\n"
+            "Setiap kali agen AI/LLM memulai sesi di repositori ini, kamu DIWAJIBKAN:\n"
+            "1. **Eksekusi Riil (Bukan Simulasi)**: DILARANG KERAS hanya menampilkan atau "
+            "mensimulasikan output teks/markdown di obrolan chat! Agen WAJIB mengeksekusi "
+            "tool MCP (`rakit_claim_ticket`, `rakit_sync_progress`, dll.) atau menjalankan "
+            "perintah terminal secara nyata ke peladen RAKIT.\n"
+            "2. **Autentikasi Token RAKIT**: Gunakan environment variable `RAKIT_API_TOKEN` "
+            "atau header `Authorization: Token <TOKEN>`. Token aktif dapat dilihat di menu "
+            "Profil & Token Web Console RAKIT (`/accounts/profile/`).\n"
+            "3. **Cek Tiket Backlog**: Jalankan `rakit status` di terminal atau panggil tool MCP "
+            "`rakit_status` untuk melihat tiket di `READY` / `BACKLOG`.\n"
+            "4. **Klaim Tiket Sebelum Koding**: DILARANG mengubah berkas tanpa tiket aktif! "
+            "Jalankan `rakit start <KEY>` atau panggil tool MCP `rakit_claim_ticket`.\n"
+            "5. **Disiplin TDD**: Setiap modifikasi fungsi wajib disertai Unit Test yang sesuai.\n"
+            "6. **Sinkronisasi Progres**: Centang to-do `[x]` pada `TASKS.md`, lalu jalankan "
+            "`rakit sync` untuk melaporkan progres ke Web Console RAKIT.\n"
+            "7. **Ambiguitas / Keraguan**: Jangan berasumsi — panggil tool MCP `rakit_ask_human` "
+            "atau laporkan via `rakit sync --note` agar dijawab pengembang di Web Console.\n"
+            "8. **Verifikasi Akhir**: Setelah kode selesai & tes lulus, jalankan `rakit verify` "
+            "menuju Gerbang G2 (QA & UAT Review).\n\n"
+        )
+
+        agents_rakit_section = (
+            f"# AGENTS.md — Kontrak Eksekusi Proyek {cfg.project_slug}\n\n"
+            f"{protocol_lines}"
+            f"## 1. Identitas Proyek\n"
+            f"- **Slug RAKIT**: `{cfg.project_slug}`\n"
+            f"- **Mesin Notebook**: `{cfg.machine_label}`\n\n"
+            f"## 2. Modul Terdeteksi (Keranjang 1 Smart Scan)\n"
+            f"{modules_list}\n\n"
+            f"## 3. Aturan Keamanan Ketat\n"
+            f"1. Dilarang keras membaca, memodifikasi, atau mengirim berkas rahasia `.env*`, "
+            f"`*.pem`, `*.key`, dan folder `secrets/`.\n"
+            f"2. Selalu gunakan `uv` untuk eksekusi Python (`uv run ...`). "
+            f"Dilarang memakai `pip` atau `poetry` langsung.\n"
+        )
+
+        if not agents_md_path.exists():
+            agents_md_path.write_text(agents_rakit_section, encoding="utf-8")
+            agents_md_status = "created"
+        else:
+            rakit_dir = workspace_root / ".rakit"
+            rakit_dir.mkdir(parents=True, exist_ok=True)
+            (rakit_dir / "AGENTS.rakit.md").write_text(agents_rakit_section, encoding="utf-8")
+            agents_md_status = "existing_preserved_snippet_saved_to_dot_rakit"
+
+        # 3. Otomatis pasang SKILL.md ke .agents/skills/rakit/ jika tidak diabaikan
+        skill_status = "skipped"
+        skill_path_str = ""
+        if not getattr(args, "no_skill", False):
+            skill_dir = get_default_workspace_skill_dir(workspace_root)
+            skill_file, skill_status = install_skill(skill_dir, force=False)
+            skill_path_str = skill_file.as_posix()
+
+        # 4. Coba kirim binding ke peladen Web Console RAKIT (bila peladen aktif)
+        server_binding_status = "local_only"
+        server_message = "Konfigurasi lokal berhasil disimpan."
+        raw_token = getattr(args, "token", "") or os.getenv("RAKIT_API_TOKEN", "")
+        token = raw_token.strip() if isinstance(raw_token, str) else ""
+
+        try:
+            import urllib.error
+            import urllib.request
+
+            bind_url = f"{cfg.api_base_url}/workspaces/bind/"
+            req_data = json.dumps(
+                {
+                    "project_slug": cfg.project_slug,
+                    "machine_label": cfg.machine_label,
+                    "root_fingerprint": cfg.root_fingerprint,
+                }
+            ).encode("utf-8")
+            headers = {"Content-Type": "application/json"}
+            if token:
+                headers["Authorization"] = f"Token {token}"
+
+            req = urllib.request.Request(bind_url, data=req_data, headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=2) as resp:
+                if resp.status == 200:
+                    server_binding_status = "connected"
+                    server_message = "Workspace berhasil terikat ke Web Console RAKIT!"
+        except urllib.error.HTTPError as exc:
+            if exc.code in {401, 403}:
+                server_binding_status = "auth_required"
+                server_message = (
+                    "Konfigurasi lokal tersimpan. Web Console memerlukan --token "
+                    "atau klik '+ Ikat Komputer Ini' di browser Web Console."
+                )
+            else:
+                server_binding_status = f"http_{exc.code}"
+                server_message = f"Peladen merespons kode HTTP {exc.code}."
+        except Exception:
+            server_binding_status = "offline"
+            server_message = "Konfigurasi lokal tersimpan (peladen offline atau belum dijangkau)."
+
+        print(
+            json.dumps(
+                {
+                    "status": "initialized",
+                    "project_slug": cfg.project_slug,
+                    "config_file": saved_path.as_posix(),
+                    "rakit_yaml": rakit_yaml_status,
+                    "agents_md": agents_md_status,
+                    "skill": skill_status,
+                    "skill_path": skill_path_str,
+                    "root_fingerprint": cfg.root_fingerprint,
+                    "secret_blocklist": list(cfg.secret_blocklist),
+                    "server_binding": server_binding_status,
+                    "message": server_message,
+                }
+            )
+        )
+        return 0
+
+    if args.command == "skill":
+        if getattr(args, "skill_action", "") == "install":
+            dest_dir = (
+                get_default_global_skill_dir()
+                if getattr(args, "is_global", False)
+                else get_default_workspace_skill_dir(workspace_root)
+            )
+            skill_file, skill_status = install_skill(
+                dest_dir, force=getattr(args, "force", False)
+            )
+            target_scope = "global" if getattr(args, "is_global", False) else "workspace"
+            action_desc = (
+                "berhasil diperbarui" if skill_status == "updated" else "berhasil dipasang"
+            )
+            print(
+                json.dumps(
+                    {
+                        "status": "skill_installed",
+                        "target": target_scope,
+                        "skill_file": skill_file.as_posix(),
+                        "install_status": skill_status,
+                        "message": (
+                            f"Skill RAKIT v2.0 ({target_scope}) {action_desc}: "
+                            f"{skill_file.as_posix()}."
+                        ),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return 0
+
+    existing_cfg = load_workspace_config(workspace_root)
+    if existing_cfg is None:
+        print(json.dumps({"error": "WORKSPACE_NOT_INITIALIZED"}))
+        return 1
+
+    if args.command == "scan":
+        safe_files = _scan_safe_files(workspace_root)
+        tasks_file = workspace_root / "TASKS.md"
+        tasks_content = tasks_file.read_text(encoding="utf-8") if tasks_file.exists() else ""
+        tasks_info = parse_tasks_markdown(tasks_content)
+
+        status_file = workspace_root / "STATUS.md"
+        status_content = status_file.read_text(encoding="utf-8") if status_file.exists() else ""
+
+        discovered_modules = _detect_local_modules(safe_files)
+        open_tasks_count = max(tasks_info.total_count - tasks_info.completed_count, 0)
+
+        # Coba sinkronkan langsung ke Web Console RAKIT via API
+        server_sync_status = "local_only"
+        server_message = "Pemindaian lokal selesai."
+        created_tickets: list[str] = []
+        raw_token = getattr(args, "token", "") or os.getenv("RAKIT_API_TOKEN", "")
+        token = raw_token.strip() if isinstance(raw_token, str) else ""
+
+        try:
+            import urllib.error
+            import urllib.request
+
+            scan_url = f"{existing_cfg.api_base_url}/workspaces/smart-scan/"
+            req_data = json.dumps(
+                {
+                    "project_slug": existing_cfg.project_slug,
+                    "machine_label": existing_cfg.machine_label,
+                    "root_fingerprint": existing_cfg.root_fingerprint,
+                    "safe_file_paths": safe_files[:1500],
+                    "tasks_markdown": tasks_content,
+                    "status_markdown": status_content,
+                    "persist_drafts": getattr(args, "persist", True),
+                }
+            ).encode("utf-8")
+            headers = {"Content-Type": "application/json"}
+            if token:
+                headers["Authorization"] = f"Token {token}"
+
+            req = urllib.request.Request(scan_url, data=req_data, headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=8) as resp:
+                if resp.status == 200:
+                    resp_json = json.loads(resp.read().decode("utf-8"))
+                    payload_data = resp_json.get("data") or {}
+                    server_sync_status = "synced_to_server"
+                    created_tickets = payload_data.get("created_ticket_keys", [])
+                    server_message = (
+                        f"Hasil Smart Scan berhasil disinkronkan ke Web Console RAKIT! "
+                        f"{len(created_tickets)} draf tiket masuk ke BACKLOG."
+                        if created_tickets
+                        else "Hasil Smart Scan berhasil disinkronkan ke Web Console RAKIT."
+                    )
+        except urllib.error.HTTPError as exc:
+            server_sync_status = f"http_{exc.code}"
+            server_message = f"Gagal sinkron ke server (HTTP {exc.code})."
+        except Exception:
+            server_sync_status = "offline"
+            server_message = "Pemindaian lokal selesai (peladen RAKIT offline)."
+
+        print(
+            json.dumps(
+                {
+                    "project_slug": existing_cfg.project_slug,
+                    "safe_files_count": len(safe_files),
+                    "tasks_completed": tasks_info.completed_count,
+                    "tasks_total": tasks_info.total_count,
+                    "open_tasks_count": open_tasks_count,
+                    "discovered_modules": discovered_modules,
+                    "server_sync": server_sync_status,
+                    "server_message": server_message,
+                    "created_ticket_keys": created_tickets,
+                }
+            )
+        )
+        return 0
+
+    if args.command == "token":
+        new_token = (args.value or "").strip()
+        if new_token:
+            updated_cfg = WorkspaceConfig(
+                project_slug=existing_cfg.project_slug,
+                api_base_url=existing_cfg.api_base_url,
+                machine_label=existing_cfg.machine_label,
+                root_fingerprint=existing_cfg.root_fingerprint,
+                active_ticket_key=existing_cfg.active_ticket_key,
+                api_token=new_token,
+                secret_blocklist=existing_cfg.secret_blocklist,
+            )
+            save_workspace_config(workspace_root, updated_cfg)
+            masked = f"{new_token[:6]}...{new_token[-4:]}" if len(new_token) > 10 else "***"
+            print(
+                json.dumps(
+                    {
+                        "status": "token_saved",
+                        "message": (
+                            f"Token API berhasil disimpan ke .rakit/workspace.json ({masked})."
+                        ),
+                        "workspace": str(workspace_root),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return 0
+
+        effective_tok = get_effective_api_token(existing_cfg)
+        if effective_tok:
+            masked = (
+                f"{effective_tok[:6]}...{effective_tok[-4:]}" if len(effective_tok) > 10 else "***"
+            )
+            src = "RAKIT_API_TOKEN (env)" if os.getenv("RAKIT_API_TOKEN") else "workspace.json"
+            print(
+                json.dumps(
+                    {
+                        "status": "token_configured",
+                        "masked_token": masked,
+                        "source": src,
+                        "help": "Untuk mengganti: rakit token <TOKEN_BARU>",
+                    },
+                    ensure_ascii=False,
+                )
+            )
+        else:
+            print(
+                json.dumps(
+                    {
+                        "status": "token_missing",
+                        "message": "Token API RAKIT belum tersimpan di folder ini.",
+                        "action": (
+                            "Salin token di http://localhost:8000/accounts/profile/ "
+                            "lalu jalankan: rakit token <TOKEN>"
+                        ),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+        return 0
+
+    if args.command == "prompt":
+        target_key = (
+            (args.ticket_key or "").strip() or (existing_cfg.active_ticket_key or "").strip()
+        )
+        if not target_key:
+            print(
+                json.dumps(
+                    {
+                        "status": "error",
+                        "error": "NO_ACTIVE_TICKET",
+                        "message": (
+                            "Tidak ada tiket aktif yang dipilih. "
+                            "Tentukan kunci tiket: rakit prompt <KEY>, misal: rakit prompt QA-031"
+                        ),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return 1
+
+        prompt_file = fetch_and_write_prompt(workspace_root, existing_cfg, target_key)
+        if args.ticket_key and args.ticket_key != existing_cfg.active_ticket_key:
+            updated_cfg = WorkspaceConfig(
+                project_slug=existing_cfg.project_slug,
+                api_base_url=existing_cfg.api_base_url,
+                machine_label=existing_cfg.machine_label,
+                root_fingerprint=existing_cfg.root_fingerprint,
+                active_ticket_key=target_key,
+                api_token=existing_cfg.api_token,
+                secret_blocklist=existing_cfg.secret_blocklist,
+            )
+            save_workspace_config(workspace_root, updated_cfg)
+
+        print(
+            json.dumps(
+                {
+                    "status": "prompt_ready",
+                    "ticket_key": target_key,
+                    "prompt_file": prompt_file.as_posix() if prompt_file else "",
+                    "message": (
+                        f"Berkas instruksi kerja .rakit/PROMPT.md "
+                        f"untuk [{target_key}] berhasil dibuat."
+                    ),
+                },
+                ensure_ascii=False,
+            )
+        )
+        return 0
+
+    if args.command == "start":
+        updated_cfg = WorkspaceConfig(
+            project_slug=existing_cfg.project_slug,
+            api_base_url=existing_cfg.api_base_url,
+            machine_label=existing_cfg.machine_label,
+            root_fingerprint=existing_cfg.root_fingerprint,
+            active_ticket_key=args.ticket_key,
+            api_token=existing_cfg.api_token,
+            secret_blocklist=existing_cfg.secret_blocklist,
+        )
+        save_workspace_config(workspace_root, updated_cfg)
+
+        token = get_effective_api_token(existing_cfg)
+        server_claim_status = "saved_locally_offline"
+        auth_hint = ""
+        if existing_cfg.api_base_url:
+            try:
+                import urllib.error
+                import urllib.request
+
+                claim_url = f"{existing_cfg.api_base_url}/tickets/{args.ticket_key}/claim/"
+                claim_payload = json.dumps(
+                    {
+                        "holder_id": existing_cfg.machine_label or "notebook-cli",
+                        "holder_kind": "NOTEBOOK_CLI",
+                        "ttl_minutes": 30,
+                        "project_slug": existing_cfg.project_slug,
+                    }
+                ).encode("utf-8")
+                headers = {"Content-Type": "application/json"}
+                if token:
+                    headers["Authorization"] = f"Token {token}"
+                req = urllib.request.Request(
+                    claim_url, data=claim_payload, headers=headers, method="POST"
+                )
+                with urllib.request.urlopen(req, timeout=4) as resp:
+                    if resp.status in {200, 201}:
+                        server_claim_status = "claimed_on_server"
+                        raw_claim = json.loads(resp.read().decode("utf-8"))
+                        ticket_obj = (raw_claim.get("data") or {}).get("ticket") or {}
+                        if ticket_obj:
+                            write_active_task_prompt(workspace_root, ticket_obj)
+            except urllib.error.HTTPError as err:
+                if err.code in {401, 403}:
+                    server_claim_status = "unauthorized_401"
+                    auth_hint = (
+                        "Token API RAKIT belum tersimpan atau tidak valid. "
+                        "Salin token di http://localhost:8000/accounts/profile/ "
+                        "lalu jalankan: rakit token <TOKEN>"
+                    )
+                else:
+                    server_claim_status = f"http_{err.code}"
+            except Exception as e:
+                server_claim_status = f"offline_fallback: {e}"
+
+        result_payload: dict[str, Any] = {
+            "status": "active_ticket_bound",
+            "active_ticket_key": updated_cfg.active_ticket_key,
+            "server_claim_status": server_claim_status,
+        }
+        if auth_hint:
+            result_payload["auth_hint"] = auth_hint
+        print(json.dumps(result_payload, ensure_ascii=False))
+        return 0
+
+    if args.command == "sync":
+        tasks_file = workspace_root / "TASKS.md"
+        synced_done_count = 0
+        server_sync_status = "offline"
+
+        # US-037: Sinkronisasi dua arah dari tiket DONE di server ke TASKS.md lokal
+        if tasks_file.exists():
+            try:
+                import urllib.error
+                import urllib.request
+
+                comp_url = (
+                    f"{existing_cfg.api_base_url}/workspaces/completed-tasks/"
+                    f"?project_slug={existing_cfg.project_slug}"
+                )
+                req = urllib.request.Request(comp_url, method="GET")
+                with urllib.request.urlopen(req, timeout=3) as resp:
+                    if resp.status == 200:
+                        raw_json = json.loads(resp.read().decode("utf-8"))
+                        payload_data = (
+                            raw_json.get("data", {}) if isinstance(raw_json, dict) else {}
+                        )
+                        done_titles = (
+                            payload_data.get("completed_titles")
+                            or raw_json.get("completed_titles")
+                            or []
+                        )
+                        if done_titles:
+                            orig_md = tasks_file.read_text(encoding="utf-8")
+                            updated_md, synced_items = _sync_completed_to_markdown(
+                                orig_md, done_titles
+                            )
+                            if synced_items:
+                                tasks_file.write_text(updated_md, encoding="utf-8")
+                                synced_done_count = len(synced_items)
+
+                                # Beritahu server bahwa markdown lokal telah diperbarui
+                                sync_md_url = (
+                                    f"{existing_cfg.api_base_url}/workspaces/sync-tasks-md/"
+                                )
+                                sync_body = json.dumps(
+                                    {
+                                        "project_slug": existing_cfg.project_slug,
+                                        "tasks_markdown": updated_md,
+                                    }
+                                ).encode("utf-8")
+                                post_req = urllib.request.Request(
+                                    sync_md_url,
+                                    data=sync_body,
+                                    headers={"Content-Type": "application/json"},
+                                    method="POST",
+                                )
+                                try:
+                                    with urllib.request.urlopen(post_req, timeout=3):
+                                        pass
+                                except Exception:
+                                    pass
+                        server_sync_status = "synced"
+            except Exception:
+                server_sync_status = "offline"
+
+        tasks_info = (
+            parse_tasks_markdown(tasks_file.read_text(encoding="utf-8"))
+            if tasks_file.exists()
+            else parse_tasks_markdown("")
+        )
+        milestone_text = redact_sensitive_text(args.note or tasks_info.next_open_task)
+        raw_idem = (
+            f"{existing_cfg.project_slug}:{existing_cfg.active_ticket_key}:"
+            f"{tasks_info.completed_count}/{tasks_info.total_count}:{milestone_text}"
+        )
+        idempotency_key = hashlib.sha256(raw_idem.encode("utf-8")).hexdigest()[:32]
+        sync_payload = {
+            "project_slug": existing_cfg.project_slug,
+            "active_ticket_key": existing_cfg.active_ticket_key,
+            "tasks_completed": tasks_info.completed_count,
+            "tasks_total": tasks_info.total_count,
+            "progress_pct": tasks_info.progress_pct,
+            "milestone": milestone_text,
+            "idempotency_key": idempotency_key,
+            "synced_done_tasks": synced_done_count,
+            "server_sync_status": server_sync_status,
+        }
+        # Pastikan .rakit/PROMPT.md otomatis dibuat bila belum ada
+        prompt_path = workspace_root / ".rakit" / "PROMPT.md"
+        if existing_cfg.active_ticket_key and not prompt_path.exists():
+            fetch_and_write_prompt(
+                workspace_root, existing_cfg, existing_cfg.active_ticket_key
+            )
+
+        enqueue_offline_sync_event(workspace_root, sync_payload)
+
+        token = get_effective_api_token(existing_cfg)
+        progress_sync_status = "no_token"
+        if existing_cfg.active_ticket_key and existing_cfg.api_base_url and token:
+            progress_sync_status, _ = _post_json(
+                f"{existing_cfg.api_base_url}/workspaces/sync-progress/",
+                {
+                    "project_slug": existing_cfg.project_slug,
+                    "ticket_key": existing_cfg.active_ticket_key,
+                    "holder_id": existing_cfg.machine_label or "notebook-cli",
+                    "tasks_completed": tasks_info.completed_count,
+                    "tasks_total": tasks_info.total_count,
+                    "milestone": milestone_text[:240],
+                    "root_fingerprint": existing_cfg.root_fingerprint,
+                    "idempotency_key": idempotency_key,
+                },
+                token=token,
+                timeout=4,
+            )
+            if progress_sync_status == "synced_to_server":
+                sync_payload["server_sync_status"] = "synced"
+        sync_payload["progress_sync_status"] = progress_sync_status
+
+        print(json.dumps(sync_payload))
+        return 0
+
+    if args.command == "verify":
+        has_tasks = (workspace_root / "TASKS.md").exists()
+        if not has_tasks:
+            print(json.dumps({"status": "missing_tasks_md", "has_tasks_md": False}))
+            return 2
+
+        ticket_key = (getattr(args, "ticket", "") or existing_cfg.active_ticket_key or "").strip()
+        failed = bool(getattr(args, "failed", False))
+        raw_note = getattr(args, "note", "") or ""
+        verify_payload: dict[str, Any] = {
+            "status": "verification_failed" if failed else "ready_for_qa",
+            "has_tasks_md": True,
+            "ticket_key": ticket_key,
+        }
+
+        token = get_effective_api_token(existing_cfg)
+        if ticket_key and existing_cfg.api_base_url and token:
+            default_log = (
+                f"Verifikasi lokal notebook ({existing_cfg.machine_label or 'notebook-cli'}) "
+                f"untuk [{ticket_key}]: {'GAGAL' if failed else 'LULUS'}."
+            )
+            console_log = redact_sensitive_text(raw_note.strip() or default_log)[:20000]
+            srv_status, srv_body = _post_json(
+                f"{existing_cfg.api_base_url}/qa-uat/execute/",
+                {
+                    "project_slug": existing_cfg.project_slug,
+                    "ticket_key": ticket_key,
+                    "holder_id": existing_cfg.machine_label or "notebook-cli",
+                    "target_preview_url": "http://localhost:8000/",
+                    "simulate_pass": not failed,
+                    "console_errors_count": 1 if failed else 0,
+                    "server_5xx_count": 0,
+                    "console_log": console_log,
+                },
+                token=token,
+                timeout=8,
+            )
+            verify_payload["server_verify_status"] = srv_status
+            data_obj = srv_body.get("data") if isinstance(srv_body.get("data"), dict) else {}
+            ticket_obj = data_obj.get("ticket") if isinstance(data_obj.get("ticket"), dict) else {}
+            if ticket_obj.get("status"):
+                verify_payload["ticket_status"] = ticket_obj["status"]
+            if data_obj.get("run_id"):
+                verify_payload["run_id"] = data_obj["run_id"]
+            if srv_status.startswith("http_"):
+                verify_payload["server_message"] = srv_body.get("message", "")
+            elif not failed and getattr(args, "auto_close", False):
+                close_res = _close_ticket_on_server(
+                    workspace_root=workspace_root,
+                    cfg=existing_cfg,
+                    ticket_key=ticket_key,
+                    token=token,
+                    approve_g2=True,
+                    pr_url=getattr(args, "pr_url", "") or "",
+                    note=raw_note,
+                )
+                verify_payload["auto_close"] = close_res
+                if close_res.get("ticket_status"):
+                    verify_payload["ticket_status"] = close_res["ticket_status"]
+        elif ticket_key:
+            verify_payload["server_verify_status"] = "no_token"
+
+        print(json.dumps(verify_payload, ensure_ascii=False))
+        return 1 if failed else 0
+
+    if args.command == "close":
+        ticket_key = (
+            getattr(args, "ticket_flag", "")
+            or getattr(args, "ticket_key", "")
+            or existing_cfg.active_ticket_key
+            or ""
+        ).strip()
+        if not ticket_key:
+            print(
+                json.dumps(
+                    {
+                        "status": "missing_ticket_key",
+                        "message": (
+                            "Sertakan kunci tiket (mis. rakit close W-070) "
+                            "atau klaim tiket terlebih dahulu."
+                        ),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return 2
+
+        token = get_effective_api_token(existing_cfg)
+        if not (existing_cfg.api_base_url and token):
+            print(
+                json.dumps(
+                    {
+                        "status": "missing_auth",
+                        "ticket_key": ticket_key,
+                        "message": (
+                            "Token API atau URL server RAKIT belum terpasang "
+                            "di .rakit/workspace.json."
+                        ),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return 2
+
+        close_res = _close_ticket_on_server(
+            workspace_root=workspace_root,
+            cfg=existing_cfg,
+            ticket_key=ticket_key,
+            token=token,
+            approve_g2=bool(getattr(args, "approve_g2", False)),
+            pr_url=getattr(args, "pr_url", "") or "",
+            note=getattr(args, "note", "") or "",
+        )
+        print(json.dumps(close_res, ensure_ascii=False))
+        return 0 if close_res.get("status") == "closed" else 1
+
+    if args.command == "docs" and getattr(args, "docs_action", "") == "pull":
+        token = get_effective_api_token(existing_cfg)
+        if not (existing_cfg.api_base_url and token):
+            print(
+                json.dumps(
+                    {
+                        "status": "missing_auth",
+                        "message": (
+                            "Token API atau URL server RAKIT belum terpasang "
+                            "di .rakit/workspace.json."
+                        ),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return 2
+
+        bundle_url = (
+            f"{existing_cfg.api_base_url}/projects/{existing_cfg.project_slug}"
+            "/documentation-bundle/"
+        )
+        srv_status, srv_body = _get_json(bundle_url, token=token, timeout=10)
+        if srv_status != "synced_to_server":
+            print(
+                json.dumps(
+                    {
+                        "status": "docs_pull_failed",
+                        "server_status": srv_status,
+                        "server_message": srv_body.get("message", ""),
+                    },
+                    ensure_ascii=False,
+                )
+            )
+            return 1
+
+        data_obj = srv_body.get("data") if isinstance(srv_body.get("data"), dict) else {}
+        files_map = data_obj.get("files") if isinstance(data_obj.get("files"), dict) else {}
+        out_dir_raw = str(getattr(args, "out_dir", "docs") or "docs").strip()
+        out_dir = workspace_root / out_dir_raw
+        selected_raw = str(getattr(args, "only", "") or "").strip().lower()
+        selected_set = {p.strip() for p in selected_raw.split(",") if p.strip()}
+        overwrite = bool(getattr(args, "overwrite", False))
+        dry_run = bool(getattr(args, "dry_run", False))
+
+        targets = [
+            ("guide", "USER_GUIDE.md", out_dir / "USER_GUIDE.md"),
+            ("faq", "FAQ.md", out_dir / "FAQ.md"),
+            ("help", "HELP.md", out_dir / "HELP.md"),
+            (
+                "changelog",
+                "CHANGELOG.md",
+                (workspace_root / "CHANGELOG.md")
+                if out_dir_raw == "docs"
+                else (out_dir / "CHANGELOG.md"),
+            ),
+        ]
+        written: list[dict[str, str]] = []
+        for alias, api_key, target_path in targets:
+            if selected_set and alias not in selected_set:
+                continue
+            content = str(files_map.get(api_key) or "").strip()
+            if not content:
+                continue
+            action = _upsert_managed_doc_section(
+                target_path, content, overwrite=overwrite, dry_run=dry_run
+            )
+            written.append({"file": str(target_path), "action": action})
+
+        print(
+            json.dumps(
+                {
+                    "status": "docs_pulled",
+                    "project_slug": existing_cfg.project_slug,
+                    "drafts_count": data_obj.get("drafts_count", 0),
+                    "suggested_bump": data_obj.get("suggested_bump", "patch"),
+                    "chapters": data_obj.get("chapters", []),
+                    "dry_run": dry_run,
+                    "written": written,
+                },
+                ensure_ascii=False,
+            )
+        )
+        return 0
+
+    if args.command == "generate-guides":
+        safe_files = _scan_safe_files(workspace_root)
+        modules = _detect_local_modules(safe_files)
+        verification_cmds = _detect_verification_commands(workspace_root, safe_files)
+        modules_list = "\n".join(f"- `{m}`" for m in modules) if modules else "- `apps/core`"
+        agents_draft = (
+            f"# AGENTS.md — Kontrak Eksekusi {existing_cfg.project_slug}\n\n"
+            f"## Modul Terdeteksi\n{modules_list}\n\n"
+            f"## Aturan Keamanan\n"
+            f"- Dilarang membaca atau mengirim berkas `.env*`, `*.pem`, atau `*.key`.\n"
+        )
+        rakit_yaml_draft = (
+            f'version: 2\nproject:\n  slug: "{existing_cfg.project_slug}"\n'
+            f"security:\n  block_dotenv: true\n"
+            f"verification:\n"
+            f'  lint_command: "{verification_cmds["lint_command"]}"\n'
+            f'  test_command: "{verification_cmds["test_command"]}"\n'
+            f'  e2e_dir: "{verification_cmds["e2e_dir"]}"\n'
+            f'  e2e_command: "{verification_cmds["e2e_command"]}"\n'
+        )
+        if args.write:
+            rakit_dir = workspace_root / ".rakit"
+            rakit_dir.mkdir(parents=True, exist_ok=True)
+            (rakit_dir / "AGENTS.draft.md").write_text(agents_draft, encoding="utf-8")
+            (rakit_dir / "rakit.draft.yaml").write_text(rakit_yaml_draft, encoding="utf-8")
+
+        print(
+            json.dumps(
+                {
+                    "status": "guides_generated",
+                    "project_slug": existing_cfg.project_slug,
+                    "agents_md": agents_draft,
+                    "rakit_yaml": rakit_yaml_draft,
+                }
+            )
+        )
+        return 0
+
+    if args.command == "install-hook":
+        hooks_dir = workspace_root / ".git" / "hooks"
+        hooks_dir.mkdir(parents=True, exist_ok=True)
+        hook_file = hooks_dir / "post-commit"
+        hook_script = (
+            "#!/bin/sh\n"
+            "# RAKIT v2.0 automatic post-commit progress sync (US-011)\n"
+            "rakit sync || true\n"
+        )
+        hook_file.write_text(hook_script, encoding="utf-8")
+        print(
+            json.dumps(
+                {
+                    "status": "hook_installed",
+                    "hook_path": hook_file.as_posix(),
+                }
+            )
+        )
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())