Files
claude-harness/plugins/harness/tests/test_hooks.py
T
DongHyeonka 327800798a fix(harness): main checkout 안 worktree를 통째로 지우는 rm을 막는다
문제: H12는 cwd의 main checkout도 rm 허용 폴더에 넣는다. 그래서
main checkout 안 worktree(.claude/worktrees/…)에서 worktree 자신
(`rm -rf ./*`), 옆 worktree(`rm -rf ../w2`), 그 안(`../w2/src`)을
지우는 것이 통과한다(docs/retro/2026-11-08.md C6). 앱은 worktree
세션의 CLAUDE_PROJECT_DIR를 main checkout으로 주므로 실제 세션이 이
경우다.

고친 방법: 허용 폴더는 그대로 두고 지킬 checkout을 따로 센다. 작업
폴더와 그 repo에 `git worktree list`로 등록된 모든 worktree다. /tmp·앱
임시 작업 폴더 밖에서는 checkout 자신이나 그것을 품은 폴더를 통째로
지우면 막는다. 이 세션 작업 폴더와 같지도, 품지도, 그 안에 있지도
않은 checkout(옆 worktree)은 그 안을 지워도 막는다. 「이 세션 작업
폴더」는 cwd의 checkout을 먼저 본다. 프로젝트 폴더를 먼저 보면 main
checkout이 내 것이 되어 옆 worktree 안이 열린다(실제 세션에서 확인).
main checkout 안 다른 자리(worktree 밖)와 main checkout 세션이
worktree 안을 치우는 일은 전처럼 통과한다.
버린 대안: worktree 세션에서 main checkout을 허용 폴더에서 빼기(설계
문구에는 맞지만 지금 통과하는 일을 더 많이 막는다. 근거 없이 넓히지
않았다), `.claude/worktrees` 이름으로 판정(다른 곳에 둔 worktree를
놓친다).

위험: 판정마다 git을 한 번 더 부른다(`worktree list`, 시간 제한
5초). 등록되지 않은 폴더(지운 worktree의 남은 폴더)는 지켜지지
않는다. /tmp 아래 worktree는 일부러 그대로 허용한다. 훅 동작이 바뀌어
harness 0.3.1로 올린다. 같은 판정이 전역 ~/.claude/hooks/guard_bash.py
에도 있어 같이 고쳤다. 이 repo가 병합되고 main checkout을 받고 플러그인을
0.3.1로 올리기 전까지 전역 훅 시험의 사본 비교 2줄은 다르다고 나온다.

검증: 새 시험을 main 훅에 돌려 실패를 먼저 봤다(worktree `./*`,
main checkout `.claude/worktrees`, 프로젝트 폴더가 main일 때
`../w2/src`). 고친 뒤 scripts/check.sh 통과(harness 28·redteam 21·
템플릿 11, expectedFailure 없음). 새 규칙 둘을 하나씩 끄면 각각 시험이
실패한다. 소유자 기계 세션 기록의 rm -r 647개를 프로젝트 폴더 없이,
또 main checkout으로 주고 옛·새 판정을 비교해 바뀐 것은 이 작업의
확인 명령 1개뿐이었다.

Refs: docs/retro/2026-11-08.md C6
2026-11-13 07:05:04 +09:00

474 lines
29 KiB
Python

