claude-controller 0.1.2 → 0.3.0

package/bin/ctl

@@ -0,0 +1,1189 @@
+#!/usr/bin/env python3
+"""
+ctl — Controller CLI
+
+웹 대시보드의 모든 기능을 커맨드라인에서 사용할 수 있는 인터페이스.
+Claude Code AI가 Bash 도구로 직접 호출하여 작업을 관리할 수 있다.
+
+Usage:
+  ctl status                                    서비스 상태 확인
+  ctl send "prompt" [--cwd PATH] [--session ID] 프롬프트 전송
+  ctl jobs                                      작업 목록 조회
+  ctl jobs purge                                완료된 작업 일괄 삭제
+  ctl job <id>                                  작업 결과 조회
+  ctl job <id> stream [--offset N]              스트림 이벤트 조회
+  ctl job <id> checkpoints                      체크포인트 목록
+  ctl job <id> rewind <hash> "prompt"           체크포인트 되감기
+  ctl job <id> delete                           작업 삭제
+  ctl sessions [--cwd PATH]                     세션 목록 조회
+  ctl config                                    설정 조회
+  ctl config set <key> <value>                  설정 변경
+  ctl service start                             서비스 시작
+  ctl service stop                              서비스 종료
+  ctl dirs [PATH]                               디렉토리 탐색
+  ctl mkdir <parent> <name>                     디렉토리 생성
+  ctl upload <file>                             파일 업로드
+  ctl project list                              프로젝트 목록
+  ctl project add <path> [--name N]             기존 프로젝트 등록
+  ctl project create <path> [--name N]          신규 프로젝트 생성
+  ctl project info <id>                         프로젝트 상세
+  ctl project remove <id>                       프로젝트 제거
+  ctl project update <id> [--name N] [--desc D] 프로젝트 수정
+  ctl pipeline list                                파이프라인 목록
+  ctl pipeline create -p <프로젝트> -c "명령어" [-i 5m]  파이프라인 생성
+  ctl pipeline status --id <id>                   파이프라인 상태
+  ctl pipeline run --id <id> [--force]            실행/강제 실행
+  ctl pipeline tick                               모든 활성 파이프라인 진행
+  ctl pipeline reset --id <id>                    상태 초기화
+  ctl pipeline delete --id <id>                   파이프라인 삭제
+  ctl summary                                     전체 상태 요약 (AI 컨텍스트용)
+  ctl stats [--limit N]                           작업 통계 집계
+  ctl health                                      헬스체크 + 디스크 + stuck 작업
+  ctl watchdog [start|stop|status|install|uninstall] 프로세스 워치독 관리
+  ctl job <id> text                               최종 텍스트 결과만 추출
+
+Output: 기본 JSON. --pretty 플래그로 포맷팅된 출력.
+"""
+
+import argparse
+import base64
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+# ── 경로 설정 ──
+CONTROLLER_DIR = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(CONTROLLER_DIR / "web"))
+
+from config import (
+    LOGS_DIR, UPLOADS_DIR, DATA_DIR,
+    RECENT_DIRS_FILE, SETTINGS_FILE, SESSIONS_DIR,
+    CLAUDE_PROJECTS_DIR, FIFO_PATH,
+)
+from jobs import get_all_jobs, get_job_result, send_to_fifo, start_controller_service, stop_controller_service
+from checkpoint import get_job_checkpoints, rewind_job
+from utils import parse_meta_file, is_service_running, cwd_to_project_dir, scan_claude_sessions
+from projects import list_projects, get_project, add_project, create_project, remove_project, update_project
+from pipeline import (
+    list_pipelines, get_pipeline_status, create_pipeline, delete_pipeline,
+    run_next, force_run, reset_phase, tick, tick_all,
+)
+import shutil
+
+
+# ══════════════════════════════════════════════════════════════
+#  출력 헬퍼
+# ══════════════════════════════════════════════════════════════
+
+def out(data, pretty=False):
+    """JSON 출력. pretty=True면 들여쓰기."""
+    indent = 2 if pretty else None
+    print(json.dumps(data, ensure_ascii=False, indent=indent))
+
+
+def err(message, code=1):
+    """에러 출력 후 종료."""
+    print(json.dumps({"error": message}, ensure_ascii=False), file=sys.stderr)
+    sys.exit(code)
+
+
+# ══════════════════════════════════════════════════════════════
+#  명령어 핸들러
+# ══════════════════════════════════════════════════════════════
+
+def cmd_status(args):
+    """서비스 상태 확인."""
+    running, pid = is_service_running()
+    out({"running": running, "pid": pid}, args.pretty)
+
+
+def cmd_send(args):
+    """프롬프트 전송."""
+    prompt = args.prompt
+    if not prompt:
+        err("프롬프트를 입력하세요")
+
+    images = None
+    if args.image:
+        images = []
+        for img_path in args.image:
+            p = Path(img_path).resolve()
+            if not p.exists():
+                err(f"파일을 찾을 수 없습니다: {img_path}")
+            images.append(str(p))
+
+    session = None
+    if args.session:
+        session = {"id": args.session, "mode": args.mode or "resume"}
+
+    result, error = send_to_fifo(
+        prompt,
+        cwd=args.cwd or os.getcwd(),
+        job_id=args.id or None,
+        images=images,
+        session=session,
+    )
+    if error:
+        err(error)
+    out(result, args.pretty)
+
+
+def cmd_jobs(args):
+    """작업 목록 또는 일괄 삭제."""
+    if args.action == "purge":
+        deleted = []
+        for mf in list(LOGS_DIR.glob("job_*.meta")):
+            meta = parse_meta_file(mf)
+            if not meta:
+                continue
+            status = meta.get("STATUS", "")
+            if status in ("done", "failed"):
+                job_id = meta.get("JOB_ID", "")
+                out_file = LOGS_DIR / f"job_{job_id}.out"
+                try:
+                    mf.unlink()
+                    if out_file.exists():
+                        out_file.unlink()
+                    deleted.append(job_id)
+                except OSError:
+                    pass
+        out({"deleted": deleted, "count": len(deleted)}, args.pretty)
+    else:
+        jobs = get_all_jobs()
+        out(jobs, args.pretty)
+
+
+def cmd_job(args):
+    """단일 작업 조작 (결과/스트림/체크포인트/되감기/삭제)."""
+    job_id = args.job_id
+
+    # ── delete ──
+    if args.action == "delete":
+        meta_file = LOGS_DIR / f"job_{job_id}.meta"
+        out_file = LOGS_DIR / f"job_{job_id}.out"
+        if not meta_file.exists():
+            err("작업을 찾을 수 없습니다")
+        meta = parse_meta_file(meta_file)
+        if meta.get("STATUS") == "running" and meta.get("PID"):
+            try:
+                os.kill(int(meta["PID"]), 0)
+                err("실행 중인 작업은 삭제할 수 없습니다")
+            except (ProcessLookupError, ValueError, OSError):
+                pass
+        try:
+            meta_file.unlink()
+            if out_file.exists():
+                out_file.unlink()
+            out({"deleted": True, "job_id": job_id}, args.pretty)
+        except OSError as e:
+            err(f"삭제 실패: {e}")
+
+    # ── stream ──
+    elif args.action == "stream":
+        out_file = LOGS_DIR / f"job_{job_id}.out"
+        meta_file = LOGS_DIR / f"job_{job_id}.meta"
+        if not meta_file.exists():
+            err("작업을 찾을 수 없습니다")
+        if not out_file.exists():
+            out({"events": [], "offset": 0, "done": False}, args.pretty)
+            return
+
+        offset = args.offset or 0
+        events = []
+        try:
+            with open(out_file, "r") as f:
+                f.seek(offset)
+                for raw_line in f:
+                    if '"type":"assistant"' not in raw_line and '"type":"result"' not in raw_line:
+                        continue
+                    try:
+                        evt = json.loads(raw_line)
+                        evt_type = evt.get("type", "")
+                        if evt_type == "assistant":
+                            msg = evt.get("message", {})
+                            content = msg.get("content", [])
+                            text_parts = [c.get("text", "") for c in content if c.get("type") == "text"]
+                            if text_parts:
+                                events.append({"type": "text", "text": "".join(text_parts)})
+                            for tp in content:
+                                if tp.get("type") == "tool_use":
+                                    events.append({
+                                        "type": "tool_use",
+                                        "tool": tp.get("name", ""),
+                                        "input": str(tp.get("input", ""))[:200],
+                                    })
+                        elif evt_type == "result":
+                            events.append({
+                                "type": "result",
+                                "result": evt.get("result", ""),
+                                "cost_usd": evt.get("total_cost_usd"),
+                                "duration_ms": evt.get("duration_ms"),
+                                "is_error": evt.get("is_error", False),
+                                "session_id": evt.get("session_id", ""),
+                            })
+                    except json.JSONDecodeError:
+                        continue
+                new_offset = f.tell()
+        except OSError as e:
+            err(f"스트림 읽기 실패: {e}")
+
+        meta = parse_meta_file(meta_file)
+        done = meta.get("STATUS", "") in ("done", "failed")
+        out({"events": events, "offset": new_offset, "done": done}, args.pretty)
+
+    # ── checkpoints ──
+    elif args.action == "checkpoints":
+        checkpoints, error = get_job_checkpoints(job_id)
+        if error:
+            err(error)
+        out(checkpoints, args.pretty)
+
+    # ── rewind ──
+    elif args.action == "rewind":
+        if not args.checkpoint:
+            err("--checkpoint 해시가 필요합니다")
+        if not args.prompt:
+            err("--prompt 가 필요합니다")
+        result, error = rewind_job(job_id, args.checkpoint, args.prompt)
+        if error:
+            err(error)
+        out(result, args.pretty)
+
+    # ── text (최종 텍스트만) ──
+    elif args.action == "text":
+        cmd_job_text(job_id, args.pretty, raw=getattr(args, "raw", False))
+        return
+
+    # ── 기본: 결과 조회 ──
+    else:
+        result, error = get_job_result(job_id)
+        if error:
+            err(error)
+        out(result, args.pretty)
+
+
+def cmd_sessions(args):
+    """세션 목록 조회."""
+    seen = {}
+    filter_cwd = args.cwd
+
+    if filter_cwd:
+        proj_name = cwd_to_project_dir(filter_cwd)
+        project_dirs = [CLAUDE_PROJECTS_DIR / proj_name]
+    else:
+        if CLAUDE_PROJECTS_DIR.exists():
+            all_dirs = sorted(
+                (d for d in CLAUDE_PROJECTS_DIR.iterdir() if d.is_dir()),
+                key=lambda d: d.stat().st_mtime,
+                reverse=True,
+            )
+            project_dirs = all_dirs[:15]
+        else:
+            project_dirs = []
+
+    for pd in project_dirs:
+        native = scan_claude_sessions(pd, limit=60)
+        for sid, info in native.items():
+            if sid not in seen:
+                seen[sid] = info
+
+    # Job meta 파일에서 보강
+    if LOGS_DIR.exists():
+        meta_files = sorted(
+            LOGS_DIR.glob("job_*.meta"),
+            key=lambda f: int(f.stem.split("_")[1]),
+            reverse=True,
+        )
+        for mf in meta_files:
+            meta = parse_meta_file(mf)
+            if not meta:
+                continue
+            sid = meta.get("SESSION_ID", "").strip()
+            if not sid:
+                continue
+            status = meta.get("STATUS", "unknown")
+            if status == "running" and meta.get("PID"):
+                try:
+                    os.kill(int(meta["PID"]), 0)
+                except (ProcessLookupError, ValueError, OSError):
+                    status = "done"
+
+            job_id = meta.get("JOB_ID", "")
+            entry = {
+                "session_id": sid,
+                "job_id": job_id,
+                "prompt": meta.get("PROMPT", ""),
+                "timestamp": meta.get("CREATED_AT", ""),
+                "status": status,
+                "cwd": meta.get("CWD", ""),
+            }
+            if sid not in seen:
+                seen[sid] = entry
+            else:
+                existing = seen[sid]
+                if existing.get("job_id") is None:
+                    existing.update({"job_id": job_id, "status": status})
+
+    # history.log 보충
+    history_file = SESSIONS_DIR / "history.log"
+    if history_file.exists():
+        try:
+            for line in history_file.read_text("utf-8").strip().split("\n"):
+                parts = line.split("|", 2)
+                if len(parts) >= 2:
+                    ts, sid = parts[0].strip(), parts[1].strip()
+                    if not sid or sid in seen:
+                        continue
+                    prompt = parts[2].strip() if len(parts) > 2 else ""
+                    seen[sid] = {
+                        "session_id": sid, "job_id": None,
+                        "prompt": prompt, "timestamp": ts,
+                        "status": "done", "cwd": None,
+                    }
+        except OSError:
+            pass
+
+    # cwd 필터
+    if filter_cwd:
+        norm = os.path.normpath(filter_cwd)
+        seen = {
+            sid: s for sid, s in seen.items()
+            if s.get("cwd") and os.path.normpath(s["cwd"]) == norm
+        }
+
+    sessions = sorted(seen.values(), key=lambda s: s.get("timestamp") or "", reverse=True)
+    out(sessions[:50], args.pretty)
+
+
+def cmd_config(args):
+    """설정 조회 또는 변경."""
+    defaults = {
+        "skip_permissions": False,
+        "allowed_tools": "Bash,Read,Write,Edit,Glob,Grep,Agent,NotebookEdit,WebFetch,WebSearch",
+        "model": "",
+        "max_jobs": 10,
+        "append_system_prompt": "",
+        "target_repo": "",
+        "base_branch": "main",
+        "checkpoint_interval": 5,
+        "locale": "ko",
+    }
+
+    try:
+        if SETTINGS_FILE.exists():
+            saved = json.loads(SETTINGS_FILE.read_text("utf-8"))
+            defaults.update(saved)
+    except (json.JSONDecodeError, OSError):
+        pass
+
+    if args.action == "set":
+        if not args.key or args.value is None:
+            err("key와 value가 필요합니다")
+
+        key = args.key
+        value = args.value
+        allowed_keys = {
+            "skip_permissions", "allowed_tools", "model", "max_jobs",
+            "append_system_prompt", "target_repo", "base_branch",
+            "checkpoint_interval", "locale",
+        }
+        if key not in allowed_keys:
+            err(f"허용되지 않는 설정 키: {key}. 허용: {', '.join(sorted(allowed_keys))}")
+
+        # 타입 변환
+        if value.lower() in ("true", "false"):
+            value = value.lower() == "true"
+        else:
+            try:
+                value = int(value)
+            except ValueError:
+                pass
+
+        defaults[key] = value
+        try:
+            DATA_DIR.mkdir(parents=True, exist_ok=True)
+            SETTINGS_FILE.write_text(
+                json.dumps(defaults, ensure_ascii=False, indent=2), "utf-8"
+            )
+            out({"ok": True, "config": defaults}, args.pretty)
+        except OSError as e:
+            err(f"설정 저장 실패: {e}")
+    else:
+        out(defaults, args.pretty)
+
+
+def cmd_service(args):
+    """서비스 시작/종료."""
+    if args.action == "start":
+        ok, pid = start_controller_service()
+        if ok:
+            out({"started": True, "pid": pid}, args.pretty)
+        else:
+            err("서비스 시작 실패")
+    elif args.action == "stop":
+        ok, error = stop_controller_service()
+        if ok:
+            out({"stopped": True}, args.pretty)
+        else:
+            err(error or "서비스 종료 실패")
+    else:
+        err(f"알 수 없는 서비스 액션: {args.action}")
+
+
+def cmd_dirs(args):
+    """디렉토리 탐색."""
+    dir_path = os.path.abspath(os.path.expanduser(args.path or os.getcwd()))
+    if not os.path.isdir(dir_path):
+        err("디렉토리가 아닙니다")
+
+    entries = []
+    try:
+        items = sorted(os.listdir(dir_path))
+    except PermissionError:
+        err("접근 권한 없음")
+
+    parent = os.path.dirname(dir_path)
+    if parent != dir_path:
+        entries.append({"name": "..", "path": parent, "type": "dir"})
+
+    for item in items:
+        if item.startswith("."):
+            continue
+        full = os.path.join(dir_path, item)
+        entry = {"name": item, "path": full}
+        if os.path.isdir(full):
+            entry["type"] = "dir"
+        else:
+            entry["type"] = "file"
+            try:
+                entry["size"] = os.path.getsize(full)
+            except OSError:
+                entry["size"] = 0
+        entries.append(entry)
+
+    out({"current": dir_path, "entries": entries}, args.pretty)
+
+
+def cmd_mkdir(args):
+    """디렉토리 생성."""
+    parent = args.parent
+    name = args.name
+
+    if "/" in name or "\\" in name or name in (".", ".."):
+        err("잘못된 디렉토리 이름입니다")
+
+    parent = os.path.abspath(os.path.expanduser(parent))
+    if not os.path.isdir(parent):
+        err("상위 디렉토리가 존재하지 않습니다")
+
+    new_dir = os.path.join(parent, name)
+    if os.path.exists(new_dir):
+        err("이미 존재하는 이름입니다")
+
+    try:
+        os.makedirs(new_dir)
+        out({"ok": True, "path": new_dir}, args.pretty)
+    except PermissionError:
+        err("접근 권한 없음")
+    except OSError as e:
+        err(f"디렉토리 생성 실패: {e}")
+
+
+def cmd_upload(args):
+    """파일 업로드."""
+    file_path = Path(args.file).resolve()
+    if not file_path.exists():
+        err(f"파일을 찾을 수 없습니다: {args.file}")
+
+    IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"}
+    ext = file_path.suffix.lower()
+    prefix = "img" if ext in IMAGE_EXTS else "file"
+    safe_name = f"{prefix}_{int(time.time())}_{os.getpid()}_{id(file_path) % 10000}{ext}"
+
+    UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
+    dest = UPLOADS_DIR / safe_name
+
+    try:
+        raw = file_path.read_bytes()
+        dest.write_bytes(raw)
+        out({
+            "path": str(dest),
+            "filename": safe_name,
+            "originalName": file_path.name,
+            "size": len(raw),
+            "isImage": ext in IMAGE_EXTS,
+        }, args.pretty)
+    except OSError as e:
+        err(f"업로드 실패: {e}")
+
+
+def cmd_project(args):
+    """프로젝트 관리."""
+    action = args.action
+
+    if action == "list" or action is None:
+        out(list_projects(), args.pretty)
+
+    elif action == "add":
+        if not args.path:
+            err("경로를 지정하세요")
+        project, error = add_project(
+            args.path,
+            name=args.name or "",
+            description=args.desc or "",
+        )
+        if error:
+            err(error)
+        out(project, args.pretty)
+
+    elif action == "create":
+        if not args.path:
+            err("경로를 지정하세요")
+        project, error = create_project(
+            args.path,
+            name=args.name or "",
+            description=args.desc or "",
+            init_git=not args.no_git,
+        )
+        if error:
+            err(error)
+        out(project, args.pretty)
+
+    elif action == "info":
+        if not args.id:
+            err("프로젝트 ID를 지정하세요")
+        project, error = get_project(args.id)
+        if error:
+            err(error)
+        out(project, args.pretty)
+
+    elif action == "remove":
+        if not args.id:
+            err("프로젝트 ID를 지정하세요")
+        result, error = remove_project(args.id)
+        if error:
+            err(error)
+        out({"removed": True, "project": result}, args.pretty)
+
+    elif action == "update":
+        if not args.id:
+            err("프로젝트 ID를 지정하세요")
+        project, error = update_project(
+            args.id,
+            name=args.name,
+            description=args.desc,
+        )
+        if error:
+            err(error)
+        out(project, args.pretty)
+
+
+def _resolve_project_path(args) -> str:
+    """--project (이름/ID) 또는 path에서 프로젝트 경로를 찾는다."""
+    projects = list_projects()
+
+    # --project 옵션: 이름 또는 ID로 검색
+    key = getattr(args, "project", None)
+    if key:
+        for p in projects:
+            if p["id"] == key or p.get("name", "").lower() == key.lower():
+                return p["path"]
+        # 부분 매칭 시도
+        for p in projects:
+            if key.lower() in p.get("name", "").lower():
+                return p["path"]
+        err(f"프로젝트를 찾을 수 없습니다: '{key}'\n"
+            f"등록된 프로젝트: {', '.join(p['name'] for p in projects) or '(없음)'}\n"
+            f"ctl project add <경로> 로 먼저 등록하세요")
+
+    # path 직접 지정 (하위 호환)
+    if getattr(args, "path", None):
+        return args.path
+
+    # 둘 다 없으면 목록 안내
+    if not projects:
+        err("등록된 프로젝트가 없습니다.\n"
+            "ctl project add <경로> --name <이름>  으로 프로젝트를 등록하세요")
+    lines = ["--project 로 프로젝트를 선택하세요:", ""]
+    for p in projects:
+        lines.append(f"  {p['name']:<20s}  {p['id']}")
+    lines.append("")
+    lines.append("예: ctl pipeline create --project <이름> --goal \"...\"")
+    err("\n".join(lines))
+
+
+def _tick_all_human(results: list[dict]) -> str:
+    """tick-all 결과를 사람이 읽기 좋은 한 줄 요약으로 변환."""
+    if not results:
+        return "활성 파이프라인 없음"
+    lines = []
+    for r in results:
+        name = r.get("name", r["pipeline_id"])
+        phase = r.get("phase", "?")
+        if r.get("error"):
+            lines.append(f"  ✗ {name} [{phase}] {r['error']}")
+        elif r.get("result"):
+            action = r["result"].get("action", "")
+            msg = r["result"].get("message", action)
+            lines.append(f"  → {name} [{phase}] {msg}")
+        else:
+            lines.append(f"  - {name} [{phase}]")
+    return "\n".join(lines)
+
+
+def cmd_pipeline(args):
+    """파이프라인 관리 및 실행."""
+    action = args.action
+
+    if action == "list" or action is None:
+        pipes = list_pipelines()
+        if not args.pretty and not pipes:
+            print("[]")
+            return
+        if args.pretty:
+            # 사람 친화적 목록
+            if not pipes:
+                print("등록된 파이프라인이 없습니다.")
+                return
+            for p in pipes:
+                status_label = {"done": "완료", "running": "실행중", "failed": "실패", "idle": "대기"}.get(p.get("status", ""), p.get("status", ""))
+                interval_label = f"  [{p['interval']}]" if p.get("interval") else ""
+                print(f"  {p['id']}  [{status_label:<6s}]{interval_label}  {p.get('name', '')}")
+                print(f"    명령: {(p.get('command', '') or '')[:60]}")
+            return
+        out(pipes, False)
+
+    elif action == "create":
+        project_path = _resolve_project_path(args)
+        command = args.cmd
+        if not command:
+            err("--cmd (-c) 로 명령어를 지정하세요\n"
+                "예: ctl pipeline create --project <이름> --cmd \"테스트 실행\" [--interval 5m]")
+        pipe, error = create_pipeline(
+            project_path,
+            command=command,
+            interval=args.interval or "",
+            name=args.name or "",
+        )
+        if error:
+            err(error)
+        out(pipe, args.pretty)
+
+    elif action == "status":
+        if not args.id:
+            err("파이프라인 ID를 지정하세요 (--id)")
+        result, error = get_pipeline_status(args.id)
+        if error:
+            err(error)
+        if args.pretty:
+            status_labels = {"done": "완료", "running": "실행 중", "failed": "실패", "idle": "대기"}
+            print(f"파이프라인: {result['name']}  [{status_labels.get(result['status'], result['status'])}]")
+            print(f"명령어: {result['command']}")
+            print(f"경로: {result['project_path']}")
+            if result.get("interval"):
+                print(f"간격: {result['interval']}")
+            print(f"실행 횟수: {result.get('run_count', 0)}")
+            if result.get("last_run"):
+                print(f"마지막 실행: {result['last_run']}")
+            if result.get("last_result"):
+                print(f"마지막 결과: {result['last_result'][:100]}")
+            if result.get("last_error"):
+                print(f"에러: {result['last_error']}")
+            if result.get("job_status"):
+                js = result["job_status"]
+                print(f"현재 작업: job#{js['job_id']} [{js.get('status', '?')}]")
+            return
+        out(result, False)
+
+    elif action == "run":
+        if not args.id:
+            err("파이프라인 ID를 지정하세요 (--id)")
+        if args.force:
+            result, error = force_run(args.id)
+        else:
+            result, error = run_next(args.id)
+        if error:
+            err(error)
+        out(result, args.pretty)
+
+    elif action == "tick":
+        if args.id:
+            result, error = tick(args.id)
+            if error:
+                err(error)
+            out(result, args.pretty)
+        else:
+            # --id 없으면 tick-all
+            results = tick_all()
+            if args.pretty:
+                print(_tick_all_human(results))
+            else:
+                out(results, False)
+
+    elif action == "tick-all":
+        results = tick_all()
+        if args.pretty:
+            print(_tick_all_human(results))
+        else:
+            out(results, False)
+
+    elif action == "reset":
+        if not args.id:
+            err("파이프라인 ID를 지정하세요 (--id)")
+        result, error = reset_phase(args.id, phase=args.phase)
+        if error:
+            err(error)
+        out(result, args.pretty)
+
+    elif action == "delete":
+        if not args.id:
+            err("파이프라인 ID를 지정하세요 (--id)")
+        result, error = delete_pipeline(args.id)
+        if error:
+            err(error)
+        out({"deleted": True, "pipeline": result}, args.pretty)
+
+    elif action == "evolution":
+        from pipeline import get_evolution_summary
+        summary = get_evolution_summary()
+        if args.pretty:
+            print(f"파이프라인 진화 요약")
+            print(f"  활성: {summary['active_count']}/{summary['total_pipelines']}")
+            print(f"  총 실행: {summary['total_runs']}회  |  총 비용: ${summary['total_cost_usd']}")
+            print(f"  효율성: {summary['efficiency_pct']}% (변경 있는 실행 비율)")
+            cls = summary["classifications"]
+            print(f"  분류: 변경있음={cls.get('has_change',0)} / 변경없음={cls.get('no_change',0)} / 불명={cls.get('unknown',0)}")
+            if summary["interval_adaptations"]:
+                print(f"  인터벌 적응:")
+                for ia in summary["interval_adaptations"]:
+                    print(f"    {ia['name']}: {ia['base_sec']}s → {ia['effective_sec']}s ({ia['change_pct']:+d}%)")
+        else:
+            out(summary, False)
+
+
+# ══════════════════════════════════════════════════════════════
+#  AI 컨텍스트 명령어 — summary, stats, health, job text
+# ══════════════════════════════════════════════════════════════
+
+def cmd_summary(args):
+    """서비스 + 최근 작업 + 파이프라인을 한 번에 요약."""
+    running, pid = is_service_running()
+
+    jobs = get_all_jobs()
+    total = len(jobs)
+    by_status = {}
+    recent_failures = []
+    total_cost = 0.0
+    running_jobs = []
+
+    for j in jobs:
+        st = j.get("status", "unknown")
+        by_status[st] = by_status.get(st, 0) + 1
+        if j.get("cost_usd"):
+            total_cost += j["cost_usd"]
+        if st == "running":
+            running_jobs.append({
+                "job_id": j["job_id"],
+                "prompt": (j.get("prompt") or "")[:80],
+                "cwd": j.get("cwd"),
+            })
+        if st == "failed":
+            recent_failures.append({
+                "job_id": j["job_id"],
+                "prompt": (j.get("prompt") or "")[:80],
+                "result": (j.get("result") or "")[:200],
+            })
+
+    done = by_status.get("done", 0)
+    failed = by_status.get("failed", 0)
+    success_rate = round(done / (done + failed), 3) if (done + failed) > 0 else None
+
+    # 파이프라인 요약
+    pipes = list_pipelines()
+    active_pipes = [
+        {"id": p["id"], "name": p.get("name", ""), "status": p.get("status", ""), "command": (p.get("command") or "")[:60]}
+        for p in pipes if p.get("status") in ("running", "idle")
+    ]
+
+    result = {
+        "service": {"running": running, "pid": pid},
+        "jobs": {
+            "total": total,
+            "by_status": by_status,
+            "success_rate": success_rate,
+            "total_cost_usd": round(total_cost, 4),
+            "running": running_jobs,
+            "recent_failures": recent_failures[:5],
+        },
+        "pipelines": {"total": len(pipes), "active": active_pipes},
+    }
+    out(result, args.pretty)
+
+
+def cmd_stats(args):
+    """작업 통계 집계 — 성공률, 비용, 소요시간, 에러 패턴."""
+    jobs = get_all_jobs()
+
+    # 기간 필터
+    limit = args.limit or len(jobs)
+    jobs = jobs[:limit]
+
+    total = len(jobs)
+    done_count = 0
+    failed_count = 0
+    costs = []
+    durations = []
+    error_patterns = {}
+
+    for j in jobs:
+        st = j.get("status", "unknown")
+        if st == "done":
+            done_count += 1
+        elif st == "failed":
+            failed_count += 1
+            # 에러 패턴 수집
+            result_text = (j.get("result") or "")[:300]
+            if result_text:
+                # 첫 줄을 패턴 키로 사용
+                key = result_text.split("\n")[0][:80]
+                error_patterns[key] = error_patterns.get(key, 0) + 1
+
+        if j.get("cost_usd"):
+            costs.append(j["cost_usd"])
+        if j.get("duration_ms"):
+            durations.append(j["duration_ms"])
+
+    completed = done_count + failed_count
+    result = {
+        "total_jobs": total,
+        "completed": completed,
+        "done": done_count,
+        "failed": failed_count,
+        "success_rate": round(done_count / completed, 3) if completed > 0 else None,
+        "cost": {
+            "total_usd": round(sum(costs), 4) if costs else 0,
+            "avg_usd": round(sum(costs) / len(costs), 4) if costs else None,
+            "max_usd": round(max(costs), 4) if costs else None,
+        },
+        "duration": {
+            "avg_ms": round(sum(durations) / len(durations)) if durations else None,
+            "median_ms": round(sorted(durations)[len(durations) // 2]) if durations else None,
+            "max_ms": max(durations) if durations else None,
+        },
+        "top_errors": dict(sorted(error_patterns.items(), key=lambda x: -x[1])[:5]),
+    }
+    out(result, args.pretty)
+
+
+def cmd_health(args):
+    """서비스 상태 + 디스크 사용량 + stuck 작업 + 고아 프로세스."""
+    running, pid = is_service_running()
+
+    # 디스크 사용량
+    def dir_size_mb(path):
+        total = 0
+        p = Path(path)
+        if not p.exists():
+            return 0
+        for f in p.rglob("*"):
+            if f.is_file():
+                total += f.stat().st_size
+        return round(total / (1024 * 1024), 2)
+
+    disk = {
+        "logs_mb": dir_size_mb(LOGS_DIR),
+        "uploads_mb": dir_size_mb(UPLOADS_DIR),
+        "worktrees_mb": dir_size_mb(CONTROLLER_DIR / "worktrees"),
+    }
+    total_disk = CONTROLLER_DIR.resolve()
+    usage = shutil.disk_usage(str(total_disk))
+    disk["system_free_gb"] = round(usage.free / (1024 ** 3), 2)
+
+    # Stuck 작업 (30분 이상 running)
+    jobs = get_all_jobs()
+    stuck = []
+    import datetime
+    now = datetime.datetime.now()
+    for j in jobs:
+        if j.get("status") != "running":
+            continue
+        created = j.get("created_at", "")
+        if not created:
+            continue
+        try:
+            started = datetime.datetime.strptime(created, "%Y-%m-%d %H:%M:%S")
+            elapsed_min = (now - started).total_seconds() / 60
+            if elapsed_min > 30:
+                stuck.append({
+                    "job_id": j["job_id"],
+                    "prompt": (j.get("prompt") or "")[:60],
+                    "elapsed_min": round(elapsed_min, 1),
+                })
+        except ValueError:
+            continue
+
+    # FIFO 상태
+    fifo_ok = FIFO_PATH.exists() and Path(FIFO_PATH).is_fifo() if hasattr(Path, 'is_fifo') else FIFO_PATH.exists()
+
+    result = {
+        "service": {"running": running, "pid": pid, "fifo_ok": fifo_ok},
+        "disk": disk,
+        "stuck_jobs": stuck,
+        "job_counts": {
+            "total": len(jobs),
+            "running": sum(1 for j in jobs if j.get("status") == "running"),
+        },
+    }
+    out(result, args.pretty)
+
+
+def cmd_watchdog(args):
+    """워치독 관리 — start/stop/status/install/uninstall."""
+    action = args.action or "status"
+    watchdog_sh = CONTROLLER_DIR / "bin" / "watchdog.sh"
+    state_file = CONTROLLER_DIR / "data" / "watchdog_state.json"
+    pid_file = CONTROLLER_DIR / "service" / "watchdog.pid"
+
+    if action in ("start", "stop", "install", "uninstall"):
+        import subprocess
+        result = subprocess.run(
+            ["bash", str(watchdog_sh), action],
+            capture_output=True, text=True
+        )
+        if result.stdout.strip():
+            if args.pretty:
+                out({"action": action, "message": result.stdout.strip()}, True)
+            else:
+                print(result.stdout.strip())
+        if result.returncode != 0 and result.stderr.strip():
+            print(result.stderr.strip(), file=sys.stderr)
+            sys.exit(result.returncode)
+    else:
+        # status — JSON 출력
+        running = False
+        pid = None
+        state = {}
+
+        if pid_file.exists():
+            try:
+                pid = int(pid_file.read_text().strip())
+                import signal
+                os.kill(pid, 0)
+                running = True
+            except (ValueError, OSError):
+                pid = None
+
+        if state_file.exists():
+            try:
+                state = json.loads(state_file.read_text())
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        out({
+            "running": running,
+            "pid": pid,
+            "status": state.get("status", "unknown"),
+            "restart_count": state.get("restart_count", 0),
+            "consecutive_fails": state.get("consecutive_fails", 0),
+            "last_restart": state.get("last_restart", ""),
+            "last_check": state.get("last_check", ""),
+            "message": state.get("message", ""),
+        }, args.pretty)
+
+
+def cmd_job_text(job_id, pretty=False, raw=False):
+    """작업의 최종 텍스트 결과만 추출 (이벤트 스트림 없이)."""
+    result, error = get_job_result(job_id)
+    if error:
+        err(error)
+
+    text = result.get("result") if result else None
+    if text is None:
+        # result 없으면 .out 에서 text 이벤트를 합산
+        out_file = LOGS_DIR / f"job_{job_id}.out"
+        if out_file.exists():
+            parts = []
+            try:
+                with open(out_file, "r") as f:
+                    for raw_line in f:
+                        if '"type":"assistant"' not in raw_line:
+                            continue
+                        try:
+                            evt = json.loads(raw_line)
+                            if evt.get("type") == "assistant":
+                                content = evt.get("message", {}).get("content", [])
+                                for c in content:
+                                    if c.get("type") == "text" and c.get("text"):
+                                        parts.append(c["text"])
+                        except json.JSONDecodeError:
+                            continue
+            except OSError:
+                pass
+            text = "\n".join(parts) if parts else None
+
+    if raw:
+        # --raw: JSON 래핑 없이 텍스트만 stdout에 출력
+        print(text or "")
+        return
+
+    out({
+        "job_id": job_id,
+        "status": result.get("status") if result else "unknown",
+        "text": text,
+        "cost_usd": result.get("cost_usd") if result else None,
+        "session_id": result.get("session_id") if result else None,
+    }, pretty)
+
+
+# ══════════════════════════════════════════════════════════════
+#  argparse 설정
+# ══════════════════════════════════════════════════════════════
+
+def build_parser():
+    # 공통 옵션을 모든 서브커맨드에 상속
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--pretty", action="store_true", help="JSON 출력 포맷팅")
+
+    parser = argparse.ArgumentParser(
+        prog="ctl",
+        description="Controller CLI — 웹 대시보드 기능을 커맨드라인에서 사용",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # ── status ──
+    sub.add_parser("status", parents=[common], help="서비스 상태 확인")
+
+    # ── send ──
+    p_send = sub.add_parser("send", parents=[common], help="프롬프트 전송")
+    p_send.add_argument("prompt", help="전송할 프롬프트")
+    p_send.add_argument("--cwd", help="작업 디렉토리")
+    p_send.add_argument("--id", help="사용자 지정 작업 ID")
+    p_send.add_argument("--session", help="기존 세션 ID (재개/포크)")
+    p_send.add_argument("--mode", choices=["resume", "fork", "new"], help="세션 모드")
+    p_send.add_argument("--image", action="append", help="첨부할 이미지 경로 (반복 가능)")
+
+    # ── jobs ──
+    p_jobs = sub.add_parser("jobs", parents=[common], help="작업 목록 조회")
+    p_jobs.add_argument("action", nargs="?", choices=["purge"], help="purge: 완료된 작업 삭제")
+
+    # ── job ──
+    p_job = sub.add_parser("job", parents=[common], help="단일 작업 조작")
+    p_job.add_argument("job_id", help="작업 ID")
+    p_job.add_argument("action", nargs="?",
+                       choices=["stream", "checkpoints", "rewind", "delete", "text"],
+                       help="수행할 작업 (생략 시 결과 조회, text: 최종 텍스트만)")
+    p_job.add_argument("--offset", type=int, default=0, help="스트림 오프셋 (stream용)")
+    p_job.add_argument("--checkpoint", help="체크포인트 해시 (rewind용)")
+    p_job.add_argument("--prompt", dest="prompt", help="리와인드 프롬프트 (rewind용)")
+    p_job.add_argument("--raw", action="store_true", help="텍스트만 출력 (text 액션용, JSON 래핑 없이)")
+
+    # ── sessions ──
+    p_sessions = sub.add_parser("sessions", parents=[common], help="세션 목록 조회")
+    p_sessions.add_argument("--cwd", help="CWD 필터")
+
+    # ── config ──
+    p_config = sub.add_parser("config", parents=[common], help="설정 조회/변경")
+    p_config.add_argument("action", nargs="?", choices=["set"], help="set: 설정 변경")
+    p_config.add_argument("key", nargs="?", help="설정 키")
+    p_config.add_argument("value", nargs="?", help="설정 값")
+
+    # ── service ──
+    p_service = sub.add_parser("service", parents=[common], help="서비스 시작/종료")
+    p_service.add_argument("action", choices=["start", "stop"], help="start 또는 stop")
+
+    # ── dirs ──
+    p_dirs = sub.add_parser("dirs", parents=[common], help="디렉토리 탐색")
+    p_dirs.add_argument("path", nargs="?", help="탐색할 경로 (기본: 현재 디렉토리)")
+
+    # ── mkdir ──
+    p_mkdir = sub.add_parser("mkdir", parents=[common], help="디렉토리 생성")
+    p_mkdir.add_argument("parent", help="상위 디렉토리 경로")
+    p_mkdir.add_argument("name", help="생성할 디렉토리 이름")
+
+    # ── upload ──
+    p_upload = sub.add_parser("upload", parents=[common], help="파일 업로드")
+    p_upload.add_argument("file", help="업로드할 파일 경로")
+
+    # ── project ──
+    p_proj = sub.add_parser("project", parents=[common], help="프로젝트 관리")
+    p_proj.add_argument("action", nargs="?",
+                        choices=["list", "add", "create", "info", "remove", "update"],
+                        help="수행할 작업 (생략 시 목록)")
+    p_proj.add_argument("path", nargs="?", help="프로젝트 경로 (add/create용)")
+    p_proj.add_argument("--id", help="프로젝트 ID (info/remove/update용)")
+    p_proj.add_argument("--name", help="프로젝트 이름")
+    p_proj.add_argument("--desc", help="프로젝트 설명")
+    p_proj.add_argument("--no-git", action="store_true", help="git init 건너뛰기 (create용)")
+
+    # ── summary (AI 컨텍스트) ──
+    sub.add_parser("summary", parents=[common], help="서비스 + 작업 + 파이프라인 전체 요약 (AI용)")
+
+    # ── stats ──
+    p_stats = sub.add_parser("stats", parents=[common], help="작업 통계 집계")
+    p_stats.add_argument("--limit", "-n", type=int, help="최근 N개 작업만 집계")
+
+    # ── health ──
+    sub.add_parser("health", parents=[common], help="서비스 헬스체크 + 디스크 + stuck 작업")
+
+    # ── watchdog ──
+    p_wd = sub.add_parser("watchdog", parents=[common], help="프로세스 워치독 관리")
+    p_wd.add_argument("action", nargs="?",
+                       choices=["start", "stop", "status", "install", "uninstall"],
+                       help="수행할 작업 (생략 시 status)")
+
+    # ── pipeline ──
+    p_pipe = sub.add_parser("pipeline", parents=[common], help="파이프라인 관리/실행")
+    p_pipe.add_argument("action", nargs="?",
+                        choices=["list", "create", "status", "run", "tick", "tick-all", "reset", "delete", "evolution"],
+                        help="수행할 작업 (생략 시 목록)")
+    p_pipe.add_argument("path", nargs="?", help="프로젝트 경로 (하위 호환)")
+    p_pipe.add_argument("--project", "-p", help="프로젝트 이름 또는 ID (create용)")
+    p_pipe.add_argument("--id", help="파이프라인 ID")
+    p_pipe.add_argument("--cmd", "-c", dest="cmd", help="Claude에게 전달할 명령어 (create용)")
+    p_pipe.add_argument("--interval", "-i", help="반복 간격 예: 5m, 1h (create용, 생략 시 1회)")
+    p_pipe.add_argument("--name", help="파이프라인 이름")
+    p_pipe.add_argument("--phase", help="초기화할 단계 (reset용)")
+    p_pipe.add_argument("--force", action="store_true", help="중복 체크 무시하고 강제 실행")
+
+    return parser
+
+
+# ══════════════════════════════════════════════════════════════
+#  메인
+# ══════════════════════════════════════════════════════════════
+
+DISPATCH = {
+    "status": cmd_status,
+    "send": cmd_send,
+    "jobs": cmd_jobs,
+    "job": cmd_job,
+    "sessions": cmd_sessions,
+    "config": cmd_config,
+    "service": cmd_service,
+    "dirs": cmd_dirs,
+    "mkdir": cmd_mkdir,
+    "upload": cmd_upload,
+    "project": cmd_project,
+    "pipeline": cmd_pipeline,
+    "summary": cmd_summary,
+    "stats": cmd_stats,
+    "health": cmd_health,
+    "watchdog": cmd_watchdog,
+}
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+    handler = DISPATCH.get(args.command)
+    if handler:
+        handler(args)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()