therookie 0.4.3

package/templates/hook/session-start.sh

@@ -0,0 +1,417 @@
+#!/bin/bash
+# SessionStart hook — Claude Code 세션 시작 시 1회 발사.
+# spec §37 (2026-05-04): UserPromptSubmit 매 turn 발사 → SessionStart 1회로 이동.
+#   - cache_creation 절감 목적 (실측 매 turn ~3K 토큰 invalidate → 0)
+#   - user_prompt 기반 hybrid retrieval 자동 inject 폐지 (안 c-3). 차차가 필요 시 직접
+#     `/api/rookie/context?user_prompt=...` curl 명시 호출.
+# spec §17 (2026-04-30): status 헬스체크 + 큐 drain + 두목 경고 prefix.
+
+# self-reference 방지(spec O-4): 차차 internal LLM 호출(`claude -p` from cli-provider)에서
+# 발사된 hook은 즉시 종료. 두목과의 진짜 대화에서만 동작.
+if [ "$ROOKIE_INTERNAL_INVOCATION" = "1" ]; then
+  exit 0
+fi
+
+# B-3 connection 비콘 — 이 hook 을 등록한 런타임(표면)을 인자로 받는다.
+# Claude Code 등록은 무인자라 기본 claude_code, Codex 등록(codex-setup)은 codex_cli 를 명시 전달.
+# 서버가 x-rookie-surface 를 enum 화이트리스트로 canonicalize(미지원값→local_cli)하므로 안전.
+ROOKIE_SURFACE="${1:-claude_code}"
+
+# §17 큐 라이브러리 로드
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -f "$SCRIPT_DIR/lib/queue.sh" ]; then
+  # shellcheck source=/dev/null
+  . "$SCRIPT_DIR/lib/queue.sh"
+elif [ -f "$HOME/.rookie/bin/lib/queue.sh" ]; then
+  # shellcheck source=/dev/null
+  . "$HOME/.rookie/bin/lib/queue.sh"
+fi
+
+# spec 2026-06-18 crash-recovery: orphan flush recovery helper (transcript.sh → orphan-recovery.sh).
+# 비정상 종료(Stop hook 미발사) 세션의 transcript 를 다음 SessionStart 에서 사후 회수.
+# B6-1 (spec 2026-07-11): config-resolve.sh — env > 로컬(.rookie/, cwd 상향) > 전역 해석 + identity pin.
+for _lib in transcript.sh orphan-recovery.sh skill-gate.sh config-resolve.sh; do
+  if [ -f "$SCRIPT_DIR/lib/$_lib" ]; then
+    # shellcheck source=/dev/null
+    . "$SCRIPT_DIR/lib/$_lib"
+  elif [ -f "$HOME/.rookie/bin/lib/$_lib" ]; then
+    # shellcheck source=/dev/null
+    . "$HOME/.rookie/bin/lib/$_lib"
+  fi
+done
+
+# stdin 의 source 만 파싱 (SessionStart payload). compact 일 때 작업 카드 더 복구.
+STDIN_BODY=$(cat)
+SOURCE=$(printf '%s' "$STDIN_BODY" | node -e "
+  let d=''; process.stdin.on('data',c=>d+=c).on('end',()=>{
+    try { const j = JSON.parse(d); const s=(j.source||'').toString();
+      if (['startup','resume','clear','compact'].includes(s)) process.stdout.write(s);
+    } catch {}
+  });
+" 2>/dev/null || echo "")
+
+# spec 2026-06-18 §3.2: 현재 세션 session_id — orphan scanner 가 진행 중 세션을 정확히 제외(1차 P1-3).
+SESSION_ID=$(printf '%s' "$STDIN_BODY" | node -e "
+  let d=''; process.stdin.on('data',c=>d+=c).on('end',()=>{
+    try { const j = JSON.parse(d); process.stdout.write((j.session_id || j.sessionId || '').toString()); } catch {}
+  });
+" 2>/dev/null || echo "")
+
+# 설계 2026-06-24 §3.4: /clear·compact 는 컨텍스트만 비우고 transcript 는 유지되므로, gate 가
+# 과거 Skill('rookie') 호출을 "현재 로드됨"으로 오인할 수 있다. 현재 transcript byte size 를 epoch 로
+# 기록 + loaded marker 무효화 → UserPromptSubmit gate 는 그 offset 이후만 scan(과거 호출 무시).
+if [ "$SOURCE" = "clear" ] || [ "$SOURCE" = "compact" ]; then
+  TRANSCRIPT_PATH=$(printf '%s' "$STDIN_BODY" | node -e "
+    let d=''; process.stdin.on('data',c=>d+=c).on('end',()=>{
+      try { const j = JSON.parse(d); process.stdout.write((j.transcript_path || j.transcriptPath || '').toString()); } catch {}
+    });
+  " 2>/dev/null || echo "")
+  if command -v skill_gate_record_epoch >/dev/null 2>&1; then
+    skill_gate_record_epoch "$SESSION_ID" "$TRANSCRIPT_PATH" || true
+  fi
+fi
+
+# Codex hook 은 실행 cwd 가 프로젝트와 다를 수 있어 stdin cwd 우선(없으면 $PWD — Claude 무변화).
+REPO_PATH=$(printf '%s' "$STDIN_BODY" | node -e "
+  let d=''; process.stdin.on('data',c=>d+=c).on('end',()=>{
+    try { const j = JSON.parse(d); const c=(j.cwd||'').toString().trim(); process.stdout.write(c||process.argv[1]); }
+    catch { process.stdout.write(process.argv[1]); }
+  });
+" "$PWD" 2>/dev/null || echo "$PWD")
+# REPO_URL 은 REPO_PATH 기준(git -C)으로 뽑는다 — hook 실행 cwd 가 프로젝트와 다르면(Codex) 엉뚱한
+#   repo_url 이 /context 에 실려 서버 matchProject 가 타 프로젝트 id 를 반환 → done-scan 교차매칭.
+REPO_URL=""
+if command -v git >/dev/null; then
+  REPO_URL=$(git -C "$REPO_PATH" remote get-url origin 2>/dev/null || echo "")
+fi
+HOST=$(hostname)
+
+# B6-1 (spec 2026-07-11 §B6): config 해석 — env > 프로젝트-로컬(.rookie/, REPO_PATH 상향 탐색) > 전역.
+# REPO_PATH(stdin cwd) 기준이라 Codex 처럼 hook 실행 cwd 가 프로젝트와 달라도 정확한 config 를 문다.
+if command -v rookie_resolve_credentials >/dev/null 2>&1; then
+  rookie_resolve_credentials "$REPO_PATH" || exit 0
+  ENDPOINT="$ROOKIE_RESOLVED_ENDPOINT"
+  TOKEN="$ROOKIE_RESOLVED_TOKEN"
+  USER_ID="$ROOKIE_RESOLVED_USER_ID"
+else
+  # config-resolve.sh 미배포(구설치) 폴백 — 기존 전역 고정 경로 동작 유지.
+  CONFIG="$HOME/.rookie/config.json"
+  [ -f "$CONFIG" ] || exit 0
+  ENDPOINT=$(node -e "console.log(require('$CONFIG').endpoint)" 2>/dev/null || echo "http://localhost:3000")
+  TOKEN=$(node -e "console.log(require('$CONFIG').token)" 2>/dev/null || echo "")
+  USER_ID=$(node -e "console.log(require('$CONFIG').user_id || '')" 2>/dev/null || echo "")
+  ROOKIE_ACTIVE_CONFIG="$CONFIG"
+fi
+if [ -z "$TOKEN" ]; then
+  exit 0
+fi
+
+# B6-3 (spec 2026-07-11 §B6): 세션 identity pinning — 유효 토큰 hash 기록. Stop hook 이 비교해
+# 세션 도중 계정 전환 시 flush 를 중단한다(교차 오염 차단).
+if [ -n "$SESSION_ID" ] && command -v identity_pin_write >/dev/null 2>&1; then
+  identity_pin_write "$SESSION_ID" "$TOKEN" || true
+fi
+
+ENCODE() {
+  node -e "console.log(encodeURIComponent(process.argv[1] || ''))" "$1"
+}
+
+# §17 H-1 / H-3: status 5s 헬스체크 → UP/DOWN 분기
+# §18 U-3: status body 도 함께 받아 templates manifest 미스매치 비교
+STATUS_FILE=$(mktemp)
+STATUS_CODE=$(curl -sS --max-time 5 -o "$STATUS_FILE" -w "%{http_code}" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "x-rookie-user-id: $USER_ID" \
+  "$ENDPOINT/api/rookie/status" 2>/dev/null) || STATUS_CODE="000"
+
+QUEUE_BEFORE=0
+if command -v queue_count >/dev/null 2>&1; then
+  QUEUE_BEFORE=$(queue_count)
+fi
+
+if [ "$STATUS_CODE" = "200" ]; then
+  # §18→spec 2026-05-26: 서버가 manifest 비교·업데이트 지시를 담당한다.
+  # 여기선 로컬 manifest hash 만 읽어 context 요청 헤더로 보낸다.
+  # LOCAL_HASH="" (옛 install·manifest 없음) → curl 이 빈 값 헤더를 생략 → 서버는 clientHash=null(=conditional 분기)로 처리
+  LOCAL_HASH=""
+  if [ -f "$HOME/.rookie/manifest.json" ]; then
+    LOCAL_HASH=$(node -e "
+      try {
+        const j = require('$HOME/.rookie/manifest.json');
+        process.stdout.write(j.manifest_hash || '');
+      } catch {}
+    " 2>/dev/null || echo "")
+  fi
+
+  # §17 H-4: 큐 drain (오래된 작업이 새 컨텍스트보다 우선)
+  if command -v queue_drain >/dev/null 2>&1; then
+    queue_drain "$ENDPOINT" "$TOKEN" "$USER_ID" >/dev/null 2>&1 || true
+  fi
+
+  # spec 2026-06-18 §3.5: queue_drain 직후 / context GET 직전 — 비정상 종료 세션 사후 복구.
+  # queue 가 먼저 자기 flush marker 를 박은 뒤라 방금 drain 된 세션은 후보에서 제외된다.
+  # helper 는 stdout 미사용(§3.7) — 복구 건수만 ROOKIE_ORPHAN_RECOVERED_COUNT 로 받아 요약 합성.
+  # spec 2026-06-18 Phase 2 (client-assisted): orphan_recover 는 chunk 만 복구하고,
+  # tail fact 추출 대기 세션을 pending 큐로 남긴다. 그 큐를 차차에게 노출해 직접 추출시킨다.
+  ORPHAN_SUMMARY=""
+  if command -v orphan_recover >/dev/null 2>&1; then
+    # 설계 2026-07-02 (Codex 15s SessionStart timeout): orphan_recover 는 비정상 종료 세션의
+    #   transcript 를 서버에 재전송하는데, backlog 이 쌓이면 세션 수만큼 네트워크 왕복이 동기로
+    #   누적돼 hook 이 15s+ 를 점유 → Codex hook timeout. 이 재전송(+sweep)은 세션 진입에 즉시
+    #   필요하지 않으므로 백그라운드로 detach 해 hook 을 즉시 리턴시킨다. `( trap '' HUP … ) & disown`
+    #   으로 부모 hook 이 exit 해도 자식이 reparent 되어 복구를 계속한다. 이번 세션에서 새로 발견되는
+    #   orphan 은 이 세션 컨텍스트엔 안 뜨고 다음 세션 pending 목록에 반영된다(detach 의 수용된 trade-off).
+    #   서브셸은 부모의 source 된 lib 함수(orphan_recover/sweep_all)를 상속받는다.
+    ( trap '' HUP
+      ROOKIE_ORPHAN_CURRENT_SID="$SESSION_ID" orphan_recover "$ENDPOINT" "$TOKEN" "$USER_ID" >/dev/null 2>&1 || true
+
+      # spec 2026-06-18: opportunistic 전체 sweep — 하루 1회 (launchd 없이 진입점 backstop).
+      # 현재 프로젝트 외 다른 프로젝트 + Codex 까지 따라잡는다. tight budget 으로 SessionStart 지연 최소화.
+      # CURRENT_SID 전파로 진행 중 라이브 세션은 sweep 에서도 제외(조기 flush 방지).
+      if command -v sweep_all >/dev/null 2>&1 && command -v sweep_due_today >/dev/null 2>&1 && sweep_due_today; then
+        ROOKIE_ORPHAN_CURRENT_SID="$SESSION_ID" ROOKIE_SWEEP_TIME_BUDGET="${ROOKIE_SWEEP_TIME_BUDGET:-8}" \
+          sweep_all "$ENDPOINT" "$TOKEN" "$USER_ID" >/dev/null 2>&1 || true
+        sweep_mark_ran_today
+      fi
+    ) &
+    disown 2>/dev/null || true
+
+    # orphan_pending 은 로컬 marker 읽기(네트워크 X, 빠름)라 동기 유지 — 이미 쌓인 pending 목록을
+    #   이번 세션 컨텍스트에 즉시 노출한다. 방금 detach 한 재전송이 추가할 신규 pending 은 다음 세션 몫.
+    if command -v orphan_pending_client_extraction >/dev/null 2>&1; then
+      # base(Claude) + codex namespace 의 pending 을 모두 모은다 (Phase 3 sweep 가 Codex 세션을
+      # codex namespace 에 남기므로 — 차차가 Claude 세션에서 Codex tail 까지 추출하게).
+      # P0.1: pending 출력은 JSONL. recovered_at DESC 정렬 후 top-5 만 표시(전체는 rookie doctor).
+      #   목록 폭주(243건 류)가 진입 컨텍스트를 오염시키지 않게 cap. 깨진 줄은 fail-soft skip(P3-5).
+      PENDING_JSONL=$(orphan_pending_client_extraction 2>/dev/null)
+      CODEX_PENDING_JSONL=$(ROOKIE_ORPHAN_DIR="${ROOKIE_ORPHAN_DIR:-$HOME/.rookie/orphan-recovery}/codex" orphan_pending_client_extraction 2>/dev/null)
+      ORPHAN_SUMMARY=$(printf '%s\n%s\n' "$PENDING_JSONL" "$CODEX_PENDING_JSONL" | grep . | node -e '
+        const lines=require("fs").readFileSync(0,"utf8").trim().split("\n").filter(Boolean);
+        const ls=[]; let bad=0;
+        for (const l of lines){ try{ ls.push(JSON.parse(l)); }catch{ bad++; } }   // 줄 단위 try/catch
+        if(!ls.length){ process.exit(0); }
+        // oldest-first(FIFO): 가장 오래된 5건을 먼저 처리해 starvation 방지(두목 결정 2026-06-23).
+        // 최신순이면 오래된 항목이 top-5 에 영영 안 걸려 TTL prune 전까지 잔류한다.
+        ls.sort((a,b)=>(a.recovered_at||"").localeCompare(b.recovered_at||""));
+        const top=ls.slice(0,5).map(x=>"- "+x.sid+" :: "+(x.path||"(경로 미상)")).join("\n");
+        const oldest=ls[0].recovered_at||"-";
+        const skip=bad?" (파싱 실패 "+bad+"건 skip)":"";
+        const shown=Math.min(ls.length,5);
+        const head="🛟 비정상 종료로 복구된 세션 "+ls.length+"건의 tail 기억(fact·진입카드)이 아직 저장되지 않았습니다"+skip+" (가장 오래됨 "+oldest+", 오래된 "+shown+"건부터 처리 권장 — 전체 목록은 rookie doctor). rookie Skill 의 「복구 세션 tail 추출」 절차대로 rookie orphan-extract --batch=5 로 초안을 뽑아 핵심 working_card/evidence/self_rule/personal_fact 만 batch-mutate 후 orphan_mark_client_extracted <sid> 를 호출하세요:";
+        process.stdout.write(head+"\n"+top);
+      ' 2>/dev/null)
+      # B5 (spec 2026-07-11 §B5) — 🛟 블록(orphan tail 추출 지시)이 실제로 노출될 때 served 계측.
+      # 서버는 이 블록을 모른다(로컬 marker 발원) — client POST 로 적재. 공용 헬퍼
+      # _orphan_directive_metric(백그라운드 fail-soft, surface 헤더 포함)로 acted 쪽과
+      # POST 형태를 일원화(리뷰 F13). env 주입으로 이 세션에서 이미 해석한 자격증명 재사용.
+      if [ -n "$ORPHAN_SUMMARY" ] && command -v _orphan_directive_metric >/dev/null 2>&1; then
+        ROOKIE_ENDPOINT="$ENDPOINT" ROOKIE_TOKEN="$TOKEN" ROOKIE_SURFACE="$ROOKIE_SURFACE" \
+          _orphan_directive_metric "served"
+      fi
+    fi
+  fi
+
+  # §37: user_prompt 파라미터 없음 — hybrid retrieval 자동 inject 폐지 (안 c-3)
+  # spec 2026-07-10: inject_budget — Claude Code v2.1.191+ 는 hook 출력 10,000자 초과 시
+  #   파일 persist + preview 만 인라인이라, 서버가 이 예산 이하로 lean prompt 를 조립한다.
+  #   이 hook 경로만 전달한다 — SKILL.md 의 curl(무예산)은 전문을 받는 복구 경로.
+  #   8500 = 10K 임계 − route directive·아래 부가 블록(done 후보·큐 경고·orphan) 여유.
+  INJECT_BUDGET=8500
+  QS="repo_path=$(ENCODE "$REPO_PATH")&inject_budget=$INJECT_BUDGET"
+  if [ -n "$REPO_URL" ]; then
+    QS="$QS&repo_url=$(ENCODE "$REPO_URL")"
+  fi
+  if [ -n "$SOURCE" ]; then
+    QS="$QS&source=$(ENCODE "$SOURCE")"
+  fi
+
+  RESP_FILE=$(mktemp)
+  CTX_CODE=$(curl -sS --max-time 10 \
+    -H "Authorization: Bearer $TOKEN" \
+    -H "x-rookie-hostname: $HOST" \
+    -H "x-rookie-user-id: $USER_ID" \
+    -H "x-rookie-surface: $ROOKIE_SURFACE" \
+    -H "x-rookie-manifest-hash: $LOCAL_HASH" \
+    -o "$RESP_FILE" \
+    -w "%{http_code}" \
+    "$ENDPOINT/api/rookie/context?$QS" 2>/dev/null) || CTX_CODE="000"
+
+  if [ "$CTX_CODE" = "200" ]; then
+    if command -v queue_record_success >/dev/null 2>&1; then
+      queue_record_success
+    fi
+
+    QUEUE_AFTER=0
+    if command -v queue_count >/dev/null 2>&1; then
+      QUEUE_AFTER=$(queue_count)
+    fi
+    WARN=""
+    if [ "$QUEUE_AFTER" -gt 0 ] && command -v queue_warning_prefix >/dev/null 2>&1; then
+      WARN=$(queue_warning_prefix "$(last_success_minutes_ago)" "$QUEUE_AFTER")
+    fi
+
+    # B1-3 (spec 2026-07-11 §B1): 계정 상태줄 — status 응답 account 요약 1줄(+빈-계정 경고).
+    # 구서버(account 필드 없음)·파싱 실패 시 빈 값으로 조용히 생략.
+    ACCOUNT_LINE=$(node -e "
+      try { const j=require(process.argv[1]); const a=j.account||null;
+        if (a && (a.email_masked || a.profile_name)) {
+          let s='[루키] 계정 '+(a.email_masked||a.profile_name);
+          if (typeof a.projects_count==='number') s+=' · 프로젝트 '+a.projects_count;
+          if (typeof a.facts_count==='number') s+=' · 기억 '+(a.facts_count>=1000?Math.round(a.facts_count/100)/10+'k':a.facts_count)+'건';
+          if (a.projects_count===0 && typeof a.facts_count==='number' && a.facts_count<50) s+='\n⚠️ 이 계정은 비어 있습니다 — 본체 계정이 맞는지 확인하세요 (rookie login)';
+          process.stdout.write(s);
+        }
+      } catch {}
+    " "$STATUS_FILE" 2>/dev/null || echo "")
+
+    # 옵션A (spec 2026-07-01-completion-linkage-remove-vs-improve): 완료 후보 감지.
+    #   context 로 이미 받은 current_project.id 를 넘겨 done-scan 이 context 재fetch 없이 doing task 를
+    #   최근 커밋과 경로 강매칭 → 완료 후보 compact 줄만 stdout. 하루 1회(HEAD 변경 시 우회) throttle.
+    #   전역 `rookie` CLI 있을 때만(없으면 조용히 skip — 마무리 reconcile 이 백업). best-effort, 세션 방해 금지.
+    DONE_CANDIDATES=""
+    if command -v rookie >/dev/null 2>&1; then
+      PROJECT_ID=$(node -e "try{const j=require('$RESP_FILE');process.stdout.write((j.current_project&&j.current_project.id)||'')}catch{}" 2>/dev/null || echo "")
+      if [ -n "$PROJECT_ID" ]; then
+        # REPO_PATH(stdin cwd) 로 이동 후 실행 — hook 실행 cwd 가 프로젝트와 다를 수 있어(Codex 등)
+        #   done-scan 의 git log 가 엉뚱한 repo 를 보고 프로젝트 A task 를 repo B 커밋과 오매칭하는 것 방지.
+        DONE_LINES=$(cd "$REPO_PATH" 2>/dev/null && rookie done-scan --project-id="$PROJECT_ID" 2>/dev/null || true)
+        # spec 2026-07-10: 후보 폭주가 additionalContext 10K 임계를 뚫지 않게 상위 5건 cap
+        #   (session-start 주입 경로 한정 — CLI 직접 실행은 무변경).
+        if [ -n "$DONE_LINES" ]; then
+          DONE_TOTAL=$(printf '%s\n' "$DONE_LINES" | grep -c .)
+          if [ "$DONE_TOTAL" -gt 5 ] 2>/dev/null; then
+            DONE_LINES="$(printf '%s\n' "$DONE_LINES" | grep . | head -5)
+…외 $((DONE_TOTAL - 5))건 — 전체는 rookie done-scan"
+          fi
+        fi
+        if [ -n "$DONE_LINES" ]; then
+          DONE_CANDIDATES=$(printf '## 🎯 완료 후보 감지 (git 강매칭)\n아래 doing task 가 커밋 산출물과 매칭됩니다. 두목께 완료 승인을 여쭙고, 승인 시에만 done 처리하세요(자동 done 금지). 두목이 "아직"이면 해당 task detail 에 `__done_defer:<sha>` 를 추가하세요.\n%s' "$DONE_LINES")
+        fi
+      fi
+    fi
+
+    # spec 2026-07-10-context-diet-design.md §2.2: 컨텍스트 다이어트 권고 (주 1회).
+    #   - source=startup 만 (resume/clear/compact 재발화에 권고가 끼어들지 않게)
+    #   - claude_code 표면만 (Codex 측정은 1차 비목표 + Codex hook 15s timeout 보호)
+    #   - throttle 검사는 hook(marker 나이 7일), 기록은 CLI 가 판정 성공 후 (실패 세션 미기록 → 재시도)
+    DIET_BLOCK=""
+    if [ "$SOURCE" = "startup" ] && [ "$ROOKIE_SURFACE" = "claude_code" ]; then
+      DIET_LAST="$HOME/.rookie/context-diet.last"
+      DIET_DUE="1"
+      if [ -f "$DIET_LAST" ]; then
+        DIET_DUE=$(node -e "
+          try { const { statSync } = require('fs');
+            process.stdout.write(Date.now() - statSync(process.argv[1]).mtimeMs > 7*24*60*60*1000 ? '1' : '0');
+          } catch { process.stdout.write('1'); }
+        " "$DIET_LAST" 2>/dev/null || echo "1")
+      fi
+      # 글로벌 rookie 미설치면 배포 CLI 최신 버전으로 폴백 (§2.2).
+      # sort -V 는 BSD(macOS 기본) sort 미보장이라 node 로 semver 최대값을 고른다.
+      DIET_CLI=""
+      if command -v rookie >/dev/null 2>&1; then
+        DIET_CLI="rookie"
+      else
+        DIET_VER=$(node -e "
+          try { const fs=require('fs');
+            const vs=fs.readdirSync(process.env.HOME+'/.rookie/cli').filter(v=>/^\d+\.\d+\.\d+$/.test(v))
+              .sort((a,b)=>{const p=a.split('.').map(Number),q=b.split('.').map(Number);return (p[0]-q[0])||(p[1]-q[1])||(p[2]-q[2]);});
+            process.stdout.write(vs.pop()||'');
+          } catch {}
+        " 2>/dev/null || echo "")
+        if [ -n "$DIET_VER" ] && [ -f "$HOME/.rookie/cli/$DIET_VER/bin/rookie.js" ]; then
+          DIET_CLI="node $HOME/.rookie/cli/$DIET_VER/bin/rookie.js"
+        fi
+      fi
+      if [ "$DIET_DUE" = "1" ] && [ -n "$DIET_CLI" ]; then
+        # shellcheck disable=SC2086 — DIET_CLI 는 "node <path>" 2단어 폴백을 허용해야 해서 의도적 무인용
+        DIET_JSON=$($DIET_CLI context-diet --json 2>/dev/null || true)
+        if [ -n "$DIET_JSON" ]; then
+          # 임계 초과 && !snooze 항목만 1줄씩, 블록 전체 ≤1KB (§2.2). 초과 0 이면 무출력.
+          DIET_BLOCK=$(printf '%s' "$DIET_JSON" | node -e '
+            let d=""; process.stdin.on("data",c=>d+=c).on("end",()=>{
+              let j={}; try { j=JSON.parse(d); } catch { return; }
+              const it=j.items||{}; const lines=[];
+              const num=(n)=>typeof n==="number"?n.toLocaleString("en-US"):"?";
+              const hit=(k)=>it[k]&&it[k].exceeded&&!it[k].snoozed;
+              if (hit("claude_md_project")) lines.push("- claude_md_project: "+num(it.claude_md_project.chars)+"자 (임계 "+num(it.claude_md_project.threshold)+") — 완료 이력·plan 상세를 docs 이관 권고");
+              if (hit("claude_md_total")) lines.push("- claude_md_total: "+num(it.claude_md_total.chars)+"자 (임계 "+num(it.claude_md_total.threshold)+", @import 포함)");
+              if (hit("skills_agents_desc")) lines.push("- skills_agents_desc: "+num(it.skills_agents_desc.chars)+"자 (임계 "+num(it.skills_agents_desc.threshold)+")");
+              if (hit("rookie_self")) lines.push("- rookie_self: SKILL.md "+num(it.rookie_self.skill_chars)+"자 / 주입 "+(it.rookie_self.injected_chars==null?"미기록":num(it.rookie_self.injected_chars)+"자")+" — 루키 자기 다이어트 후보");
+              if (hit("unused_skills")) lines.push("- unused_skills: "+it.unused_skills.count+"개 "+it.unused_skills.window_days+"일간 0회 — 후보 목록: rookie context-diet");
+              if (!lines.length) return;
+              let out="## 🍞 컨텍스트 다이어트 권고 (주 1회)";
+              for (const l of lines) { if ((out+"\n"+l).length>1024) break; out+="\n"+l; }
+              process.stdout.write(out);
+            });
+          ' 2>/dev/null || true)
+        fi
+      fi
+    fi
+
+    # SessionStart 컨텍스트 주입 = JSON hookSpecificOutput.additionalContext.
+    # spec 2026-07-10 (구 2026-06-08 실측 대체): Claude Code v2.1.191+ 는 additionalContext 가
+    #   10,000자를 넘으면 파일 persist + ~2KB preview 만 인라인 주입한다. 서버가 inject_budget
+    #   으로 system_prompt 를 8,500자 이하로 조립하고, 여기선 부가 블록까지 합친 최종 길이를
+    #   9,800자 게이트로 재검사한다(이중 방어 — 구서버·directive·부가 블록 합산 대비).
+    # P0.2: 순서 = system_prompt → done 후보 → queue warning → orphan summary. system_prompt
+    #   (skill 지시·회상가이드·진입카드)가 먼저 와야 preview 안에 들어가 차차가 첫 응답 전에 본다.
+    # 설계 2026-07-02 Codex 컨텍스트 벽: Codex(codex_cli 표면)는 hook 의 additionalContext 를 화면에
+    #   "hook context" 로 통째 렌더한다(접기 불가). 큰 system_prompt 를 여기서 주입하면 매 세션
+    #   컨텍스트 벽이 뜬다. → Codex 에서는 system_prompt 를 MCP `rookie_context` 로 일원화하고, hook 은
+    #   결정론 보장용 "rookie_context 호출 지시 한 줄" 만 남긴다. Claude Code(claude_code)는 hook 이
+    #   주경로라 전체 주입 유지(무손상). done 후보·서버경고·복구알림 작은 블록은 양쪽 공통으로 유지.
+    ROOKIE_SURFACE="$ROOKIE_SURFACE" ROOKIE_ACCOUNT_LINE="$ACCOUNT_LINE" ROOKIE_WARN="$WARN" ROOKIE_ORPHAN_SUMMARY="$ORPHAN_SUMMARY" ROOKIE_DONE_CANDIDATES="$DONE_CANDIDATES" ROOKIE_DIET_BLOCK="$DIET_BLOCK" ROOKIE_SOURCE="$SOURCE" node -e "
+      const fs=require('fs');
+      const path=require('path');
+      const os=require('os');
+      let j={}; try { j=JSON.parse(fs.readFileSync(process.argv[1],'utf8')); } catch {}
+      const parts=[];
+      const isCodex = process.env.ROOKIE_SURFACE === 'codex_cli';
+      if (j.system_prompt) {
+        if (isCodex) parts.push('[Rookie] 세션 컨텍스트(차차 정체성·회사·프로젝트·진행 카드)는 이 hook 이 직접 주입하지 않습니다. 첫 응답 전에 MCP \`rookie_context\` 툴을 1회 호출해 페르소나와 진행 카드를 로드하세요.');
+        else parts.push(j.system_prompt);
+      }
+      // spec 2026-07-10 최종 길이 게이트: system_prompt 는 그대로 두고(예산은 서버 책임),
+      // 부가 블록은 합산 9,800자 이내까지만 append. 초과 블록은 생략 + 안내 1줄.
+      const GATE=9800;
+      const extras=[];
+      // B1-3: 계정 상태줄이 첫 extra — 오-binding 신호가 preview 에 최대한 가깝게.
+      if (process.env.ROOKIE_ACCOUNT_LINE) extras.push(process.env.ROOKIE_ACCOUNT_LINE);
+      if (process.env.ROOKIE_DONE_CANDIDATES) extras.push(process.env.ROOKIE_DONE_CANDIDATES);
+      if (process.env.ROOKIE_WARN) extras.push(process.env.ROOKIE_WARN);
+      if (process.env.ROOKIE_ORPHAN_SUMMARY) extras.push(process.env.ROOKIE_ORPHAN_SUMMARY);
+      if (process.env.ROOKIE_DIET_BLOCK) extras.push(process.env.ROOKIE_DIET_BLOCK);
+      let ctx=parts.join('\n\n');
+      let dropped=false;
+      for (const b of extras) {
+        const next = ctx ? ctx+'\n\n'+b : b;
+        if (next.length > GATE) { dropped=true; continue; }
+        ctx = next;
+      }
+      if (dropped) ctx = ctx ? ctx+'\n\n⚠️ (부가 알림 일부 생략 — rookie doctor 로 확인)' : '⚠️ (부가 알림 일부 생략 — rookie doctor 로 확인)';
+      // spec 2026-07-10-context-diet §2.2: 실주입 크기 기록 — context-diet rookie_self 판정 입력.
+      try {
+        fs.writeFileSync(path.join(os.homedir(),'.rookie','last-injection.json'), JSON.stringify({
+          bytes: Buffer.byteLength(ctx,'utf8'), chars: ctx.length,
+          at: new Date().toISOString(), source: process.env.ROOKIE_SOURCE||'', hook_version: '2026-07-10'
+        }));
+      } catch {}
+      if (ctx) process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:'SessionStart',additionalContext:ctx}}));
+    " "$RESP_FILE" 2>/dev/null || true
+  else
+    if command -v queue_warning_prefix >/dev/null 2>&1; then
+      WARN=$(queue_warning_prefix "$(last_success_minutes_ago)" "$QUEUE_BEFORE")
+      ROOKIE_WARN="$WARN" node -e "const c=process.env.ROOKIE_WARN||''; if(c) process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:'SessionStart',additionalContext:c}}))" 2>/dev/null || true
+    fi
+  fi
+  rm -f "$RESP_FILE"
+else
+  # §17 H-3: DOWN — 두목께 경고 노출 (silent 금지). additionalContext JSON 으로 통일.
+  if command -v queue_warning_prefix >/dev/null 2>&1; then
+    WARN=$(queue_warning_prefix "$(last_success_minutes_ago)" "$QUEUE_BEFORE")
+    ROOKIE_WARN="$WARN" node -e "const c=process.env.ROOKIE_WARN||''; if(c) process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:'SessionStart',additionalContext:c}}))" 2>/dev/null || true
+  fi
+fi
+
+rm -f "$STATUS_FILE"
+exit 0

package/templates/hook/settings.partial.json

@@ -0,0 +1,55 @@
+{
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": ".*",
+        "__rookie_managed": true,
+        "hooks": [
+          { "type": "command", "command": "__FLUSH_SESSION_CMD__" }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": ".*",
+        "__rookie_managed": true,
+        "hooks": [
+          { "type": "command", "command": "__SESSION_START_CMD__" }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Read|Bash",
+        "__rookie_managed": true,
+        "hooks": [
+          { "type": "command", "command": "__PRETOOL_MD_READ_CMD__" }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "__rookie_managed": true,
+        "hooks": [
+          { "type": "command", "command": "__GUARD_DESTRUCTIVE_DB_CMD__" }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Read|Bash|Grep",
+        "__rookie_managed": true,
+        "hooks": [
+          { "type": "command", "command": "__POSTTOOL_RECALL_NUDGE_CMD__" }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "__rookie_managed": true,
+        "hooks": [
+          { "type": "command", "command": "__USER_PROMPT_SKILL_GATE_CMD__", "timeout": 3 }
+        ]
+      }
+    ]
+  }
+}

package/templates/hook/sweep-recovery.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# sweep-recovery.sh — Phase 3 cross-runtime sweep 진입점.
+# spec docs/superpowers/specs/2026-06-18-crash-recovery-orphan-flush.md §4 Phase 3.
+# launchd 가 주기 실행(또는 수동)하여 Claude 전체 프로젝트 + Codex 세션을 사후 회수(chunk 복구).
+# fact 는 Phase 2 client-assisted(pending → 다음 Claude 세션의 차차)로 위임.
+# SessionStart 의 orphan_recover(현재 프로젝트만)와 달리, 이 sweep 은 모든 프로젝트·Codex 의 backstop.
+
+# self-reference 방지(spec O-4): 차차 internal LLM 호출에서 발사되면 즉시 종료.
+[ "$ROOKIE_INTERNAL_INVOCATION" = "1" ] && exit 0
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+for _lib in config-resolve.sh transcript.sh orphan-recovery.sh cross-runtime-sweep.sh; do
+  if [ -f "$SCRIPT_DIR/lib/$_lib" ]; then
+    # shellcheck source=/dev/null
+    . "$SCRIPT_DIR/lib/$_lib"
+  elif [ -f "$HOME/.rookie/bin/lib/$_lib" ]; then
+    # shellcheck source=/dev/null
+    . "$HOME/.rookie/bin/lib/$_lib"
+  fi
+done
+
+# B6-1 (spec 2026-07-11 §B6): config 해석 — env > 로컬(.rookie/, 실행 cwd 상향) > 전역.
+# launchd 실행은 보통 $HOME cwd → 전역 config. B6-4 partition 이 로컬 config 소속 transcript 를 걸러낸다.
+if command -v rookie_resolve_credentials >/dev/null 2>&1; then
+  rookie_resolve_credentials "$PWD" || exit 0
+  ENDPOINT="$ROOKIE_RESOLVED_ENDPOINT"
+  TOKEN="$ROOKIE_RESOLVED_TOKEN"
+  USER_ID="$ROOKIE_RESOLVED_USER_ID"
+else
+  CONFIG="$HOME/.rookie/config.json"
+  [ -f "$CONFIG" ] || exit 0
+  ENDPOINT=$(node -e "console.log(require('$CONFIG').endpoint)" 2>/dev/null || echo "")
+  TOKEN=$(node -e "console.log(require('$CONFIG').token)" 2>/dev/null || echo "")
+  USER_ID=$(node -e "console.log(require('$CONFIG').user_id || '')" 2>/dev/null || echo "")
+fi
+[ -n "$ENDPOINT" ] && [ -n "$TOKEN" ] || exit 0
+
+command -v sweep_all >/dev/null 2>&1 || exit 0
+sweep_all "$ENDPOINT" "$TOKEN" "$USER_ID" || true
+
+# launchd StandardOutPath 로 1줄 요약 (회수 건수). 복구된 fact 추출은 다음 Claude 세션의 차차 몫.
+printf '%s sweep recovered=%s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "${ROOKIE_SWEEP_TOTAL:-0}"
+exit 0

package/templates/hook/user-prompt-skill-gate.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+# UserPromptSubmit hook — rookie Skill 미로드 세션에 "먼저 Skill 호출" 상기 주입.
+# 설계: docs/superpowers/plans/2026-06-24-sessionstart-skill-load-enforcement.md
+# - 로드 감지 = transcript 에서 Skill(rookie) tool_use 를 semantic 파싱 (grep 고정문자열 아님).
+# - hook-owned marker 캐시 = ~/.rookie/skill-gate/<sha256(session_id)>.loaded (로드 후 조용).
+# - epoch = /clear·compact 후 과거 호출 무시 (SessionStart 가 .epoch 기록 → 그 byte offset 이후만 scan).
+# - fail-soft: 어떤 실패도 stderr 없이 안내 주입 또는 조용 종료.
+set -u
+
+# self-reference 방지: 차차 internal LLM 호출(claude -p)에서 발사된 hook 은 즉시 종료.
+[ "${ROOKIE_INTERNAL_INVOCATION:-}" = "1" ] && exit 0
+
+# B6-1 (spec 2026-07-11 §B6): config 해석 — env > 프로젝트-로컬(.rookie/, cwd 상향) > 전역.
+# UserPromptSubmit hook 은 프로젝트 cwd 에서 발사되므로 $PWD 기준. lib 미배포(구설치)면 전역 폴백.
+_GATE_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -f "$_GATE_SCRIPT_DIR/lib/config-resolve.sh" ]; then
+  # shellcheck source=/dev/null
+  . "$_GATE_SCRIPT_DIR/lib/config-resolve.sh"
+elif [ -f "$HOME/.rookie/bin/lib/config-resolve.sh" ]; then
+  # shellcheck source=/dev/null
+  . "$HOME/.rookie/bin/lib/config-resolve.sh"
+fi
+if command -v rookie_resolve_credentials >/dev/null 2>&1; then
+  rookie_resolve_credentials "$PWD" || exit 0
+  TOKEN="$ROOKIE_RESOLVED_TOKEN"
+else
+  CONFIG="$HOME/.rookie/config.json"
+  [ -f "$CONFIG" ] || exit 0
+  TOKEN=$(node -e "try{process.stdout.write(String(require('$CONFIG').token||''))}catch{}" 2>/dev/null)
+fi
+[ -n "$TOKEN" ] || exit 0
+
+GATE_DIR="${ROOKIE_SKILL_GATE_DIR:-$HOME/.rookie/skill-gate}"
+
+# stdin(UserPromptSubmit payload) → node 가 전부 처리(파싱·sha256·marker·epoch·scan·신호·출력 결정).
+# node 단일 덩어리라 fail-soft·stderr 억제가 쉽다. code 안에 작은따옴표 미사용(bash single-quote 보호).
+# 두 갈래(한 turn 한 메시지): skill 미로드 → SKILL_MSG / 로드됨 + 과거-방법 회상 신호 → RECALL_MSG.
+# marker(.loaded)는 "로드됨 캐시"일 뿐 early-return 아님 — 로드 뒤에도 프롬프트 신호를 매 turn 검사(spec 2026-07-07-recall-first §3.1).
+cat | ROOKIE_GATE_DIR="$GATE_DIR" node -e '
+  let d="";
+  process.stdin.on("data",c=>d+=c).on("end",()=>{
+    const SKILL_MSG="⚠️ 이 세션에서 아직 rookie Skill 을 로드하지 않았습니다. 다른 작업·응답 전에 먼저 rookie Skill 을 호출하세요 — 회상(recall)·미link 등록 제안·기억 저장 절차가 그 안에 있습니다. (이미 호출했다면 이 안내는 사라집니다.)";
+    const RECALL_MSG="🧠 이 프롬프트에 과거 맥락·방법 회상 신호가 있습니다. grep·파일 열람·자기판단·두목 되묻기 이전에 GET /api/rookie/recall 을 먼저 호출하세요 (brand.ts 회상-순서 룰).";
+    const injectMsg=(msg)=>{ try{ process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:"UserPromptSubmit",additionalContext:msg}})); }catch{} };
+    try{
+      const fs=require("fs"), path=require("path"), crypto=require("crypto");
+      const gateDir=process.env.ROOKIE_GATE_DIR;
+      const p=JSON.parse(d);
+      const sid=(p.session_id||"").toString();
+      const tp=(p.transcript_path||"").toString();
+      const prompt=(p.prompt||"").toString();
+      // recall 신호(과거 방법 재현) — 과거형 집중. 현재형(구현해)·미래순서(배포 전에/이전에)·조건형(했으면) 제외.
+      const PAST_TIME=/어제|그때|저번|지난번|예전/;
+      const PAST_HOW=/어떻게[\s\S]{0,15}?(했|였|만들었|제작했|구현했|처리했|뽑았|짰|썼|캡[처쳐]했)(?!으면|으려|으실|으세|었으면)|어떻게\s*(하더라|했더라|됐)/;
+      const REPRO=/재현|기억\s*나|했었(?!으면)/;
+      // spec 2026-07-10 §3.B1 — SKILL.md 회상 표와 정합 확장(작업 연속·결정 회상·환경 질의).
+      const CONTINUE=/이어서|이어가|계속\s*(하|해|진행)|마저|어디까지|재개|하던\s*(거|것|작업)/;
+      const DECIDED=/뭐였|뭐더라|왜\s*였|왜\s*그랬|어떻게\s*됐|결정했|정했었/;
+      // ENVQ 는 명사 단독 매칭 금지(코드 얘기 중 "포트" 빈발) — 의문 신호 동반 필수.
+      const ENVQ=/(포트|유저명|계정|경로|도메인|호스트|엔드포인트|서버\s*주소)[^\n]{0,12}(뭐|몇|어디|알아|기억|였)/;
+      const recallSignal = PAST_TIME.test(prompt)||PAST_HOW.test(prompt)||REPRO.test(prompt)||CONTINUE.test(prompt)||DECIDED.test(prompt)||ENVQ.test(prompt);
+      const key= sid ? crypto.createHash("sha256").update(sid).digest("hex") : "";
+      let skillLoaded=false;
+      if(key && fs.existsSync(path.join(gateDir,key+".loaded"))){ skillLoaded=true; }   // marker = 로드됨 캐시(재scan 회피), early-return 아님
+      else {
+        let offset=0;
+        if(key){ try{ const n=parseInt(String(fs.readFileSync(path.join(gateDir,key+".epoch"),"utf8")).trim(),10); if(Number.isFinite(n)&&n>0) offset=n; }catch{} }
+        let text=null;
+        try{ text=fs.readFileSync(tp).slice(offset).toString("utf8"); }catch{ text=null; }   // transcript 없음 → 미로드 취급
+        if(text!==null){
+          for(const line of text.split("\n")){
+            const t=line.trim(); if(!t) continue;
+            let j; try{ j=JSON.parse(t); }catch{ continue; }
+            const m=(j&&j.message)||j;
+            const c=m&&m.content; const blocks=Array.isArray(c)?c:[];
+            for(const b of blocks){ if(b&&b.type==="tool_use"&&b.name==="Skill"&&b.input&&b.input.skill==="rookie"){ skillLoaded=true; break; } }
+            if(!skillLoaded && j&&j.name==="Skill"&&j.input&&j.input.skill==="rookie") skillLoaded=true;
+            if(skillLoaded) break;
+          }
+          if(skillLoaded && key){ try{ fs.mkdirSync(gateDir,{recursive:true,mode:0o700}); fs.writeFileSync(path.join(gateDir,key+".loaded"),JSON.stringify({session_id:sid,transcript_path:tp,loaded_at:new Date().toISOString()}),{mode:0o600}); }catch{} }
+        }
+      }
+      if(!skillLoaded) return injectMsg(SKILL_MSG);   // 미로드 → skill 리마인더 (recall 리마인더 안 함, 한 turn 한 메시지)
+      if(recallSignal) return injectMsg(RECALL_MSG);  // 로드됨 + 과거-방법 신호 → recall 리마인더
+      return;                                         // 로드됨 + 신호 없음 → 조용
+    }catch{ return injectMsg(SKILL_MSG); }   // fail-soft
+  });
+' 2>/dev/null
+
+exit 0

package/templates/launchd/com.rollingmango.rookie-sweep.plist

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!--
+  Phase 3 sweep — OPTIONAL "상시 백그라운드 모드" (spec 2026-06-18-crash-recovery-orphan-flush §4).
+
+  ⚠️ 기본값 아님. 기본 backstop 은 **진입점 opportunistic sweep(하루 1회)** 이다:
+    Claude SessionStart + (후속) Codex rookie_context + 수동 CLI 에서 sweep_due_today 가드로 실행.
+    그래야 OS 스케줄러 없이도, 꺼져 있던 PC도 다음 사용 때 따라잡는다(맥 전용 문제 회피).
+  이 launchd 는 "Claude/Codex 를 한동안 안 열어도 상시 자동 회수" 를 원할 때만 켜는 macOS 전용 옵션.
+  (Linux=systemd timer/cron, Windows=작업 스케줄러 — 별도. 이식 가능한 sweep core 는 후속 Node CLI.)
+
+  __SWEEP_CMD__ = 설치된 sweep-recovery.sh 절대경로 (rookie-cli 가 치환).
+  켜기(두목 승인 후 수동): ~/Library/LaunchAgents/com.rollingmango.rookie-sweep.plist 로 복사 →
+    launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.rollingmango.rookie-sweep.plist
+  끄기: launchctl bootout gui/$(id -u) ~/Library/LaunchAgents/com.rollingmango.rookie-sweep.plist
+  상태: launchctl print gui/$(id -u)/com.rollingmango.rookie-sweep
+  로그: ~/Library/Logs/Rookie/sweep.log / sweep.err
+  StartInterval 21600 = 6시간마다. RunAtLoad=true 로 등록 직후 1회.
+-->
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.rollingmango.rookie-sweep</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>__SWEEP_CMD__</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StartInterval</key>
+  <integer>21600</integer>
+  <key>StandardOutPath</key>
+  <string>__HOME__/Library/Logs/Rookie/sweep.log</string>
+  <key>StandardErrorPath</key>
+  <string>__HOME__/Library/Logs/Rookie/sweep.err</string>
+</dict>
+</plist>