feat(ledger): 하네스 판 비교를 eval 줄로 남기고 시작 컨텍스트를 잰다
문제: 하네스 v2(분야 전문가 협업)를 v1과 견주려면 같은 과제를 판마다 돌린 실행을 한 줄씩 남기고 비교해야 하는데, 장부에는 예측·실측만 있다. 실측도 시간·호출·토큰뿐이라 모든 세션의 시작 비용(첫 호출 입력 토큰)과 서브에이전트가 메인에 돌려준 양(컨텍스트 비용)을 볼 수 없다. 고른 방법: - usage에 start_context(본 기록 첫 호출), subagents·subagent_output_tokens, agent_calls(Agent·Task 호출), agent_return_chars를 더한다. 반환 글자는 Agent 도구 결과와, 백그라운드 결과가 들어오는 대기열 알림 (queued_command의 <agent-message·<task-notification 머리)을 센다. 2026-11-11 세션 기록에서 백그라운드 결과가 tool_result가 아니라 알림으로 오는 것을 확인했다. - 새 줄 종류 eval(arm·case 필수)과 명령 eval(초안)·compare(과제·판별 중앙값, 마지막 판/첫 판 비율). precedents는 eval만 있는 작업을 세지 않는다. - Stop 훅이 0.2.0이 저장한 상태 파일을 이어 읽어도 깨지지 않게 새 칸은 setdefault로 채운다. - 버린 대안: eval을 actual 줄에 arm 칸으로 붙이기. 같은 작업의 판 여럿이 by_task에서 덮이고 회고 대기 계산에 섞인다. 위험: 대기열 알림 모양은 앱 내부 형식이다. 바뀌면 agent_return_chars가 조용히 줄어든다(시험이 지금 모양을 고정한다). 검증: python3 -m unittest discover -s plugins/harness/tests → 24건 통과 (알려진 실패 1). 조건을 하나씩 끈 변이 9개가 모두 시험에 걸렸다.
This commit is contained in:
+16
-1
@@ -7,6 +7,7 @@
|
||||
끝 보고 직전 ──> actual 줄: 세션 기록에서 뽑은 실측
|
||||
회고(주 1회) ──> retro 줄: 틀린 이유와 고칠 단계, 개선 id
|
||||
판정(뒤 작업 2건) ──> verdict 줄: 그 개선이 효과가 있었나, 없으면 되돌림
|
||||
평가(하네스 판 비교) ──> eval 줄: 같은 과제를 판마다 돌린 실행 하나씩
|
||||
```
|
||||
|
||||
- 파일은 `docs/ledger/estimates.jsonl` 하나다. 한 줄이 JSON 하나다(JSON Lines). 줄을 고치거나 지우지 않고 더하기만 한다. 고칠 일이 있으면 같은 `task`로 `"correction": true` 줄을 더한다.
|
||||
@@ -23,7 +24,7 @@
|
||||
| 칸 | 형식 | 뜻 |
|
||||
| --- | --- | --- |
|
||||
| `schema` | 정수 | 이 형식의 판. 지금 1 |
|
||||
| `kind` | `estimate` · `actual` · `retro` · `verdict` | 줄의 종류 |
|
||||
| `kind` | `estimate` · `actual` · `retro` · `verdict` · `eval` | 줄의 종류 |
|
||||
| `task` | 문자열 | 작업 이름. 같은 작업의 줄을 묶는 키다(예: 세션 이름) |
|
||||
| `recorded_at` | ISO 8601 | 이 줄을 쓴 시각 |
|
||||
| `transcript` | 문자열 | Claude Code 세션 기록 파일 이름(`~/.claude/projects/<폴더>/<이 값>.jsonl`). 실측을 다시 셀 때 쓴다 |
|
||||
@@ -68,3 +69,17 @@
|
||||
| `ref` | 문자열 | `reverted`면 되돌린 커밋 |
|
||||
|
||||
`task`는 판정을 내린 작업 이름이다.
|
||||
|
||||
`eval`(하네스 판 비교의 실행 하나, `harness-eval` 스킬):
|
||||
|
||||
| 칸 | 형식 | 뜻 |
|
||||
| --- | --- | --- |
|
||||
| `task` | 문자열 | 평가 이름(예: `harness-v2-eval`). 같은 평가의 실행을 묶는다 |
|
||||
| `arm`, `case` | 문자열 | 판(예: `v1`·`v2`), 과제(예: `review-seeded-be`) |
|
||||
| `active_minutes`, `calls`, `output_tokens`, `input_tokens_total` | 정수 | `actual`과 같은 규칙. 서브에이전트 기록을 더한다 |
|
||||
| `start_context`, `max_context` | 정수 | 첫 호출의 입력 토큰(시작 비용), 가장 큰 호출의 입력 토큰 |
|
||||
| `subagents`, `subagent_calls`, `agent_calls`, `agent_return_chars` | 정수 | 서브에이전트 기록 수와 그 호출 수, 메인이 띄운 Agent 호출 수, 서브에이전트가 메인에 돌려준 글자 수(컨텍스트 비용) |
|
||||
| `findings`, `false_findings` | 정수 | 정답을 아는 과제에서 찾은 것, 틀린 발견 |
|
||||
| `note` | 문자열 | 실행 방식(새 세션인가, 서브에이전트로 흉내 냈나), 모델 |
|
||||
|
||||
`ledger.py compare --task <평가 이름>`이 과제·판마다 중앙값과 마지막 판/첫 판 비율을 보인다. `precedents`·회고 대기는 `eval` 줄을 세지 않는다.
|
||||
|
||||
@@ -11,6 +11,8 @@
|
||||
current 지금 폴더의 세션 기록 경로
|
||||
usage [기록 경로|uuid] 세션 기록의 실측(JSON). 하위 에이전트 기록(<uuid>/subagents/)을 더한다
|
||||
actual --task T [기록] T의 예측과 견준 actual 줄 초안(JSON). 쓰지는 않는다
|
||||
eval --task E --arm A --case C [기록] 평가 E의 한 실행(판 A, 과제 C) eval 줄 초안(JSON). 쓰지는 않는다
|
||||
compare --task E 평가 E의 과제·판별 중앙값 표와 마지막 판/첫 판 비율
|
||||
precedents [--kind K] [--size S] 장부의 지난 예측·실측 표와 보정 줄(실측/p50 중앙값). --ledger를 여러 번 줘도 된다
|
||||
pending 예측 밖인데 회고가 없는 작업, 효과 판정이 없는 개선
|
||||
append stdin의 JSON 한 줄을 검사해 장부 끝에 더한다
|
||||
@@ -31,16 +33,19 @@ import sys
|
||||
import time
|
||||
|
||||
GAP_SECONDS = 300
|
||||
KINDS = ("estimate", "actual", "retro", "verdict")
|
||||
KINDS = ("estimate", "actual", "retro", "verdict", "eval")
|
||||
REQUIRED = {
|
||||
"estimate": ("minutes", "basis"),
|
||||
"actual": ("active_minutes",),
|
||||
"eval": ("arm", "case", "active_minutes"),
|
||||
"retro": ("cause", "level"),
|
||||
"verdict": ("fix", "effect"),
|
||||
}
|
||||
CAUSES = ("지시 모호", "착수 전 조사 부족", "아키텍처 경직", "검증 대기", "외부 대기", "범위 변경", "예측 근거 없음")
|
||||
LEVELS = ("architecture", "gate", "instructions", "user")
|
||||
EFFECTS = ("effective", "reverted")
|
||||
AGENT_TOOLS = ("Agent", "Task") # 서브에이전트를 띄우는 도구 이름(옛 이름 Task)
|
||||
HANDBACK_PREFIXES = ("<agent-message", "<task-notification") # 백그라운드 결과가 대기열로 들어올 때의 머리
|
||||
VERDICT_AFTER = 2 # 개선 뒤에 예측한 다른 작업의 실측이 이만큼 쌓이면 효과를 판정한다
|
||||
NUDGE_EVERY = 20 * 3600 # 같은 repo에 넛지를 다시 내기까지(초)
|
||||
|
||||
@@ -67,11 +72,23 @@ def local_iso(seconds):
|
||||
# ---------------------------------------------------------------- 세션 기록 읽기
|
||||
|
||||
def new_file_state():
|
||||
return {"offset": 0, "ids": {}, "first": None, "last": None, "active": 0.0}
|
||||
# first_id: 첫 호출의 message.id(시작 컨텍스트). agents: Agent 호출 id → 결과를 셌나. agent_chars: 돌려받은 글자
|
||||
return {"offset": 0, "ids": {}, "first": None, "last": None, "active": 0.0,
|
||||
"first_id": None, "agents": {}, "agent_chars": 0}
|
||||
|
||||
|
||||
def result_chars(content):
|
||||
if isinstance(content, str):
|
||||
return len(content)
|
||||
if isinstance(content, list):
|
||||
return sum(len(b.get("text") or "") for b in content if isinstance(b, dict) and b.get("type") == "text")
|
||||
return 0
|
||||
|
||||
|
||||
def scan(path, st):
|
||||
"""path를 st["offset"]부터 마지막 완전한 줄까지 읽어 st를 갱신한다."""
|
||||
for key, value in new_file_state().items(): # 옛 판이 저장한 상태에 없는 칸
|
||||
st.setdefault(key, value)
|
||||
try:
|
||||
with open(path, "rb") as f:
|
||||
f.seek(st["offset"])
|
||||
@@ -100,6 +117,21 @@ def scan(path, st):
|
||||
("input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens", "output_tokens")]
|
||||
old = st["ids"].get(msg["id"])
|
||||
st["ids"][msg["id"]] = [max(a, b) for a, b in zip(old, vals)] if old else vals
|
||||
if st["first_id"] is None:
|
||||
st["first_id"] = msg["id"]
|
||||
queued = d.get("attachment") if d.get("type") == "attachment" else None
|
||||
if isinstance(queued, dict) and queued.get("type") == "queued_command" and isinstance(queued.get("prompt"), str) \
|
||||
and queued["prompt"].lstrip().startswith(HANDBACK_PREFIXES):
|
||||
st["agent_chars"] += len(queued["prompt"]) # 백그라운드 서브에이전트의 결과·완료 알림
|
||||
blocks = (d.get("message") or {}).get("content") if isinstance(d.get("message"), dict) else None
|
||||
for b in blocks if isinstance(blocks, list) else ():
|
||||
if not isinstance(b, dict):
|
||||
continue
|
||||
if b.get("type") == "tool_use" and b.get("name") in AGENT_TOOLS and b.get("id"):
|
||||
st["agents"].setdefault(b["id"], False)
|
||||
elif b.get("type") == "tool_result" and st["agents"].get(b.get("tool_use_id")) is False:
|
||||
st["agents"][b["tool_use_id"]] = True
|
||||
st["agent_chars"] += result_chars(b.get("content"))
|
||||
st["offset"] += end
|
||||
return st
|
||||
|
||||
@@ -112,8 +144,10 @@ def summarize(transcript, files):
|
||||
"""files: 경로 → 상태. 본 기록의 시간과 모든 기록의 토큰을 합친다."""
|
||||
main = files.get(transcript) or new_file_state()
|
||||
ids = [v for st in files.values() for v in st["ids"].values()]
|
||||
sub_calls = sum(len(st["ids"]) for p, st in files.items() if p != transcript)
|
||||
subs = [st for p, st in files.items() if p != transcript and st["ids"]]
|
||||
sub_calls = sum(len(st["ids"]) for st in subs)
|
||||
first, last = main["first"], main["last"]
|
||||
start = main["ids"].get(main.get("first_id")) or [0, 0, 0, 0]
|
||||
return {
|
||||
"transcript": os.path.basename(transcript)[:-len(".jsonl")],
|
||||
"started_at": local_iso(first),
|
||||
@@ -126,6 +160,11 @@ def summarize(transcript, files):
|
||||
"cache_read_tokens": sum(v[2] for v in ids),
|
||||
"input_tokens_total": sum(v[0] + v[1] + v[2] for v in ids),
|
||||
"max_context": max((v[0] + v[1] + v[2] for v in ids), default=0),
|
||||
"start_context": start[0] + start[1] + start[2],
|
||||
"subagents": len(subs),
|
||||
"subagent_output_tokens": sum(v[3] for st in subs for v in st["ids"].values()),
|
||||
"agent_calls": len(main.get("agents") or {}),
|
||||
"agent_return_chars": main.get("agent_chars") or 0,
|
||||
}
|
||||
|
||||
|
||||
@@ -331,6 +370,8 @@ def cmd_precedents(args):
|
||||
rows = []
|
||||
for name, t in tasks.items():
|
||||
e, a = t.get("estimate", {}), t.get("actual", {})
|
||||
if not e and not a: # 평가 줄만 있는 작업
|
||||
continue
|
||||
if args.kind and args.kind not in str(e.get("task_kind", "")):
|
||||
continue
|
||||
if args.size and args.size != e.get("size"):
|
||||
@@ -389,6 +430,69 @@ def cmd_actual(args):
|
||||
return 0
|
||||
|
||||
|
||||
EVAL_COLUMNS = (("작업 중 분", "active_minutes"), ("호출", "calls"), ("출력 토큰", "output_tokens"),
|
||||
("시작 컨텍스트", "start_context"), ("최대 컨텍스트", "max_context"), ("발견", "findings"),
|
||||
("틀린 발견", "false_findings"))
|
||||
EVAL_RATIOS = (("작업 중 분", "active_minutes"), ("호출", "calls"), ("출력", "output_tokens"),
|
||||
("시작 컨텍스트", "start_context"), ("발견", "findings"), ("최대 컨텍스트", "max_context"))
|
||||
|
||||
|
||||
def num(v):
|
||||
return "-" if v is None else ("%d" % v if float(v).is_integer() else "%.1f" % v)
|
||||
|
||||
|
||||
def med(rows, key):
|
||||
vals = [r[key] for r in rows if isinstance(r.get(key), (int, float))]
|
||||
return statistics.median(vals) if vals else None
|
||||
|
||||
|
||||
def cmd_compare(args):
|
||||
rows = [r for r in read_ledger(ledger_path(args.ledger)) if r.get("kind") == "eval" and r.get("task") == args.task]
|
||||
if not rows:
|
||||
print("평가 줄 없음: %s. 실행마다 `ledger.py eval` 초안을 채워 append한다." % args.task)
|
||||
return 0
|
||||
groups, arms = {}, []
|
||||
for r in rows:
|
||||
groups.setdefault((r.get("case"), r.get("arm")), []).append(r)
|
||||
if r.get("arm") not in arms:
|
||||
arms.append(r.get("arm"))
|
||||
print("| 과제 | 판 | 실행 | %s |" % " | ".join(label for label, _ in EVAL_COLUMNS))
|
||||
print("|---|---|---|%s" % "---|" * len(EVAL_COLUMNS))
|
||||
for (case, arm), rs in groups.items():
|
||||
print("| %s | %s | %d | %s |" % (case, arm, len(rs), " | ".join(num(med(rs, k)) for _, k in EVAL_COLUMNS)))
|
||||
if len(arms) < 2:
|
||||
return 0
|
||||
base, cand = arms[0], arms[-1]
|
||||
parts = []
|
||||
for label, key in EVAL_RATIOS:
|
||||
ratios = []
|
||||
for case in dict.fromkeys(c for c, _ in groups):
|
||||
b, c = med(groups.get((case, base), []), key), med(groups.get((case, cand), []), key)
|
||||
if b and c is not None:
|
||||
ratios.append(c / b)
|
||||
if ratios:
|
||||
parts.append("%s %.2f" % (label, statistics.median(ratios)))
|
||||
print("\n%s/%s 중앙값: %s. 과제마다 비율을 내고 그 중앙값이다. 발견은 리뷰가 찾은 결함 수다(클수록 좋다)." % (
|
||||
cand, base, " · ".join(parts)))
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_eval(args):
|
||||
transcript = resolve_transcript(args.transcript)
|
||||
if not transcript:
|
||||
print("세션 기록을 찾지 못했다. 기록 경로나 uuid를 넘긴다.", file=sys.stderr)
|
||||
return 1
|
||||
summary, _ = usage(transcript)
|
||||
row = {"schema": 1, "kind": "eval", "task": args.task, "arm": args.arm, "case": args.case,
|
||||
"recorded_at": now_iso(), "transcript": summary["transcript"]}
|
||||
row.update({k: summary[k] for k in ("active_minutes", "calls", "output_tokens", "input_tokens_total",
|
||||
"start_context", "max_context", "subagents", "subagent_calls",
|
||||
"agent_calls", "agent_return_chars")})
|
||||
row.update({"findings": None, "false_findings": None, "result": "done", "note": ""})
|
||||
print(json.dumps(row, ensure_ascii=False))
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_append(args):
|
||||
row = json.loads(sys.stdin.read())
|
||||
problems = []
|
||||
@@ -448,6 +552,14 @@ def main(argv):
|
||||
pr.add_argument("--kind")
|
||||
pr.add_argument("--size", choices=("small", "medium", "large"))
|
||||
pr.add_argument("--ledger", action="append")
|
||||
ev = sub.add_parser("eval")
|
||||
ev.add_argument("--task", required=True)
|
||||
ev.add_argument("--arm", required=True)
|
||||
ev.add_argument("--case", required=True)
|
||||
ev.add_argument("transcript", nargs="?")
|
||||
cp = sub.add_parser("compare")
|
||||
cp.add_argument("--task", required=True)
|
||||
cp.add_argument("--ledger")
|
||||
for name in ("pending", "append"):
|
||||
sub.add_parser(name).add_argument("--ledger")
|
||||
args = p.parse_args(argv)
|
||||
@@ -470,8 +582,8 @@ def main(argv):
|
||||
return 1
|
||||
print(json.dumps(usage(transcript)[0], ensure_ascii=False, indent=1))
|
||||
return 0
|
||||
return {"actual": cmd_actual, "precedents": cmd_precedents, "pending": cmd_pending,
|
||||
"append": cmd_append}[args.cmd](args)
|
||||
return {"actual": cmd_actual, "precedents": cmd_precedents, "pending": cmd_pending, "append": cmd_append,
|
||||
"eval": cmd_eval, "compare": cmd_compare}[args.cmd](args)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -270,6 +270,96 @@ class LedgerTest(unittest.TestCase):
|
||||
r = run("ledger.py", ["precedents", "--ledger", one, "--ledger", two], env=self.env)
|
||||
self.assertIn("실측/p50 중앙값 시간 0.75(3건) · 호출 0.50(2건). 시간 실측이 p30 아래 1건, p80 위 1건", r.stdout)
|
||||
|
||||
def test_usage_measures_start_context_and_subagent_returns(self):
|
||||
"""평가(v1·v2 비교)에 쓰는 칸: 첫 호출 컨텍스트, Agent 호출 수, 서브에이전트가 돌려준 글자 수."""
|
||||
self.write_transcript([
|
||||
self.assistant("m1", "2026-11-07T10:00:00Z", 10, cache_read=900, inp=50, created=50),
|
||||
{"type": "assistant", "timestamp": "2026-11-07T10:00:05Z", "message": {
|
||||
"id": "m2", "usage": {"input_tokens": 1, "output_tokens": 5},
|
||||
"content": [{"type": "tool_use", "id": "tu1", "name": "Agent", "input": {"prompt": "x"}},
|
||||
{"type": "tool_use", "id": "tu2", "name": "Bash", "input": {"command": "ls"}}]}},
|
||||
])
|
||||
# 결과가 다음 조각에 온다(Stop 훅은 이어 읽는다)
|
||||
self.write_transcript([
|
||||
{"type": "user", "timestamp": "2026-11-07T10:01:00Z", "message": {"content": [
|
||||
{"type": "tool_result", "tool_use_id": "tu1", "content": [{"type": "text", "text": "가" * 40}]},
|
||||
{"type": "tool_result", "tool_use_id": "tu2", "content": "bash 출력은 세지 않는다"}]}},
|
||||
{"type": "assistant", "timestamp": "2026-11-07T10:01:05Z", "message": {
|
||||
"id": "m3", "usage": {"output_tokens": 1},
|
||||
"content": [{"type": "tool_use", "id": "tu3", "name": "Task", "input": {}}]}},
|
||||
{"type": "user", "timestamp": "2026-11-07T10:02:00Z", "message": {"content": [
|
||||
{"type": "tool_result", "tool_use_id": "tu3", "content": "short"}]}},
|
||||
# 백그라운드 서브에이전트의 결과는 대기열 알림으로 온다. 사용자가 끼워 넣은 말은 세지 않는다
|
||||
{"type": "attachment", "timestamp": "2026-11-07T10:03:00Z",
|
||||
"attachment": {"type": "queued_command", "prompt": "<agent-message from=\"a1\">0123456789"}},
|
||||
{"type": "attachment", "timestamp": "2026-11-07T10:03:01Z",
|
||||
"attachment": {"type": "queued_command", "prompt": "사용자가 중간에 보낸 말"}},
|
||||
], mode="a")
|
||||
sub = os.path.join(self.dir, "abc", "subagents")
|
||||
os.makedirs(sub)
|
||||
for i in (1, 2):
|
||||
with open(os.path.join(sub, "agent-%d.jsonl" % i), "w") as f:
|
||||
f.write(json.dumps(self.assistant("s%d" % i, "2026-11-07T10:00:30Z", 7, cache_read=5000)) + "\n")
|
||||
u = json.loads(run("ledger.py", ["usage", self.transcript], env=self.env).stdout)
|
||||
self.assertEqual(u["start_context"], 1000) # 본 기록 첫 호출만, 서브에이전트 첫 호출이 아니다
|
||||
self.assertEqual((u["agent_calls"], u["agent_return_chars"]), (2, 45 + 35)) # 알림 머리 25자 + 본문 10자
|
||||
self.assertEqual((u["subagents"], u["subagent_output_tokens"]), (2, 14))
|
||||
|
||||
hook = {"session_id": "s-3", "transcript_path": self.transcript, "cwd": self.dir}
|
||||
with open(self.transcript) as f:
|
||||
lines = f.readlines()
|
||||
with open(self.transcript, "w") as f:
|
||||
f.writelines(lines[:2]) # Agent 호출까지만 쓰인 때 한 번
|
||||
run("ledger.py", ["stop"], payload=hook, env=self.env)
|
||||
with open(self.transcript, "a") as f:
|
||||
f.writelines(lines[2:])
|
||||
run("ledger.py", ["stop"], payload=hook, env=self.env)
|
||||
with open(os.path.join(self.env["HARNESS_STATE_DIR"], "usage", "s-3.json")) as f:
|
||||
saved = json.load(f)["summary"]
|
||||
self.assertEqual((saved["agent_calls"], saved["agent_return_chars"]), (2, 45 + 35)) # 알림 머리 25자 + 본문 10자
|
||||
|
||||
def test_stop_hook_survives_state_saved_by_older_version(self):
|
||||
self.write_transcript([self.assistant("m1", "2026-11-07T10:00:00Z", 10)])
|
||||
folder = os.path.join(self.env["HARNESS_STATE_DIR"], "usage")
|
||||
os.makedirs(folder)
|
||||
old = {"offset": 0, "ids": {}, "first": None, "last": None, "active": 0.0} # 0.2.0이 저장한 모양
|
||||
with open(os.path.join(folder, "s-4.json"), "w") as f:
|
||||
json.dump({"session_id": "s-4", "transcript_path": self.transcript, "files": {self.transcript: old}}, f)
|
||||
hook = {"session_id": "s-4", "transcript_path": self.transcript, "cwd": self.dir}
|
||||
r = run("ledger.py", ["stop"], payload=hook, env=self.env)
|
||||
self.assertEqual(r.stderr, "")
|
||||
with open(os.path.join(folder, "s-4.json")) as f:
|
||||
self.assertEqual(json.load(f)["summary"]["calls"], 1)
|
||||
|
||||
def test_eval_rows_compare_arms_per_case(self):
|
||||
ledger = os.path.join(self.dir, "estimates.jsonl")
|
||||
bad = {"kind": "eval", "task": "e1", "case": "review"} # arm 없음
|
||||
self.assertEqual(run("ledger.py", ["append", "--ledger", ledger], payload=bad, env=self.env).returncode, 1)
|
||||
rows = []
|
||||
for arm, mins, findings, start in (("v1", 20, 3, 70000), ("v1", 30, 5, 70000),
|
||||
("v2", 10, 6, 75000), ("v2", 20, 8, 75000)):
|
||||
rows.append({"kind": "eval", "task": "e1", "case": "review", "arm": arm, "active_minutes": mins,
|
||||
"calls": mins * 2, "output_tokens": mins * 1000, "start_context": start,
|
||||
"max_context": start * 2, "findings": findings, "false_findings": 1})
|
||||
for row in rows:
|
||||
self.assertEqual(run("ledger.py", ["append", "--ledger", ledger], payload=row, env=self.env).returncode, 0)
|
||||
self.write_ledger(ledger, self.pair("plain", 5))
|
||||
r = run("ledger.py", ["compare", "--task", "e1", "--ledger", ledger], env=self.env)
|
||||
self.assertEqual(r.returncode, 0, r.stderr)
|
||||
self.assertIn("| review | v1 | 2 | 25 | 50 | 25000 | 70000 | 140000 | 4 | 1 |", r.stdout)
|
||||
self.assertIn("| review | v2 | 2 | 15 | 30 | 15000 | 75000 | 150000 | 7 | 1 |", r.stdout)
|
||||
self.assertIn("v2/v1 중앙값: 작업 중 분 0.60 · 호출 0.60 · 출력 0.60 · 시작 컨텍스트 1.07 · 발견 1.75", r.stdout)
|
||||
self.assertNotIn("| e1 |", run("ledger.py", ["precedents", "--ledger", ledger], env=self.env).stdout)
|
||||
self.assertIn("평가 줄 없음", run("ledger.py", ["compare", "--task", "none", "--ledger", ledger],
|
||||
env=self.env).stdout)
|
||||
|
||||
self.write_transcript([self.assistant("m1", "2026-11-07T10:00:00Z", 10)])
|
||||
r = run("ledger.py", ["eval", "--task", "e1", "--arm", "v2", "--case", "review", self.transcript], env=self.env)
|
||||
draft = json.loads(r.stdout)
|
||||
self.assertEqual((draft["kind"], draft["arm"], draft["case"], draft["calls"]), ("eval", "v2", "review", 1))
|
||||
self.assertIn("findings", draft)
|
||||
self.assertIn("false_findings", draft)
|
||||
|
||||
def test_nudge_prints_one_line_once_per_repo_on_startup(self):
|
||||
repo = os.path.join(self.dir, "repo")
|
||||
os.makedirs(repo)
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
끝 보고 직전 ──> actual 줄: 세션 기록에서 뽑은 실측
|
||||
회고(주 1회) ──> retro 줄: 틀린 이유와 고칠 단계, 개선 id
|
||||
판정(뒤 작업 2건) ──> verdict 줄: 그 개선이 효과가 있었나, 없으면 되돌림
|
||||
평가(하네스 판 비교) ──> eval 줄: 같은 과제를 판마다 돌린 실행 하나씩
|
||||
```
|
||||
|
||||
- 파일은 `docs/ledger/estimates.jsonl` 하나다. 한 줄이 JSON 하나다(JSON Lines). 줄을 고치거나 지우지 않고 더하기만 한다. 고칠 일이 있으면 같은 `task`로 `"correction": true` 줄을 더한다.
|
||||
@@ -23,7 +24,7 @@
|
||||
| 칸 | 형식 | 뜻 |
|
||||
| --- | --- | --- |
|
||||
| `schema` | 정수 | 이 형식의 판. 지금 1 |
|
||||
| `kind` | `estimate` · `actual` · `retro` · `verdict` | 줄의 종류 |
|
||||
| `kind` | `estimate` · `actual` · `retro` · `verdict` · `eval` | 줄의 종류 |
|
||||
| `task` | 문자열 | 작업 이름. 같은 작업의 줄을 묶는 키다(예: 세션 이름) |
|
||||
| `recorded_at` | ISO 8601 | 이 줄을 쓴 시각 |
|
||||
| `transcript` | 문자열 | Claude Code 세션 기록 파일 이름(`~/.claude/projects/<폴더>/<이 값>.jsonl`). 실측을 다시 셀 때 쓴다 |
|
||||
@@ -68,3 +69,17 @@
|
||||
| `ref` | 문자열 | `reverted`면 되돌린 커밋 |
|
||||
|
||||
`task`는 판정을 내린 작업 이름이다.
|
||||
|
||||
`eval`(하네스 판 비교의 실행 하나, `harness-eval` 스킬):
|
||||
|
||||
| 칸 | 형식 | 뜻 |
|
||||
| --- | --- | --- |
|
||||
| `task` | 문자열 | 평가 이름(예: `harness-v2-eval`). 같은 평가의 실행을 묶는다 |
|
||||
| `arm`, `case` | 문자열 | 판(예: `v1`·`v2`), 과제(예: `review-seeded-be`) |
|
||||
| `active_minutes`, `calls`, `output_tokens`, `input_tokens_total` | 정수 | `actual`과 같은 규칙. 서브에이전트 기록을 더한다 |
|
||||
| `start_context`, `max_context` | 정수 | 첫 호출의 입력 토큰(시작 비용), 가장 큰 호출의 입력 토큰 |
|
||||
| `subagents`, `subagent_calls`, `agent_calls`, `agent_return_chars` | 정수 | 서브에이전트 기록 수와 그 호출 수, 메인이 띄운 Agent 호출 수, 서브에이전트가 메인에 돌려준 글자 수(컨텍스트 비용) |
|
||||
| `findings`, `false_findings` | 정수 | 정답을 아는 과제에서 찾은 것, 틀린 발견 |
|
||||
| `note` | 문자열 | 실행 방식(새 세션인가, 서브에이전트로 흉내 냈나), 모델 |
|
||||
|
||||
`ledger.py compare --task <평가 이름>`이 과제·판마다 중앙값과 마지막 판/첫 판 비율을 보인다. `precedents`·회고 대기는 `eval` 줄을 세지 않는다.
|
||||
|
||||
Reference in New Issue
Block a user