agent-coach-cli 0.1.0__py3-none-any.whl

agentcoach/collect.py

@@ -0,0 +1,336 @@
+"""Read local Claude Code and Codex CLI transcripts into a common shape.
+
+Only the human side matters for coaching, so a Session keeps the user's
+prompts verbatim and squeezes everything the agent did between them into a
+one-line summary (tool counts + a short excerpt of its last reply).
+"""
+from __future__ import annotations
+
+import glob
+import json
+import os
+import re
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable, Iterator
+
+from .paths import coach_home
+
+
+@dataclass
+class Turn:
+    index: int
+    text: str
+    ts: str = ""
+    images: int = 0
+    slash: str = ""           # e.g. "/clear" when the turn was a slash command
+    agent_after: str = ""     # summary of what the agent did before the next human turn
+
+
+@dataclass
+class Session:
+    source: str               # "claude" | "codex"
+    id: str
+    project: str
+    path: str
+    started: str
+    ended: str
+    turns: list[Turn] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+# ---------------------------------------------------------------- helpers
+
+_NOISE_PREFIXES = (
+    "<local-command-", "<command-message>", "<task-notification", "<system-reminder",
+    "<side-sessions-event", "<ci-monitor-event", "Caveat:", "[Request interrupted",
+    "<environment_context>", "<user_instructions>", "# AGENTS.md", "<permissions",
+    "<turn_aborted>", "<user_shell_command>", "<subagent_notification", "<image",
+    "This session is being continued from a previous conversation",  # auto compaction summary
+    "<artifact-view-context", "<ide_", "<bash-input>", "<bash-stdout>",
+)
+_SLASH_RE = re.compile(r"<command-name>\s*(/[\w:-]+)\s*</command-name>")
+_ARGS_RE = re.compile(r"<command-args>(.*?)</command-args>", re.S)
+
+
+def _parse_ts(s: str) -> datetime | None:
+    if not s:
+        return None
+    try:
+        return datetime.fromisoformat(s.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def _summarize_agent(tools: dict[str, int], last_text: str) -> str:
+    parts = []
+    if tools:
+        top = sorted(tools.items(), key=lambda kv: -kv[1])[:5]
+        parts.append("tools: " + ", ".join(f"{k}x{v}" for k, v in top))
+    if last_text:
+        t = " ".join(last_text.split())
+        parts.append("reply: " + (t[:280] + "…" if len(t) > 280 else t))
+    return " | ".join(parts)
+
+
+def _is_temp_project(dirname: str) -> bool:
+    low = dirname.lower()
+    return "-temp-" in low or "appdata-local-temp" in low or "agent-coach-judge" in low
+
+
+# ---------------------------------------------------------------- Claude Code
+
+def claude_root() -> Path:
+    return Path(os.environ.get("CLAUDE_CONFIG_DIR", Path.home() / ".claude")) / "projects"
+
+
+def _claude_human_text(d: dict) -> tuple[str, int] | None:
+    """Return (text, image_count) when this record is a prompt a human typed."""
+    if d.get("type") != "user" or d.get("isSidechain") or d.get("isMeta"):
+        return None
+    origin = d.get("origin")
+    if isinstance(origin, dict) and origin.get("kind") not in (None, "human"):
+        return None
+    content = (d.get("message") or {}).get("content")
+    images = 0
+    if isinstance(content, str):
+        text = content
+    elif isinstance(content, list):
+        if any(isinstance(c, dict) and c.get("type") == "tool_result" for c in content):
+            return None
+        texts = []
+        for c in content:
+            if not isinstance(c, dict):
+                continue
+            if c.get("type") == "text":
+                texts.append(c.get("text", ""))
+            elif c.get("type") == "image":
+                images += 1
+        text = "\n".join(texts)
+    else:
+        return None
+    return text, images
+
+
+def parse_claude_file(path: str, include_sdk: bool = False) -> Session | None:
+    project = Path(path).parent.name
+    turns: list[Turn] = []
+    tools: dict[str, int] = {}
+    last_text = ""
+    first_ts = last_ts = ""
+    sid = Path(path).stem
+    saw_human = saw_script = False
+
+    def flush():
+        nonlocal tools, last_text
+        if turns:
+            turns[-1].agent_after = _summarize_agent(tools, last_text)
+        tools, last_text = {}, ""
+
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        for line in fh:
+            try:
+                d = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            ts = d.get("timestamp") or ""
+            if d.get("type") == "user" and not d.get("isSidechain"):
+                origin_human = isinstance(d.get("origin"), dict) and d["origin"].get("kind") == "human"
+                if origin_human or d.get("turnOrigin") == "human":
+                    saw_human = True
+                elif d.get("entrypoint") == "sdk-cli" or d.get("turnOrigin") == "sdk":
+                    saw_script = True
+                # peer messages, task notifications, scripted prompts: not typed by a person
+                if d.get("turnOrigin") not in (None, "human") and not origin_human and not include_sdk:
+                    continue
+            if d.get("type") == "assistant" and not d.get("isSidechain"):
+                for c in (d.get("message") or {}).get("content") or []:
+                    if not isinstance(c, dict):
+                        continue
+                    if c.get("type") == "tool_use":
+                        n = c.get("name", "?")
+                        tools[n] = tools.get(n, 0) + 1
+                    elif c.get("type") == "text" and c.get("text", "").strip():
+                        last_text = c["text"]
+                continue
+            got = _claude_human_text(d)
+            if not got:
+                continue
+            text, images = got
+            slash = ""
+            m = _SLASH_RE.search(text)
+            if m:
+                slash = m.group(1)
+                a = _ARGS_RE.search(text)
+                text = (slash + " " + (a.group(1).strip() if a else "")).strip()
+            elif text.lstrip().startswith(_NOISE_PREFIXES):
+                continue
+            text = text.strip()
+            if not text and not images:
+                continue
+            if turns and turns[-1].text == text:   # resumed sessions repeat the prompt
+                continue
+            flush()
+            turns.append(Turn(index=len(turns) + 1, text=text, ts=ts, images=images, slash=slash))
+            first_ts = first_ts or ts
+            last_ts = ts or last_ts
+    flush()
+    scripted = saw_script and not saw_human   # `claude -p` or an app driving the SDK
+    if (scripted and not include_sdk) or not turns:
+        return None
+    return Session("claude", sid, project, path, first_ts, last_ts or first_ts, turns)
+
+
+def iter_claude(include_sdk: bool = False) -> Iterator[Session]:
+    root = claude_root()
+    for path in glob.glob(str(root / "*" / "*.jsonl")):
+        if _is_temp_project(Path(path).parent.name):
+            continue
+        s = parse_claude_file(path, include_sdk)
+        if s:
+            yield s
+
+
+# ---------------------------------------------------------------- Codex CLI
+
+def codex_root() -> Path:
+    return Path(os.environ.get("CODEX_HOME", Path.home() / ".codex"))
+
+
+def parse_codex_file(path: str, include_sdk: bool = False) -> Session | None:
+    turns: list[Turn] = []
+    tools: dict[str, int] = {}
+    last_text = ""
+    sid, project, first_ts, last_ts = Path(path).stem, "", "", ""
+    from_items: list[tuple[str, str, int]] = []
+    from_events: list[tuple[str, str, int]] = []
+    order: list[tuple] = []   # interleaving of user turns and agent activity
+
+    with open(path, encoding="utf-8", errors="replace") as fh:
+        for line in fh:
+            try:
+                d = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            ts = d.get("timestamp") or ""
+            p = d.get("payload") or {}
+            t, pt = d.get("type"), p.get("type")
+            if t == "session_meta":
+                sid = p.get("id") or sid
+                cwd = p.get("cwd") or ""
+                project = re.split(r"[\\/]", cwd.rstrip("\\/"))[-1] if cwd else ""  # cwd may be a Windows path
+                # `codex exec`, or another program driving Codex through the app-server
+                # (default originator "codex_cli_rs"); the TUI/IDE set their own originator
+                scripted = p.get("source") == "exec" or p.get("originator") == "codex_cli_rs" \
+                    or p.get("thread_source") not in (None, "user")
+                if scripted and not include_sdk:
+                    return None
+                if _is_temp_project(cwd.replace("\\", "-").replace("/", "-")):
+                    return None
+            elif t == "response_item" and pt == "message" and p.get("role") == "user":
+                texts, images = [], 0
+                for c in p.get("content") or []:
+                    if c.get("type") in ("input_text", "text"):
+                        texts.append(c.get("text", ""))
+                    elif c.get("type") in ("input_image", "image"):
+                        images += 1
+                text = "\n".join(texts).strip()
+                if text.startswith(_NOISE_PREFIXES):
+                    continue
+                order.append(("user", text, ts, images))
+            elif t == "event_msg" and pt == "user_message":
+                from_events.append((p.get("message", "").strip(), ts, len(p.get("images") or [])))
+            elif t == "response_item" and pt in ("function_call", "custom_tool_call", "local_shell_call"):
+                order.append(("tool", p.get("name") or pt))
+            elif t == "response_item" and pt == "message" and p.get("role") == "assistant":
+                txt = " ".join(c.get("text", "") for c in p.get("content") or [] if isinstance(c, dict))
+                if txt.strip():
+                    order.append(("say", txt))
+
+    has_items = any(o[0] == "user" for o in order)
+    if not has_items:   # older rollouts only log user prompts as events
+        order = [("user", txt, ts, im) for txt, ts, im in from_events] + [o for o in order if o[0] != "user"]
+
+    def flush():
+        nonlocal tools, last_text
+        if turns:
+            turns[-1].agent_after = _summarize_agent(tools, last_text)
+        tools, last_text = {}, ""
+
+    for o in order:
+        if o[0] == "user":
+            _, text, ts, images = o
+            if not text and not images:
+                continue
+            flush()
+            slash = text.split()[0] if text.startswith("/") and text.split() else ""
+            turns.append(Turn(index=len(turns) + 1, text=text, ts=ts, images=images, slash=slash))
+            first_ts = first_ts or ts
+            last_ts = ts or last_ts
+        elif o[0] == "tool":
+            tools[o[1]] = tools.get(o[1], 0) + 1
+        elif o[0] == "say":
+            last_text = o[1]
+    flush()
+    if not turns:
+        return None
+    return Session("codex", sid, project, path, first_ts, last_ts or first_ts, turns)
+
+
+def iter_codex(include_sdk: bool = False) -> Iterator[Session]:
+    root = codex_root()
+    paths = glob.glob(str(root / "sessions" / "**" / "*.jsonl"), recursive=True)
+    paths += glob.glob(str(root / "archived_sessions" / "*.jsonl"))
+    seen = set()
+    for path in paths:
+        s = parse_codex_file(path, include_sdk)
+        if s and s.id not in seen:
+            seen.add(s.id)
+            yield s
+
+
+# ---------------------------------------------------------------- selection
+
+def collect(sources: Iterable[str], since: datetime | None = None,
+            include_sdk: bool = False, min_chars: int = 15) -> list[Session]:
+    out: list[Session] = []
+    for src in sources:
+        it = iter_claude(include_sdk) if src == "claude" else iter_codex(include_sdk)
+        for s in it:
+            end = _parse_ts(s.ended)
+            if since and (end is None or end < since):
+                continue
+            typed = sum(len(t.text) for t in s.turns if not t.slash)
+            if typed < min_chars:
+                continue
+            out.append(s)
+    if not include_sdk:
+        # the same opening prompt in 3+ sessions is a template a script sent, not a person typing
+        firsts: dict[str, int] = {}
+        for s in out:
+            k = s.turns[0].text[:200]
+            firsts[k] = firsts.get(k, 0) + 1
+        out = [s for s in out if firsts[s.turns[0].text[:200]] < 3]
+    out.sort(key=lambda s: s.ended, reverse=True)
+    return out
+
+
+def pick_sample(sessions: list[Session], limit: int) -> list[Session]:
+    """Spread the sample over the whole window, preferring sessions with more turns."""
+    if len(sessions) <= limit:
+        return sessions
+    # interleaved buckets each span the window; take the richest session from each
+    buckets = [sessions[i::limit] for i in range(limit)]
+    picked = []
+    for b in buckets:
+        b = sorted(b, key=lambda s: -min(len(s.turns), 30))
+        picked.append(b[0])
+    picked.sort(key=lambda s: s.ended, reverse=True)
+    return picked
+
+
+def now_utc() -> datetime:
+    return datetime.now(timezone.utc)

agentcoach/heuristics.py

@@ -0,0 +1,134 @@
+"""Offline scorer: keyword/shape signals only, no model calls.
+
+It is deliberately rough. It exists so a first report works with zero setup
+(and in a classroom without spending anyone's quota); the LLM judge is the
+real coach. Each rule returns 0/1/2 or None (not applicable).
+"""
+from __future__ import annotations
+
+import re
+
+from .collect import Session
+
+R = lambda p: re.compile(p, re.I)  # noqa: E731
+
+PATH = R(r"(@[\w./\\-]+|[\w\-]+[/\\][\w./\\-]+|\b[\w\-]+\.(py|ts|tsx|js|jsx|go|rs|java|kt|cs|cpp|c|h|rb|php|md|json|ya?ml|toml|html|css|sql|sh|ps1)\b|:\d+\b)")
+SYMPTOM = R(r"(에러|오류|실패|안 ?돼|안 ?됨|깨져|버그|증상|재현|error|fail|exception|traceback|crash|bug|doesn'?t work|broken)")
+VERIFY = R(r"(테스트|test|pytest|jest|통과|pass|빌드|build|lint|린트|타입체크|typecheck|검증|확인해|재현|돌려 ?봐|실행해 ?봐|스크린샷|screenshot|until .* pass|될 때까지)")
+CONSTRAINT = R(r"(하지 ?마|말고|없이|금지|건드리지|유지|그대로 두|만 ?(수정|고쳐)|패턴(을|대로)? 따라|don'?t|do not|without|no new|keep|only|avoid|must not|instead of)")
+SCOPE = R(r"(최소(한)?|간단히|간단하게|빠르게 대충|넉넉|꼼꼼|빠짐없이|엣지 ?케이스|edge case|빈 ?상태|에러 ?상태|be ambitious|minimal|just the|fully|end[- ]to[- ]end|전부|모두 다)")
+PLAN = R(r"(계획|플랜|plan|설계|먼저 .*(말해|알려|정리)|질문(해|하고)|인터뷰|interview|spec|스펙|단계별|마일스톤|milestone)")
+EVIDENCE = R(r"(보여줘|보여 ?달|출력(을|도)? ?(보여|붙여)|로그(를|도)? ?(보여|붙여)|증거|스크린샷|캡처|evidence|show me|paste the output|결과(를)? (보여|붙여))")
+CORRECTION = R(r"^(아니|아냐|그게 아니|다시|또|여전히|still|no[,. ]|wrong|not what|그대로잖|안 ?바뀌|똑같)")
+ERRDUMP = R(r"(Traceback|Error:|Exception|at .+:\d+|\bline \d+|```)")
+STOPS = R(r"(멈춰|멈추고|물어보고|물어봐|확인받|승인(하면|받|한 ?뒤)|제출 ?전|하기 ?전에|직전에|묻지 ?말고|알아서 (진행|끝까지)|ask me|stop and|before (you )?(submit|delete|push|send)|keep going|don'?t ask)")
+DURABLE = R(r"(앞으로|항상|매번|무조건|절대|from now on|always|every time|never)")
+MISS_SIG = [
+    ("repeat", R(r"(라니까|랬잖|했잖아|말했잖|말했는데|아까 (말|얘기)|분명히 (말|얘기))")),
+    ("redo", R(r"(되돌려|원래대로|원상복구|롤백|revert|undo|다시 해)")),
+    ("mishap", R(r"(왜 (이렇게|그렇게|이걸|그걸|.{0,12}했)|하지 말(라|랬)|손해|날렸|망가|잘못 (눌|했|만))")),
+    ("correction", R(r"^\s*(아니|아냐|그게 아니|그거 말고|그런 뜻|틀렸|안 ?바뀌|여전히|똑같|still|no[,. ]|wrong|not what)")),
+]
+RECORD = R(r"(CLAUDE\.md|AGENTS\.md|메모리|기억해|규칙(으로|에)|스킬|skill|훅|hook|memory)")
+
+
+def _task_prompts(s: Session) -> list:
+    """Turns that start or substantially reframe work (long enough to carry a spec)."""
+    out = [t for t in s.turns if not t.slash and (t.index == 1 or len(t.text) >= 60)]
+    return out or [t for t in s.turns if not t.slash][:1]
+
+
+def score_session(s: Session, rubric: dict) -> dict:
+    tasks = _task_prompts(s)
+    typed = [t for t in s.turns if not t.slash]
+    all_text = "\n".join(t.text for t in typed)
+    task_text = "\n".join(t.text for t in tasks)
+    big = len(typed) >= 6 or len(task_text) >= 400
+    first = tasks[0] if tasks else None
+
+    def first_turn(rx):
+        for t in typed:
+            if rx.search(t.text):
+                return t.index
+        return None
+
+    def graded(rx, text_first, text_any):
+        if rx.search(text_first):
+            return 2
+        if rx.search(text_any):
+            return 1
+        return 0
+
+    dims = {}
+    ft = first.text if first else ""
+    actionable = bool(re.search(r"(해줘|해 ?주세요|만들어|고쳐|수정|추가|바꿔|구현|fix|add|make|build|implement|change|refactor|write)", all_text, re.I))
+
+    ctx = 2 if (PATH.search(ft) and (SYMPTOM.search(ft) or len(ft) > 120)) else (1 if PATH.search(task_text) or SYMPTOM.search(ft) or len(ft) > 200 else 0)
+    dims["specific_context"] = ctx if actionable else None
+    dims["done_criteria"] = graded(VERIFY, ft, all_text) if actionable else None
+    dims["constraints"] = graded(CONSTRAINT, ft, task_text) if actionable else None
+    has_material = any(t.images for t in typed) or "@" in all_text or ERRDUMP.search(all_text)
+    mentions_err = SYMPTOM.search(all_text)
+    dims["hand_over"] = (2 if has_material else 0) if (mentions_err or any(t.images for t in typed)) else None
+    dims["scope_signal"] = (graded(SCOPE, ft, task_text)) if actionable and big else None
+    planned = any(t.slash in ("/plan", "/goal") for t in s.turns) or PLAN.search(ft)
+    dims["plan_first"] = (2 if planned else (1 if PLAN.search(all_text) else 0)) if big else None
+    claimed_done = any(re.search(r"(완료|끝났|done|fixed|passed|통과)", t.agent_after, re.I) for t in s.turns)
+    dims["evidence"] = (2 if EVIDENCE.search(all_text) else 0) if claimed_done and actionable else None
+
+    # longest run of consecutive correction-style prompts without a reset
+    run = best = 0
+    for t in s.turns:
+        if t.slash in ("/clear", "/rewind", "/compact", "/new"):
+            run = 0
+        elif CORRECTION.search(t.text.strip()):
+            run += 1
+            best = max(best, run)
+        else:
+            run = 0
+    corrections = sum(1 for t in typed if CORRECTION.search(t.text.strip()))
+    dims["steering"] = None if corrections == 0 else (2 if best <= 1 else 1 if best == 2 else 0)
+
+    risky = re.search(r"(제출|지원|결제|구매|삭제|지워|전송|보내|게시|업로드|푸시|push|submit|delete|send|publish|pay)", all_text, re.I)
+    dims["stop_conditions"] = graded(STOPS, ft, task_text) if actionable and (big or risky) else None
+
+    durable_turns = [t for t in typed if DURABLE.search(t.text)]
+    if not durable_turns:
+        dims["reusable_guidance"] = None
+    elif any(RECORD.search(t.text) for t in typed):
+        dims["reusable_guidance"] = 2
+    else:
+        dims["reusable_guidance"] = 0 if len(durable_turns) >= 3 else 1
+
+    resets = sum(1 for t in s.turns if t.slash in ("/clear", "/compact", "/new", "/fork"))
+    if len(typed) < 15:
+        dims["focused_session"] = None
+    elif len(typed) >= 60 and resets == 0:
+        dims["focused_session"] = 0
+    else:
+        dims["focused_session"] = 1 if (len(typed) >= 30 and resets == 0) else 2
+
+    rx_for = {"specific_context": PATH, "done_criteria": VERIFY, "constraints": CONSTRAINT,
+              "scope_signal": SCOPE, "plan_first": PLAN, "evidence": EVIDENCE, "steering": CORRECTION,
+              "hand_over": ERRDUMP, "stop_conditions": STOPS, "reusable_guidance": DURABLE}
+    out = {}
+    for d in rubric["dimensions"]:
+        did = d["id"]
+        sc = dims.get(did)
+        out[did] = {"score": sc, "evidence_turn": first_turn(rx_for[did]) if did in rx_for else None,
+                    "note": ""}
+    # misses: what happened next tells us the turn missed; offline we can't tell whose fault it was
+    misses = []
+    for i, t in enumerate(s.turns[:-1]):
+        nxt = s.turns[i + 1]
+        if t.slash or nxt.slash:
+            continue
+        for kind, rx in MISS_SIG:
+            if rx.search(nxt.text.strip()[:160]):
+                misses.append({"turn": t.index, "signal_turn": nxt.index, "signal": kind, "cause": "unclassified",
+                               "context_was_enough": None, "original": t.text[:160], "what_went_wrong": nxt.text[:160],
+                               "better": "", "why": ""})
+                break
+    return {"task_summary": (ft[:80] + "…") if len(ft) > 80 else ft, "dimensions": out, "coaching": [],
+            "misses": misses[:8],
+            "judge": "heuristic"}

agentcoach/i18n.py

@@ -0,0 +1,88 @@
+"""Language selection and CLI messages (Korean and English)."""
+from __future__ import annotations
+
+import locale
+import os
+
+SUPPORTED = ("en", "ko")
+
+
+def detect_lang() -> str:
+    """AGENT_COACH_LANG wins; otherwise follow the OS locale; default English."""
+    env = os.environ.get("AGENT_COACH_LANG", "").lower()
+    if env in SUPPORTED:
+        return env
+    candidates = [os.environ.get(k, "") for k in ("LC_ALL", "LC_MESSAGES", "LANG")]
+    try:
+        candidates.append(locale.getlocale()[0] or "")
+    except ValueError:
+        pass
+    for c in candidates:
+        c = c.lower()
+        if c.startswith("ko") or "korean" in c:
+            return "ko"
+    return "en"
+
+
+M = {
+    "bad_source": {"en": "Unknown source: {bad} (choose from claude, codex)",
+                   "ko": "알 수 없는 source: {bad} (claude, codex 중에서)"},
+    "all_time": {"en": "all time", "ko": "전체"},
+    "scan_head": {"en": "Window: since {since}  ·  {n} conversations",
+                  "ko": "기간: {since} 이후  ·  대화 {n}개"},
+    "scan_tail": {"en": "{turns} prompts you typed. Run `agent-coach run` to grade them (up to {max} conversations by default).",
+                  "ko": "사람이 쓴 지시 {turns}개. `agent-coach run` 으로 채점합니다 (기본 최대 {max}개 대화)."},
+    "nothing": {"en": "No conversations to grade. Widen the window with --days 30 or --all.",
+                "ko": "채점할 대화가 없습니다. --days 30 이나 --all 로 기간을 넓혀 보세요."},
+    "grading": {"en": "Grading {k} of {n} conversations · judge: {judge}",
+                "ko": "대화 {n}개 중 {k}개를 채점합니다 · 채점기: {judge}"},
+    "done": {"en": "done", "ko": "완료"},
+    "fallback": {"en": "failed, using keyword scoring", "ko": "실패, 키워드 채점으로 대체"},
+    "all_failed": {"en": "Every LLM grading call failed; saving keyword scores only. Use --verbose to see why.",
+                   "ko": "LLM 채점이 모두 실패해 키워드 채점 결과만 저장합니다. --verbose 로 원인을 확인하세요."},
+    "grouping": {"en": "Grouping prompt gaps that keep coming back…", "ko": "반복되는 지시 빈틈을 묶는 중…"},
+    "result": {"en": "Overall {overall} · {gaps} of {total} missed responses were gaps in your prompt\nRun saved {path}\nReport {out}",
+               "ko": "종합 {overall}점 · 놓친 응답 {total}곳 중 내 지시 빈틈 {gaps}곳\n기록 {path}\n리포트 {out}"},
+    "no_runs": {"en": "No runs yet. Run `agent-coach run` first.",
+                "ko": "아직 채점 기록이 없습니다. 먼저 `agent-coach run` 을 실행하세요."},
+    "no_history": {"en": "No runs yet", "ko": "기록 없음"},
+    "hist_head": {"en": ("Date", "Overall", "Convos", "Judge"), "ko": ("날짜", "종합", "대화", "채점기")},
+    "desc": {"en": "Coach how you direct Claude Code and Codex, graded against the official guides using your own local transcripts.",
+             "ko": "Claude Code·Codex 대화 기록으로 공식 가이드 기준 지시 습관을 코칭합니다."},
+    "h_rubric": {"en": "Rubric JSON path (default: built-in, grounded in the official guides)",
+                 "ko": "채점표 JSON 경로 (기본: 공식 가이드 기반)"},
+    "h_source": {"en": "Which tools to read: claude,codex (default both)", "ko": "claude,codex 중 선택 (기본 둘 다)"},
+    "h_days": {"en": "Last N days (default: since the previous run; 14 days on the first run)",
+               "ko": "최근 N일 (기본: 지난 채점 이후, 첫 회는 14일)"},
+    "h_all": {"en": "No time window", "ko": "기간 제한 없이 전체"},
+    "h_sdk": {"en": "Also include scripted `claude -p` / `codex exec` conversations",
+              "ko": "스크립트로 돌린 claude -p / codex exec 대화도 포함"},
+    "h_max": {"en": "Max conversations to grade (default 20)", "ko": "채점할 최대 대화 수 (기본 20)"},
+    "h_lang": {"en": "Language for the report and coaching (default: from your OS locale)",
+               "ko": "리포트와 코칭 언어 (기본: OS 언어 설정)"},
+    "h_scan": {"en": "Preview which conversations would be graded (no model calls)",
+               "ko": "채점 대상 대화를 미리 봅니다 (모델 호출 없음)"},
+    "h_run": {"en": "Grade, save the run and open the report", "ko": "채점하고 기록을 남긴 뒤 리포트를 엽니다"},
+    "h_judge": {"en": "Judge (default auto: claude → codex → keywords)", "ko": "채점기 (기본 auto: claude → codex → 키워드)"},
+    "h_model": {"en": "Model for the judge (e.g. sonnet, haiku, gpt-5.5)", "ko": "채점에 쓸 모델 (예: sonnet, haiku, gpt-5.5)"},
+    "h_workers": {"en": "Parallel grading calls", "ko": "동시 채점 수"},
+    "h_noopen": {"en": "Don't open the report in a browser", "ko": "리포트를 브라우저로 열지 않음"},
+    "h_report": {"en": "Rebuild the report from saved runs", "ko": "저장된 기록으로 리포트만 다시 만듭니다"},
+    "h_history": {"en": "Score table per run", "ko": "회차별 점수 표"},
+    "h_summary": {"en": "Print the latest run as text: weakest habits, rewrites, missed responses, rules to add",
+                  "ko": "최근 회차를 글로 출력: 약한 습관, 고쳐 쓰기, 놓친 응답, 추가할 규칙"},
+    "sum_head": {"en": "agent-coach · {date} · overall {overall}/100 · {n} conversations",
+                 "ko": "agent-coach · {date} · 종합 {overall}/100 · 대화 {n}개"},
+    "sum_weak": {"en": "Weakest habits", "ko": "약한 습관"},
+    "sum_rewrites": {"en": "Rewrites of your prompts", "ko": "내 지시 고쳐 쓰기"},
+    "sum_gaps": {"en": "Missed responses caused by a gap in your prompt", "ko": "내 지시의 빈틈 때문에 놓친 응답"},
+    "sum_rules": {"en": "Rules worth adding", "ko": "추가할 만한 규칙"},
+    "sum_wrote": {"en": "wrote", "ko": "쓴 지시"},
+    "sum_better": {"en": "better", "ko": "이렇게"},
+    "sum_why": {"en": "why", "ko": "이유"},
+}
+
+
+def t(key: str, lang: str, **kw):
+    msg = M[key].get(lang) or M[key]["en"]
+    return msg.format(**kw) if isinstance(msg, str) and kw else msg