"""하네스 플러그인 훅과 장부 도구 시험. 표준 라이브러리만 쓴다.
python3 -m unittest discover -s plugins/harness/tests
훅 스크립트에 Claude Code가 주는 것과 같은 JSON을 stdin으로 넣고 종료 코드와 출력을 본다.
"""
import json
import os
import shutil
import subprocess
import sys
import tempfile
import unittest
SCRIPTS = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "scripts")
REPO = os.path.dirname(os.path.dirname(os.path.dirname(SCRIPTS)))
# 시험용 checkout을 둘 /tmp 밖 후보. H12는 /tmp 아래 rm을 일부러 허용하므로 /tmp 안에서는 작업 폴더 판정이 안 보인다
OUTSIDE_TMP_BASES = ("/var/tmp", os.path.expanduser("~"))
def run(script, args=(), payload=None, env=None, cwd=None):
full_env = {k: v for k, v in os.environ.items() if k != "CLAUDE_PROJECT_DIR"}
full_env.update(env or {})
stdin = payload if isinstance(payload, str) else json.dumps(payload or {})
return subprocess.run([sys.executable, "-I", os.path.join(SCRIPTS, script), *args], input=stdin,
capture_output=True, text=True, env=full_env, cwd=cwd, timeout=30)
def bash(command, cwd=REPO):
return {"session_id": "t", "hook_event_name": "PreToolUse", "tool_name": "Bash",
"tool_input": {"command": command}, "cwd": cwd}
def git(cwd, *args):
"""시험용 git. 사용자 설정(서명·훅·기본 브랜치)에 따라 결과가 달라지지 않게 부른다."""
subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@example.com", "-c", "commit.gpgsign=false",
"-c", "core.hooksPath=/dev/null", "-c", "init.defaultBranch=main", "-C", cwd, *args],
check=True, capture_output=True, text=True, timeout=30)
def outside_tmp_base():
"""OUTSIDE_TMP_BASES 중 쓸 수 있는 첫 폴더. 없으면 시험을 건너뛰지 않고 오류로 멈춘다."""
for base in OUTSIDE_TMP_BASES:
real = os.path.realpath(base)
if os.path.isdir(real) and os.access(real, os.W_OK) and not (real + "/").startswith("/tmp/"):
return real
raise RuntimeError("/tmp 밖에 시험용 checkout을 만들 곳이 없다: %s" % ", ".join(OUTSIDE_TMP_BASES))
class H12Asserts:
ALWAYS = {"HARNESS_H12": "always"}
def assert_blocked(self, command, cwd=REPO, env=None):
r = run("guard_bash.py", payload=bash(command, cwd), env={**self.ALWAYS, **(env or {})})
self.assertEqual(r.returncode, 2, "막혀야 한다: %s\n%s" % (command, r.stderr))
self.assertIn("[H12", r.stderr)
def assert_passed(self, command, cwd=REPO, env=None):
r = run("guard_bash.py", payload=bash(command, cwd), env={**self.ALWAYS, **(env or {})})
self.assertEqual(r.returncode, 0, "통과해야 한다: %s\n%s" % (command, r.stderr))
class GuardBashTest(H12Asserts, unittest.TestCase):
"""H12. 여기 사례는 판정의 대표만 둔다. 많은 사례는 소유자 기계 전역 훅 시험에 있다."""
def test_force_push_to_hosting_remote_is_blocked(self):
for c in ("git push --force origin main", "git push -f", "git push origin +feature/x",
"git push --force-with-lease origin claude/x", "git push --mirror origin",
"ssh build 'cd ~/w/x && git push -f origin main'"):
self.assert_blocked(c)
def test_path_remote_transport_passes_but_not_onto_main(self):
self.assert_passed("git push -q -f desktop:/home/u/w/x v3/check:refs/heads/v3/check")
self.assert_blocked("git push -f desktop:/home/u/w/x HEAD:main")
def test_normal_push_and_own_branch_delete_pass(self):
self.assert_passed("git push -u origin claude/x")
self.assert_passed("git push origin --delete review/x")
self.assert_blocked("git push origin --delete main")
def test_rm_outside_or_too_broad_is_blocked(self):
for c in ("rm -rf /", "rm -rf ~", "rm -rf .git", 'rm -rf "$UNSET/"',
"ssh build 'rm -rf ~/workspace/some-repo'"):
self.assert_blocked(c)
def test_rm_inside_project_tmp_and_known_vars_pass(self):
for c in ("rm -rf build dist", "rm -rf /tmp/some-build-x", 'T=$(mktemp -d) && rm -rf "$T"',
"S=/tmp/x; rm -rf $S/out", 'rm -rf "${OUT:?}/build"', "ssh build 'rm -rf ~/x-logs'"):
self.assert_passed(c)
def test_data_deletion_is_blocked(self):
for c in ("psql -c 'DROP DATABASE app'", "redis-cli FLUSHALL", "./gradlew :app:flywayClean",
"ssh build 'docker compose down -v'", "docker volume rm app_db",
"kubectl delete pvc data-0"):
self.assert_blocked(c)
def test_scoped_teardown_and_data_as_text_pass(self):
for c in ("docker compose -p lane-1 -f compose.yml down -v", "docker compose down",
"kubectl delete pod web-1", "grep -rn 'DROP TABLE' docs",
"cat > V2__drop.sql <<'EOF'\nDROP TABLE old;\nEOF"):
self.assert_passed(c)
def test_skips_when_owner_global_hook_has_h12(self):
with tempfile.TemporaryDirectory() as home:
os.makedirs(os.path.join(home, ".claude"))
settings = {"hooks": {"PreToolUse": [{"matcher": "Bash", "hooks": [
{"type": "command", "command": "python3 -I /x/.claude/hooks/guard_bash.py H12"}]}]}}
with open(os.path.join(home, ".claude", "settings.json"), "w") as f:
json.dump(settings, f)
r = run("guard_bash.py", payload=bash("git push --force origin main"), env={"HOME": home})
self.assertEqual(r.returncode, 0, r.stderr)
settings["hooks"]["PreToolUse"][0]["hooks"][0]["command"] = "python3 -I /x/guard_bash.py H1"
with open(os.path.join(home, ".claude", "settings.json"), "w") as f:
json.dump(settings, f)
r = run("guard_bash.py", payload=bash("git push --force origin main"), env={"HOME": home})
self.assertEqual(r.returncode, 2, r.stderr)
def test_broken_input_does_not_block(self):
r = run("guard_bash.py", payload="{not json", env=self.ALWAYS)
self.assertEqual(r.returncode, 1)
class GuardRmCheckoutTest(H12Asserts, unittest.TestCase):
"""H12가 작업 폴더 안 삭제는 통과시키고 작업 폴더 자신·옆 폴더 삭제는 막는지.
이 repo의 checkout을 cwd로 쓰면 결과가 checkout 위치에 따라 달라진다(/tmp 아래면 /tmp 허용에 걸려 통과하고,
main checkout 안의 worktree면 main checkout 허용에 걸려 통과한다). 그래서 /tmp 밖에 checkout과 그 안의
worktree를 직접 만들어 cwd로 넘긴다.
"""
@classmethod
def setUpClass(cls):
base = tempfile.mkdtemp(prefix="h12-test-", dir=outside_tmp_base())
cls.addClassCleanup(shutil.rmtree, base, True)
cls.checkout = os.path.join(base, "repo")
git(base, "init", "-q", cls.checkout)
git(cls.checkout, "commit", "-q", "--allow-empty", "-m", "init")
cls.worktree = os.path.join(cls.checkout, ".claude", "worktrees", "w")
cls.sibling = os.path.join(cls.checkout, ".claude", "worktrees", "w2")
for wt in (cls.worktree, cls.sibling):
git(cls.checkout, "worktree", "add", "-q", "--detach", wt)
# scratchpad처럼 /tmp 아래 둔 worktree. /tmp 아래는 일부러 허용하므로 통째로 지워도 통과해야 한다
cls.tmp_worktree = os.path.join(tempfile.mkdtemp(prefix="h12-test-", dir="/tmp"), "wt")
cls.addClassCleanup(shutil.rmtree, os.path.dirname(cls.tmp_worktree), True)
git(cls.checkout, "worktree", "add", "-q", "--detach", cls.tmp_worktree)
def test_rm_inside_checkout_and_worktree_passes(self):
# 둘 다 허용 폴더로 잡힌다. 아래 시험이 막히는 것은 위치를 몰라서가 아니라 대상이 넓어서다
for cwd in (self.checkout, self.worktree):
for c in ("rm -rf build", "rm -rf build dist node_modules/.cache", "rm -rf ./out/*"):
self.assert_passed(c, cwd=cwd)
self.assert_passed("rm -rf ../../build", cwd=self.worktree) # main checkout 안, worktree 밖(.claude/build)
self.assert_passed("rm -rf .claude/worktrees/w/build", cwd=self.checkout) # main checkout이 worktree 안을 치운다
def test_rm_tmp_worktree_passes(self):
for cwd in (self.checkout, self.worktree):
self.assert_passed("rm -rf %s" % self.tmp_worktree, cwd=cwd)
def test_rm_whole_checkout_or_sibling_is_blocked(self):
for c in ("rm -rf ./*", "rm -rf ../other-repo/src", "rm -rf .claude/worktrees", "rm -rf .claude/worktrees/w"):
self.assert_blocked(c, cwd=self.checkout)
def test_rm_nested_worktree_itself_or_sibling_is_blocked(self):
"""main checkout 안 worktree에서 worktree 자신, 옆 worktree, 그 안, 둘을 품은 폴더를 지우지 못한다."""
for c in ("rm -rf ./*", "rm -rf ../w2", "rm -rf ../w2/src", "rm -rf ..", "rm -rf ../.."):
self.assert_blocked(c, cwd=self.worktree)
def test_project_dir_main_checkout_still_guards_nested_worktree(self):
"""앱이 worktree 세션의 CLAUDE_PROJECT_DIR를 main checkout으로 줄 때도 같은 판정이다(세션 cwd가 먼저다)."""
env = {"CLAUDE_PROJECT_DIR": self.checkout}
for c in ("rm -rf ./*", "rm -rf ../w2", "rm -rf ../w2/src"):
self.assert_blocked(c, cwd=self.worktree, env=env)
for c in ("rm -rf build", "rm -rf ../../build"):
self.assert_passed(c, cwd=self.worktree, env=env)
self.assert_passed("rm -rf .claude/worktrees/w/build", cwd=self.checkout, env=env)
class NudgeSecretsTest(unittest.TestCase):
def nudge(self, content, tool="Write"):
key = "content" if tool == "Write" else "new_string"
r = run("nudge_secrets.py", payload={"tool_name": tool, "tool_input": {"file_path": "a.yml", key: content}})
self.assertEqual(r.returncode, 0, r.stderr)
return json.loads(r.stdout)["hookSpecificOutput"]["additionalContext"] if r.stdout.strip() else ""
def test_real_looking_secrets_nudge_and_are_masked(self):
token = "ghp_" + "a1B2" * 9
for content in ("-----BEGIN OPENSSH PRIVATE KEY-----", "token: " + token,
'db:\n password: "s3cr3t-Value"', "AWS_KEY=AKIA" + "ABCDEFGHIJKLMNOP"):
text = self.nudge(content)
self.assertIn("[N4", text, content)
self.assertNotIn(token, text)
def test_edit_new_string_is_checked(self):
self.assertIn("[N4", self.nudge("api_key = 'q8Zr2LmP0xY'", tool="Edit"))
def test_placeholders_and_references_are_quiet(self):
for content in ("password: ${DB_PASSWORD}", "password=changeme", "api_key: <your-key>",
"AWS_KEY=AKIAIOSFODNN7EXAMPLE", "max_tokens: 4096", "TOKEN_TTL=3600",
"password = request.getParameter(\"pw\")", "secret: dummy-secret-value"):
self.assertEqual(self.nudge(content), "", content)
class LedgerTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.dir = self.tmp.name
self.env = {"HARNESS_STATE_DIR": os.path.join(self.dir, "state")}
self.transcript = os.path.join(self.dir, "abc.jsonl")
def tearDown(self):
self.tmp.cleanup()
def write_transcript(self, lines, mode="w"):
with open(self.transcript, mode) as f:
for line in lines:
f.write(json.dumps(line) + "\n")
@staticmethod
def assistant(msg_id, ts, out, cache_read=100, inp=10, created=5):
return {"type": "assistant", "timestamp": ts, "message": {"id": msg_id, "usage": {
"input_tokens": inp, "cache_creation_input_tokens": created, "cache_read_input_tokens": cache_read,
"output_tokens": out}}}
def test_usage_dedupes_message_ids_and_caps_gaps(self):
self.write_transcript([
{"type": "user", "timestamp": "2026-11-07T10:00:00Z"},
self.assistant("m1", "2026-11-07T10:01:00Z", 50),
self.assistant("m1", "2026-11-07T10:01:01Z", 70), # 같은 메시지가 나뉘어 기록됨: 한 번, 큰 값
self.assistant("m2", "2026-11-07T10:31:01Z", 30, cache_read=400), # 30분 빈틈은 5분만
])
sub = os.path.join(self.dir, "abc", "subagents")
os.makedirs(sub)
with open(os.path.join(sub, "agent-1.jsonl"), "w") as f:
f.write(json.dumps(self.assistant("s1", "2026-11-07T10:02:00Z", 20)) + "\n")
r = run("ledger.py", ["usage", self.transcript], env=self.env)
self.assertEqual(r.returncode, 0, r.stderr)
u = json.loads(r.stdout)
self.assertEqual((u["calls"], u["subagent_calls"], u["output_tokens"]), (3, 1, 120))
self.assertEqual(u["cache_read_tokens"], 600)
self.assertEqual(u["max_context"], 415)
self.assertEqual((u["minutes"], u["active_minutes"]), (31, 6))
def test_stop_hook_reads_incrementally_and_matches_full_scan(self):
self.write_transcript([self.assistant("m1", "2026-11-07T10:00:00Z", 10)])
hook = {"session_id": "s-1", "transcript_path": self.transcript, "cwd": self.dir}
self.assertEqual(run("ledger.py", ["stop"], payload=hook, env=self.env).returncode, 0)
self.write_transcript([self.assistant("m2", "2026-11-07T10:02:00Z", 5)], mode="a")
with open(self.transcript, "a") as f:
f.write('{"type": "assistant", "timestamp": "2026-11-07T10:0') # 쓰는 중인 줄은 다음에
self.assertEqual(run("ledger.py", ["stop"], payload=hook, env=self.env).returncode, 0)
with open(os.path.join(self.env["HARNESS_STATE_DIR"], "usage", "s-1.json")) as f:
saved = json.load(f)["summary"]
self.assertEqual((saved["calls"], saved["output_tokens"], saved["active_minutes"]), (2, 15, 2))
def test_session_start_records_and_hooks_never_print(self):
hook = {"session_id": "s-2", "transcript_path": self.transcript, "cwd": self.dir, "source": "startup"}
r = run("ledger.py", ["session-start"], payload=hook, env=self.env)
self.assertEqual((r.returncode, r.stdout), (0, ""))
with open(os.path.join(self.env["HARNESS_STATE_DIR"], "sessions.jsonl")) as f:
self.assertEqual(json.loads(f.readline())["session_id"], "s-2")
r = run("ledger.py", ["stop"], payload="{broken", env=self.env)
self.assertEqual((r.returncode, r.stdout), (0, ""))
def test_append_checks_fields_and_actual_computes_within(self):
ledger = os.path.join(self.dir, "docs", "ledger", "estimates.jsonl")
bad = {"kind": "estimate", "task": "t1", "minutes": {"p30": 1}}
r = run("ledger.py", ["append", "--ledger", ledger], payload=bad, env=self.env)
self.assertEqual(r.returncode, 1)
self.assertFalse(os.path.exists(ledger))
good = {"kind": "estimate", "task": "t1", "task_kind": "docs", "size": "small",
"minutes": {"p30": 1, "p50": 2, "p80": 10}, "basis": "시험"}
self.assertEqual(run("ledger.py", ["append", "--ledger", ledger], payload=good, env=self.env).returncode, 0)
self.write_transcript([self.assistant("m1", "2026-11-07T10:00:00Z", 10),
self.assistant("m2", "2026-11-07T10:03:00Z", 10)])
r = run("ledger.py", ["actual", "--task", "t1", "--ledger", ledger, self.transcript], env=self.env)
row = json.loads(r.stdout)
self.assertEqual((row["active_minutes"], row["within"]), (3, "p80"))
r = run("ledger.py", ["precedents", "--ledger", ledger], env=self.env)
self.assertIn("| t1 | docs | small | 1/2/10 |", r.stdout)
retro = {"kind": "retro", "task": "t1", "cause": "모름", "level": "gate"}
self.assertEqual(run("ledger.py", ["append", "--ledger", ledger], payload=retro, env=self.env).returncode, 1)
def write_ledger(self, path, rows):
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, "a", encoding="utf-8") as f:
for row in rows:
f.write(json.dumps(row, ensure_ascii=False) + "\n")
@staticmethod
def pair(task, active, why="", at="2026-11-01T10:00+09:00", p=(10, 20, 30), calls=None):
est = {"kind": "estimate", "task": task, "minutes": dict(zip(("p30", "p50", "p80"), p)), "basis": "시험",
"recorded_at": at}
act = {"kind": "actual", "task": task, "active_minutes": active, "why": why, "recorded_at": at}
if calls:
est["calls"], act["calls"] = {"p30": 1, "p50": calls[0], "p80": 99}, calls[1]
return [est, act]
def test_pending_lists_misses_then_tracks_fix_until_verdict(self):
ledger = os.path.join(self.dir, "estimates.jsonl")
self.write_ledger(ledger, self.pair("in", 25) + self.pair("under", 3) + self.pair("over", 31)
+ self.pair("noted", 15, why="검증 대기가 길었다"))
r = run("ledger.py", ["pending", "--ledger", ledger], env=self.env)
self.assertEqual([line.split(":")[0] for line in r.stdout.splitlines()], ["- under", "- over", "- noted"])
retro = {"kind": "retro", "task": "under", "cause": "예측 근거 없음", "level": "architecture", "note": "시험",
"fix": "f1", "recorded_at": "2026-11-02T10:00+09:00"}
self.assertEqual(run("ledger.py", ["append", "--ledger", ledger], payload=retro, env=self.env).returncode, 0)
self.write_ledger(ledger, [{"kind": "estimate", "task": "under", "correction": True,
"recorded_at": "2026-11-02T12:00+09:00"}, # 회고한 작업 자신은 세지 않는다
{"kind": "estimate", "task": "c", "minutes": {"p30": 1, "p50": 2, "p80": 9},
"basis": "시험", "recorded_at": "2026-11-02T12:00+09:00"}]) # 실측 전은 세지 않는다
r = run("ledger.py", ["pending", "--ledger", ledger], env=self.env)
self.assertNotIn("- under", r.stdout)
self.assertIn("- 판정 대기 f1(under, 2026-11-02 적용): 뒤 실측 0건\n", r.stdout)
for task, at in (("a", "2026-11-03T10:00+09:00"), ("b", "2026-11-04T10:00+09:00")):
self.write_ledger(ledger, [{"kind": "estimate", "task": task, "minutes": {"p30": 1, "p50": 2, "p80": 9},
"basis": "시험", "recorded_at": at}])
r = run("ledger.py", ["append", "--ledger", ledger], env=self.env,
payload={"kind": "actual", "task": task, "active_minutes": 40, "recorded_at": at})
self.assertIn("예측 밖이다(예측 1/2/9분, 실측 40분)", r.stdout)
self.assertIn("효과를 판정할 개선 1건", r.stdout)
self.assertIn("뒤 실측 2건. 판정할 때다", run("ledger.py", ["pending", "--ledger", ledger], env=self.env).stdout)
for bad in ({"fix": "f9", "effect": "effective"}, {"fix": "f1", "effect": "모름"}):
r = run("ledger.py", ["append", "--ledger", ledger], env=self.env, payload={"kind": "verdict", "task": "b", **bad})
self.assertEqual(r.returncode, 1, bad)
verdict = {"kind": "verdict", "task": "b", "fix": "f1", "effect": "reverted", "ref": "abc1234"}
self.assertEqual(run("ledger.py", ["append", "--ledger", ledger], payload=verdict, env=self.env).returncode, 0)
self.assertNotIn("판정 대기", run("ledger.py", ["pending", "--ledger", ledger], env=self.env).stdout)
def test_precedents_shows_bias_across_ledgers(self):
one, two = os.path.join(self.dir, "one.jsonl"), os.path.join(self.dir, "two.jsonl")
self.write_ledger(one, self.pair("x", 5, calls=(100, 40)))
self.write_ledger(two, self.pair("y", 15, calls=(100, 60)) + self.pair("z", 40))
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("\n|---|---|---|---|---|---|---|---|---|---|\n", r.stdout) # 마크다운 표 구분선
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)
subprocess.run(["git", "init", "-q", repo], check=True)
hook = {"session_id": "s", "cwd": repo, "source": "startup"}
self.assertEqual(run("ledger.py", ["nudge"], payload=hook, env=self.env).stdout, "") # 장부 없음
ledger = os.path.join(repo, "docs", "ledger", "estimates.jsonl")
self.write_ledger(ledger, self.pair("in", 25))
self.assertEqual(run("ledger.py", ["nudge"], payload=hook, env=self.env).stdout, "") # 빗나간 것 없음
self.write_ledger(ledger, self.pair("under", 3))
self.assertEqual(run("ledger.py", ["nudge"], payload={**hook, "source": "resume"}, env=self.env).stdout, "")
r = run("ledger.py", ["nudge"], payload=hook, env=self.env)
self.assertEqual(r.returncode, 0)
self.assertEqual(len(r.stdout.splitlines()), 1)
self.assertIn("회고 안 한 빗나간 예측 1건", r.stdout)
self.assertEqual(run("ledger.py", ["nudge"], payload=hook, env=self.env).stdout, "") # 하루 한 번
r = run("ledger.py", ["nudge"], payload="{broken", env=self.env)
self.assertEqual((r.returncode, r.stdout), (0, ""))
class TechdebtTest(unittest.TestCase):
def test_lists_only_added_markers(self):
with tempfile.TemporaryDirectory() as d:
def git(*a):
subprocess.run(["git", "-C", d, *a], check=True, capture_output=True)
git("init", "-q", "-b", "main")
git("config", "user.email", "t@example.com")
git("config", "user.name", "t")
git("config", "core.hooksPath", "/dev/null")
with open(os.path.join(d, "a.py"), "w") as f:
f.write("# TODO old\n")
git("add", ".")
git("commit", "-q", "-m", "base")
with open(os.path.join(d, "a.py"), "a") as f:
f.write("x = 1 # noqa\n# FIXME new\n")
r = run("techdebt.py", ["--base", "HEAD"], cwd=d)
self.assertEqual(r.returncode, 0, r.stderr)
self.assertIn("a.py:3 # FIXME new", r.stdout)
self.assertIn("a.py:2 x = 1 # noqa", r.stdout)
self.assertNotIn("TODO old", r.stdout)
if __name__ == "__main__":
unittest.main()