init: company-haness 설계

2026-07-23 17:49:00 +09:00
parent 57d1bab894
commit f668d6a158
962 changed files with 98989 additions and 1 deletions
@@ -0,0 +1,86 @@
+"""Phase 0 headless probe — 실제 claude -p 로 stage 를 헤드리스 실행할 수 있는지, process 를
+넘겨도 원장+artifact 만으로 재개되는지 검증한다. slash 직접 실행이 안 되면 adapter prompt 로 전환.
+
+실제 실행은 CLI 의 `probe --execute` 가 담당(예산·claude CLI 필요). 여기 함수는 순수 로직."""
+import os
+import subprocess
+
+CLAUDE_CMD = os.environ.get("ORGOS_BENCH_CLAUDE", "claude")
+
+
+def build_stage_invocation(command_name, command_body, brief_path):
+    """stage(command)를 headless 로 실행할 사양을 만든다. command_body 가 순수 slash 지시(첫 줄이
+    `# /<name>`)면 direct-slash 로 `/<name>` 프롬프트를, 아니면 command 본문을 펼친 adapter 프롬프트를 쓴다."""
+    first = (command_body.strip().splitlines() or [""])[0].strip()
+    if first.startswith(f"# /{command_name}") or first == f"/{command_name}":
+        mode = "direct-slash"
+        prompt = f"/{command_name}\nbrief: {brief_path}"
+    else:
+        mode = "adapter"
+        prompt = (f"다음 커맨드 절차를 이 brief 로 수행하라.\nbrief: {brief_path}\n\n"
+                  f"--- command: {command_name} ---\n{command_body}")
+    argv = [CLAUDE_CMD, "-p", prompt, "--dangerously-skip-permissions"]
+    return {"mode": mode, "prompt": prompt, "argv": argv}
+
+
+def resume_ok(ledger_before, ledger_after):
+    """새 process 가 원장만으로 재개 가능한가 — stage 원장이 전진하고 accepted artifact 가 생겼는가."""
+    before = set((ledger_before or {}).get("stages", []))
+    after = set((ledger_after or {}).get("stages", []))
+    return bool(after - before) and bool((ledger_after or {}).get("accepted"))
+
+
+def run_probe(arm_commit, out_findings_path, execute=False):
+    """실제 headless probe: worktree(arm_commit) → /ground 1회 headless → 종료 → 새 process 원장 재로드
+    → resume_ok → PROBE-FINDINGS.md 기록(헤드리스 가능성·adapter 여부·stage별 산출 파일 shape).
+    execute=False 면 미실행(사양만, worktree 도 만들지 않는다) — 무거운 실행은 이 플래그 뒤에 숨긴다.
+
+    실행 절차(execute=True):
+    1. git worktree add → arm 커밋 부스트랩(runner.setup_worktree)
+    2. worktree 에서 runner.run_stage(ground) 로 headless 1회 실행(원장+산출물 기록)
+    3. process 종료(암묵적, exec_fn 이 subprocess 로 격리)
+    4. stage 결과를 원장 anchor 로 재구성(새 process 가 원장만 보고 재개 가능한지 시뮬레이션)
+    5. resume_ok 호출로 전진 검증
+    6. PROBE-FINDINGS.md 에 헤드리스 가능/adapter 여부/stage 산출물 shape 기록
+    """
+    plan = {"arm-commit": arm_commit, "executed": execute,
+            "worktree": None, "workspace": None, "stage-result": None, "resume-ok": None}
+    if not execute:
+        _write_findings(out_findings_path, plan)
+        return plan
+
+    from . import paths, runner
+
+    rid = paths.run_id(arm_commit)
+    worktree = runner.setup_worktree(rid, "probe", arm_commit, paths.ROOT)
+    workspace = paths.workspace_dir(rid, "probe")
+    os.makedirs(workspace, exist_ok=True)
+    env = runner.evidence_env(os.path.join(workspace, "evidence-pack"))
+
+    def _exec_fn(argv, cwd, exec_env):
+        r = subprocess.run(argv, cwd=cwd, env=exec_env, capture_output=True, text=True)
+        return {"exit-code": r.returncode, "artifacts": [], "transcript": [r.stdout, r.stderr]}
+
+    ledger_before = {"stages": [], "accepted": []}
+    result = runner.run_stage(worktree, workspace, runner.STAGES[0], env, _exec_fn)
+    # process 종료 후 "새 process" 가 보는 원장 상태 — 이 stage 의 반환값만이 그 process 의 유일한
+    # 산출 신호이므로, 성공한 stage 만 원장에 전진 기록된 것으로 재구성한다(원장 재로드 시뮬레이션).
+    advanced = result["exit-code"] == 0
+    ledger_after = {"stages": [result["stage"]] if advanced else [],
+                     "accepted": [result["stage"]] if advanced else []}
+    ok = resume_ok(ledger_before, ledger_after)
+
+    plan.update({"worktree": worktree, "workspace": workspace, "stage-result": result, "resume-ok": ok})
+    _write_findings(out_findings_path, plan)
+    return plan
+
+
+def _write_findings(path, plan):
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    lines = ["# PROBE-FINDINGS", "",
+              f"executed: {plan.get('executed')}",
+              f"arm-commit: {plan.get('arm-commit')}",
+              f"resume-ok: {plan.get('resume-ok')}",
+              f"stage-result: {plan.get('stage-result')}"]
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines) + "\n")