therookie 0.4.5 → 0.4.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "therookie",
-  "version": "0.4.5",
-  "description": "the Rookie \u2014 the AI new hire that remembers what you teach it. A CLI that connects a personal AI memory to AI tools like Claude and Codex.",
+  "version": "0.4.13",
+  "description": "the Rookie — the AI new hire that remembers what you teach it. A CLI that connects a personal AI memory to AI tools like Claude and Codex.",
   "license": "MIT",
   "keywords": [
     "ai",

package/src/commands/update.js

@@ -129,6 +129,20 @@ export async function runUpdate(flags) {
   )
   chmodSync(join(pretoolBinDir, 'posttool-recall-nudge.sh'), 0o755)
 
+  // spec 2026-07-22 §D3 — 회상 없이 파일 수정 착수 시 보정 넛지.
+  cpSync(
+    join(TEMPLATES, 'hook', 'bin', 'work-recall-gate.sh'),
+    join(pretoolBinDir, 'work-recall-gate.sh')
+  )
+  chmodSync(join(pretoolBinDir, 'work-recall-gate.sh'), 0o755)
+
+  // spec 2026-07-25 §3 — recall 소비 실패율 계측 Stop 파서(순수 관측, flush-session 과 별개 훅).
+  cpSync(
+    join(TEMPLATES, 'hook', 'bin', 'recall-episode-metric.sh'),
+    join(pretoolBinDir, 'recall-episode-metric.sh')
+  )
+  chmodSync(join(pretoolBinDir, 'recall-episode-metric.sh'), 0o755)
+
   const libDir = join(binDir, 'lib')
   mkdirSync(libDir, { recursive: true })
   cpSync(join(TEMPLATES, 'hook', 'lib', 'queue.sh'), join(libDir, 'queue.sh'))
@@ -160,6 +174,8 @@ export async function runUpdate(flags) {
     posttoolRecallNudgeCmd: claudeHookCommand(join(pretoolBinDir, 'posttool-recall-nudge.sh')),
     guardCmd: claudeHookCommand(join(binDir, 'guard-destructive-db.sh')),
     skillGateCmd: claudeHookCommand(join(binDir, 'user-prompt-skill-gate.sh')),
+    workRecallGateCmd: claudeHookCommand(join(pretoolBinDir, 'work-recall-gate.sh')),
+    recallEpisodeMetricCmd: claudeHookCommand(join(pretoolBinDir, 'recall-episode-metric.sh')),
   })
 
   // v6 P0b — 글로벌 SKILL.md 갱신 (backup-and-overwrite). 같은 본문이면 no-op.
@@ -171,6 +187,8 @@ export async function runUpdate(flags) {
   if (skillResult.installed) {
     console.log(`✓ Skill 갱신 → ${skillResult.path}`)
     if (skillResult.backup) console.log(`  · 이전 본문 backup → ${skillResult.backup}`)
+  } else if (skillResult.assets_synced > 0) {
+    console.log(`✓ Skill 본문 변경 없음 · 부속 문서 ${skillResult.assets_synced}건 동기화`)
   } else {
     console.log(`✓ Skill 본문 변경 없음 (manifest 동기화만)`)
   }
@@ -201,8 +219,10 @@ async function mergeSettings(settingsPath, partialPath, subs) {
     .replaceAll('__SESSION_START_CMD__', escapeJsonStringValue(subs.sessionStartCmd))
     .replaceAll('__PRETOOL_MD_READ_CMD__', escapeJsonStringValue(subs.pretoolMdReadCmd))
     .replaceAll('__POSTTOOL_RECALL_NUDGE_CMD__', escapeJsonStringValue(subs.posttoolRecallNudgeCmd))
+    .replaceAll('__RECALL_EPISODE_METRIC_CMD__', escapeJsonStringValue(subs.recallEpisodeMetricCmd))
     .replaceAll('__GUARD_DESTRUCTIVE_DB_CMD__', escapeJsonStringValue(subs.guardCmd))
     .replaceAll('__USER_PROMPT_SKILL_GATE_CMD__', escapeJsonStringValue(subs.skillGateCmd))
+    .replaceAll('__WORK_RECALL_GATE_CMD__', escapeJsonStringValue(subs.workRecallGateCmd))
   const partial = JSON.parse(partialRaw)
 
   let current = {}

package/src/lib/deploy-artifacts.js

@@ -7,6 +7,7 @@ import { saveClientManifest } from './manifest.js'
 import { upsertCodexHookBlock } from './codex-config.js'
 import { claudeHookCommand, escapeJsonStringValue } from './hook-command.js'
 import { mergeHooks } from './merge-hooks.js'
+import { syncSkillAssets } from './skill-installer.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -58,6 +59,20 @@ export function installSharedHookRuntime({ scope, home, cwd } = {}) {
   )
   chmodSync(join(pretoolBinDir, 'posttool-recall-nudge.sh'), 0o755)
 
+  // spec 2026-07-22 §D3 — 회상 없이 파일 수정 착수 시 보정 넛지(PostToolUse Bash 마커 + PreToolUse Edit 판정).
+  cpSync(
+    join(TEMPLATES, 'hook', 'bin', 'work-recall-gate.sh'),
+    join(pretoolBinDir, 'work-recall-gate.sh')
+  )
+  chmodSync(join(pretoolBinDir, 'work-recall-gate.sh'), 0o755)
+
+  // spec 2026-07-25 §3 — recall 소비 실패율 계측 Stop 파서(순수 관측, flush-session 과 별개 훅).
+  cpSync(
+    join(TEMPLATES, 'hook', 'bin', 'recall-episode-metric.sh'),
+    join(pretoolBinDir, 'recall-episode-metric.sh')
+  )
+  chmodSync(join(pretoolBinDir, 'recall-episode-metric.sh'), 0o755)
+
   // spec post-v5-decisions §17 — hook offline queue 라이브러리 배포
   const libDir = join(binDir, 'lib')
   mkdirSync(libDir, { recursive: true })
@@ -102,6 +117,7 @@ export async function applyClaudeSetup({ scope, cfg, home, cwd } = {}) {
     .replaceAll('__INSTALLED_AT__', new Date().toISOString())
     .replaceAll('__INSTALLED_BY__', `rookie-cli@${CLI_VERSION}`)
   writeFileSync(join(skillDir, 'SKILL.md'), skillRendered)
+  syncSkillAssets({ targetDir: skillDir, templateDir: join(TEMPLATES, 'skill') })
 
   // Windows 는 claudeHookCommand 가 `bash "<posix>"` 로 감싼다(아래 hook-command.js). macOS/Linux 무변경.
   const settingsResult = await mergeSettings(settingsPath, join(TEMPLATES, 'hook', 'settings.partial.json'), {
@@ -111,6 +127,8 @@ export async function applyClaudeSetup({ scope, cfg, home, cwd } = {}) {
     posttoolRecallNudgeCmd: claudeHookCommand(join(pretoolBinDir, 'posttool-recall-nudge.sh')),
     guardCmd: claudeHookCommand(join(binDir, 'guard-destructive-db.sh')),
     skillGateCmd: claudeHookCommand(join(binDir, 'user-prompt-skill-gate.sh')),
+    workRecallGateCmd: claudeHookCommand(join(pretoolBinDir, 'work-recall-gate.sh')),
+    recallEpisodeMetricCmd: claudeHookCommand(join(pretoolBinDir, 'recall-episode-metric.sh')),
   })
 
   // §18 U-3 — 클라이언트 manifest 저장. 다음 hook turn 부터 미스매치 경고 비교 가능.
@@ -165,8 +183,10 @@ async function mergeSettings(settingsPath, partialPath, subs) {
     .replaceAll('__SESSION_START_CMD__', escapeJsonStringValue(subs.sessionStartCmd))
     .replaceAll('__PRETOOL_MD_READ_CMD__', escapeJsonStringValue(subs.pretoolMdReadCmd))
     .replaceAll('__POSTTOOL_RECALL_NUDGE_CMD__', escapeJsonStringValue(subs.posttoolRecallNudgeCmd))
+    .replaceAll('__RECALL_EPISODE_METRIC_CMD__', escapeJsonStringValue(subs.recallEpisodeMetricCmd))
     .replaceAll('__GUARD_DESTRUCTIVE_DB_CMD__', escapeJsonStringValue(subs.guardCmd))
     .replaceAll('__USER_PROMPT_SKILL_GATE_CMD__', escapeJsonStringValue(subs.skillGateCmd))
+    .replaceAll('__WORK_RECALL_GATE_CMD__', escapeJsonStringValue(subs.workRecallGateCmd))
   const partial = JSON.parse(partialRaw)
 
   let current = {}

package/src/lib/merge-hooks.js

@@ -8,7 +8,7 @@
 // refresh-context.sh 포함 — 과거 UserPromptSubmit 로 실배포됐던 legacy hook.
 // 마커 소실 구버전 설정에서 이를 보존하면 매 turn 대용량 주입 회귀가 남는다(codex R3-P1).
 export const ROOKIE_HOOK_SCRIPTS =
-  /[\\/]\.rookie[\\/]bin[\\/](?:bin[\\/])?(?:flush-session|session-start|user-prompt-skill-gate|guard-destructive-db|pretool-md-read|posttool-recall-nudge|sweep-recovery|refresh-context)\.sh\b/
+  /[\\/]\.rookie[\\/]bin[\\/](?:bin[\\/])?(?:flush-session|session-start|user-prompt-skill-gate|guard-destructive-db|pretool-md-read|posttool-recall-nudge|work-recall-gate|recall-episode-metric|sweep-recovery|refresh-context)\.sh\b/
 
 export function isRookieEntry(entry) {
   if (!entry || typeof entry !== 'object') return false

package/src/lib/skill-installer.js

@@ -1,8 +1,9 @@
 // v6 P0b — Skill 본문 install/upgrade. 기존 init/update 의 인라인 skill 쓰기 로직을
 // backup 옵션과 함께 모듈화. 같은 내용이면 no-op, 다른 내용이면 .bak.<ts> 백업 후 덮어쓰기.
+// 2026-07-18 컨텍스트 다이어트 — SKILL.md 를 코어 + references/ 로 분할하며 부속 파일 동기화 추가.
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
-import { join, dirname } from 'node:path'
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs'
+import { join, dirname, relative, sep } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { homedir } from 'node:os'
 
@@ -16,6 +17,39 @@ const DEFAULT_TEMPLATE = join(
   'SKILL.md'
 )
 
+// templates/skill/ 의 SKILL.md 외 부속 파일(references/*.md 등)을 skill 폴더에 동기화.
+// placeholder 렌더 없음(부속 문서는 정적) — 내용이 다를 때만 덮어쓴다. backup 없음(제품 관리 파일).
+// 템플릿에서 사라진 부속 파일은 지우지 않는다(보수적 — 사용자 추가 파일 보호).
+export function syncSkillAssets({ targetDir, templateDir }) {
+  let synced = 0
+  const walk = (dir) => {
+    let entries
+    try {
+      entries = readdirSync(dir)
+    } catch {
+      return
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry)
+      const st = statSync(full)
+      if (st.isDirectory()) {
+        walk(full)
+        continue
+      }
+      const rel = relative(templateDir, full)
+      if (rel === 'SKILL.md') continue
+      const target = join(targetDir, ...rel.split(sep))
+      const content = readFileSync(full)
+      if (existsSync(target) && readFileSync(target).equals(content)) continue
+      mkdirSync(dirname(target), { recursive: true })
+      writeFileSync(target, content)
+      synced++
+    }
+  }
+  walk(templateDir)
+  return synced
+}
+
 export function installSkill({
   home = homedir(),
   scope = 'global',
@@ -39,17 +73,18 @@ export function installSkill({
     .replaceAll('__INSTALLED_BY__', installedBy)
 
   mkdirSync(targetDir, { recursive: true })
+  const assetsSynced = syncSkillAssets({ targetDir, templateDir: dirname(templatePath) })
 
   let backupPath = null
   if (existsSync(targetPath)) {
     const existing = readFileSync(targetPath, 'utf8')
     if (existing === rendered) {
-      return { installed: false, reason: 'no_change', path: targetPath }
+      return { installed: false, reason: 'no_change', path: targetPath, assets_synced: assetsSynced }
     }
     backupPath = `${targetPath}.bak.${Date.now()}`
     writeFileSync(backupPath, existing)
   }
 
   writeFileSync(targetPath, rendered)
-  return { installed: true, path: targetPath, backup: backupPath }
+  return { installed: true, path: targetPath, backup: backupPath, assets_synced: assetsSynced }
 }

package/src/lib/sweep-core.mjs

@@ -81,15 +81,32 @@ export function parseCodexMessages(filePath) {
   return capTurns(out)
 }
 
-export function codexCwd(filePath) {
+// rollout 첫 non-empty 줄의 session_meta.payload 에서 sweep 판정에 쓰는 필드를 한 번에 뽑는다.
+// spec 2026-07-20-codex-exec-prompt-pollution §4.2 — cwd 만 읽던 것을 originator/source 까지 확장.
+// 파싱 실패·session_meta 부재는 빈 값(fail-open) — 캡처 누락보다 과캡처가 낫다는 기존 sweep 기조.
+export function codexSessionMeta(filePath) {
   try {
     const fd = fs.openSync(filePath, 'r'); const buf = Buffer.alloc(65536)
     const n = fs.readSync(fd, buf, 0, 65536, 0); fs.closeSync(fd)
     const first = buf.toString('utf8', 0, n).split('\n').find(l => l.trim())
     const j = JSON.parse(first)
-    if (j.type === 'session_meta' && j.payload && j.payload.cwd) return j.payload.cwd
+    if (j.type === 'session_meta' && j.payload) {
+      const p = j.payload
+      return { cwd: p.cwd || '', originator: p.originator || '', source: p.source || '' }
+    }
   } catch {}
-  return ''
+  return { cwd: '', originator: '', source: '' }
+}
+
+export function codexCwd(filePath) {
+  return codexSessionMeta(filePath).cwd
+}
+
+// `codex exec` = 비대화형 one-shot. 차차(에이전트)가 도구로 부른 호출이지 사람의 대화가 아니다.
+// 이 rollout 의 role='user' 블록은 에이전트가 쓴 프롬프트라, 저장하면 두목 발화로 오귀속된다.
+// 사람의 Codex 사용(Codex Desktop·codex-tui)은 여기 걸리지 않으므로 그대로 캡처된다.
+export function isCodexExecRollout(meta) {
+  return meta.originator === 'codex_exec' || meta.source === 'exec'
 }
 
 // Claude transcript jsonl 의 첫 cwd 필드 (없으면 ''). codexCwd 와 대칭 — 이슈② repo 역산용.
@@ -393,13 +410,21 @@ export async function recoverCodex({ endpoint, token, userId, sessionsDir, hostn
   for (const fp of cands) {
     if (Date.now() >= deadline) break
     const sid = sessionIdFromPath(fp, 'codex'); if (!sid || deferBlocked(sid, codexOpts)) continue
-    const messages = parseCodexMessages(fp); if (!messages.length) continue
-    const repoPath = codexCwd(fp) || undefined
+    // spec 2026-07-20-codex-exec-prompt-pollution §4.2.1 — session_meta 를 먼저 읽는다.
+    // 메시지 파싱은 skip 대상이 아닐 때로 미룬다(계약 순서 = 코드 순서, 불필요한 파싱 제거).
+    const meta = codexSessionMeta(fp)
+    const repoPath = meta.cwd || undefined
     // B6-4: Claude 경로(recoverProject)와 대칭 — cwd 불명·디렉토리 소실 보류 + 타 config 소속 skip.
     if (!repoPath || !fs.existsSync(repoPath)) continue
     if (opts.activeConfigPath && configPathForCwd(repoPath) !== opts.activeConfigPath) continue
     // B6-3: identity pin 불일치 보류 (recoverProject 와 대칭).
     if (identityPinMismatch(sid, token, opts)) continue
+    // §4.2.1 — 격리 게이트(위 3줄)를 **통과한 뒤에만** 소비 완료 처리한다. 앞에서 marker 를 박으면
+    // 타 계정 소유 세션을 현재 config 가 소비해버려 B6-4 를 깬다.
+    // marker 없이 그냥 continue 하면 매 sweep 재후보가 되어 최신순+cap 아래 사람 세션을 굶긴다.
+    // 재시도 대상이 아니므로 pending·deferred·dead-letter 는 남기지 않는다.
+    if (isCodexExecRollout(meta)) { markBaseline(sid, 'codex_exec', codexOpts); continue }
+    const messages = parseCodexMessages(fp); if (!messages.length) continue
     if (await recoverOne({ endpoint, token, userId, fp, sid, messages, hostname, repoPath, opts: codexOpts })) count++
   }
   return count

package/templates/hook/bin/recall-episode-metric.sh

@@ -0,0 +1,231 @@
+#!/bin/bash
+# Stop hook — 세션 raw transcript 를 episode 단위로 사후 파싱해 recall 소비 실패율을 계측한다.
+# spec: docs/superpowers/specs/2026-07-25-recall-consumption-enforcement.md §3
+#
+# 8회 반복된 "회상 안 함 / 해놓고 안 믿고 밖에서 찾음" 문제의 근본 = 재발률을 한 번도 측정하지
+# 않아 "고쳤다"가 반증 불가능했던 것. 이 훅은 관측만 한다 — 어떤 도구도 차단하지 않는다.
+#
+# flush-session.sh 와 별개의 Stop 훅(무간섭). Stop 은 매 assistant 응답마다 발사되고 transcript 는
+# 누적이라, 파서가 매번 전체를 재계산해 세션의 모든 episode 를 upsert 로 보낸다(서버 UNIQUE 멱등).
+#
+# IMPORTANT: set -e 금지. 차단 절대 X — 항상 exit 0.
+set +e
+
+# self-reference 방지: 차차 internal LLM 호출에서 발사된 hook 은 즉시 종료.
+[ "${ROOKIE_INTERNAL_INVOCATION:-}" = "1" ] && exit 0
+command -v node >/dev/null 2>&1 || exit 0
+
+INPUT=$(cat 2>/dev/null) || exit 0
+[ -z "$INPUT" ] && exit 0
+
+SESSION_ID=$(printf '%s' "$INPUT" | 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)
+TRANSCRIPT_PATH=$(printf '%s' "$INPUT" | 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)
+[ -z "$SESSION_ID" ] && exit 0
+[ -z "$TRANSCRIPT_PATH" ] && exit 0
+[ -f "$TRANSCRIPT_PATH" ] || exit 0
+
+# config 해석 (env > 프로젝트-로컬 > 전역) — session-start.sh 패턴.
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -f "$SCRIPT_DIR/lib/config-resolve.sh" ]; then
+  # shellcheck source=/dev/null
+  . "$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
+  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
+[ -z "$TOKEN" ] && exit 0
+[ -z "$ENDPOINT" ] && exit 0
+
+# identity pin — 세션 도중 계정 전환 시 이전 계정 transcript 로 계산한 metric 이 현재 owner 로
+# 오귀속되는 교차 오염 차단(flush-session.sh 패턴, codex 코드검토 P1). pin 없음(구세션)은 통과.
+if command -v identity_pin_check >/dev/null 2>&1; then
+  if ! identity_pin_check "$SESSION_ID" "$TOKEN"; then
+    command -v identity_pin_log_mismatch >/dev/null 2>&1 && identity_pin_log_mismatch "$SESSION_ID" "recall-episode" || true
+    exit 0
+  fi
+fi
+
+BND_DIR="${ROOKIE_RECALL_EPISODE_DIR:-$HOME/.rookie/recall-episode}"
+
+# transcript 를 episode[] JSON 으로 재구성. 회상 신호 정규식은 user-prompt-skill-gate.sh 와 정합(spec §3.2).
+EPISODES=$(ROOKIE_TP="$TRANSCRIPT_PATH" ROOKIE_SID="$SESSION_ID" ROOKIE_BND_DIR="$BND_DIR" node -e '
+try {
+  const fs=require("fs"), path=require("path"), crypto=require("crypto");
+  const tp=process.env.ROOKIE_TP, sid=process.env.ROOKIE_SID, bndDir=process.env.ROOKIE_BND_DIR;
+
+  // ── 회상 신호 정규식 (user-prompt-skill-gate.sh L59-70 정합) ──────────────
+  const PAST_TIME=/어제|그때|저번|지난번|예전|아까|(방금|(\d+|한|두|두어|세|네|몇)\s*(분|시간|일|주|주일|달|개월|년))\s*전(?=[\s,.!?)\]]|$|에|부터|까지|의|엔|은|는|이|가|도|만|과|와|랑)|(전|이전)에\s*(만든|만들었|했던|하던|쓰던|썼던|정한|결정한|작업한|구현한|짠)/;
+  const PAST_HOW=/어떻게[\s\S]{0,15}?(했|였|만들었|제작했|구현했|처리했|뽑았|짰|썼|캡[처쳐]했)(?!으면|으려|으실|으세|었으면)|어떻게\s*(하더라|했더라|됐)/;
+  const REPRO=/재현|기억\s*나(?!면|다면|시|실|셔|세)|했었(?!으면)|했잖|하지\s*않았(?:나|어|었)/;
+  const AMNESIA=/기억(을|은|이)?\s*(못|안)\s*(하|해|되|나|난)(?!면|다면|시|실|셔|세)|까먹(?!지)|처음\s*(인\s*것|인|것)\s*처럼|또\s*(잊(?!지)|까먹(?!지))/;
+  const CONTINUE=/이어서|이어가|계속\s*(하|해|진행)|마저|어디까지|재개|하던\s*(거|것|작업)/;
+  const DECIDED=/뭐였|뭐더라|왜\s*였|왜\s*그랬|어떻게\s*됐|결정했|정했었/;
+  const ENVQ=/(포트|유저명|계정|경로|도메인|호스트|엔드포인트|서버\s*주소)[^\n]{0,12}(뭐|몇|어디|알아|기억|였)/;
+  const isSignal=(t)=>PAST_TIME.test(t)||PAST_HOW.test(t)||REPRO.test(t)||CONTINUE.test(t)||DECIDED.test(t)||ENVQ.test(t)||AMNESIA.test(t);
+
+  // ── compact/clear boundary offsets (이 transcript 것만, 정렬) ──────────────
+  let boundaries=[];
+  try {
+    const key=crypto.createHash("sha256").update(sid).digest("hex");
+    const raw=fs.readFileSync(path.join(bndDir,key+".boundaries"),"utf8");
+    for(const line of raw.split("\n")){ const s=line.trim(); if(!s) continue;
+      try{ const b=JSON.parse(s); if(b && b.transcript_path===tp && typeof b.offset_bytes==="number") boundaries.push(b.offset_bytes); }catch{} }
+    boundaries.sort((a,b)=>a-b);
+  } catch {}
+  // episode 시작 offset 이후 처음 나오는 boundary (episode 를 그 지점에서 강제 종료).
+  const firstBoundaryAfter=(start)=>{ for(const b of boundaries){ if(b>start) return b; } return Infinity; };
+
+  // ── transcript 순차 파싱 (byte offset 추적) ──────────────
+  const buf=fs.readFileSync(tp);
+  const full=buf.toString("utf8");
+  const rawLines=full.split("\n");
+  const episodes=[];
+  let cur=null;            // 현재 episode
+  let seq=0;
+  let off=0;               // 현재 라인 시작 byte offset
+  const userText=(m)=>{
+    const c=m.content;
+    if(typeof c==="string") return c.trim();
+    if(Array.isArray(c)) return c.filter(b=>b&&b.type==="text"&&typeof b.text==="string").map(b=>b.text).join("\n").trim();
+    return "";
+  };
+  const closeIfPastBoundary=(lineOff)=>{ if(cur && lineOff>=cur._boundary){ cur=null; } };
+
+  for(const raw of rawLines){
+    const lineOff=off;
+    off+=Buffer.byteLength(raw,"utf8")+1;   // +1 = split 로 사라진 \n
+    const t=raw.trim(); if(!t) continue;
+    let j; try{ j=JSON.parse(t); }catch{ continue; }
+    const m=j.message||j;
+    const role=m&&m.role;
+
+    // boundary 를 넘어선 라인은 이전 episode 에 귀속시키지 않는다.
+    closeIfPastBoundary(lineOff);
+
+    // recall 응답의 verified_solution 판정(codex P1) — recall 호출 이후 + "tool_result 성격 라인"에서만
+    //  `"verified_solution"` JSON key 를 스캔한다. 일반 대화(text 블록)의 단어 언급은 tool_result 가
+    //  아니라 배제된다. transcript shape 다양성 커버: ① user content[] 의 tool_result 블록
+    //  ② top-level toolUseResult 필드 ③ type==="tool_result" 라인. (MCP recall 응답도 results+meta 를
+    //  stringify 해 이 JSON key 를 남긴다 — packages/rookie-mcp/src/tools.js.)
+    if(cur && cur.recall_called && !cur.verified_solution_served){
+      // raw 라인 t 는 JSON 이스케이프(\"verified_solution\")라 key 패턴이 안 맞는다 → tool_result 의
+      //  **파싱된** 필드만 모아 스캔(이스케이프 해제 상태). 이게 tool_result 한정 + JSON key 정확도를 동시에 준다.
+      let probe="";
+      const cc=m&&m.content;
+      if(Array.isArray(cc)){
+        for(const b of cc){
+          if(b && b.type==="tool_result"){
+            probe += typeof b.content==="string" ? b.content
+              : Array.isArray(b.content) ? b.content.map(x=>x&&typeof x.text==="string"?x.text:"").join(" ")
+              : JSON.stringify(b.content||"");
+          }
+        }
+      }
+      if(j.toolUseResult!==undefined) probe += " " + (typeof j.toolUseResult==="string"?j.toolUseResult:JSON.stringify(j.toolUseResult));
+      if(j.type==="tool_result" && j.content!==undefined) probe += " " + (typeof j.content==="string"?j.content:JSON.stringify(j.content));
+      if(probe && /"verified_solution"/.test(probe)) cur.verified_solution_served=true;
+    }
+
+    if(role==="user"){
+      const txt=userText(m);
+      if(!txt) continue;                     // tool_result-only user 라인 등은 프롬프트 아님
+      const sig=isSignal(txt), amn=AMNESIA.test(txt);
+      // 직전 회상 episode 의 "다음 프롬프트"가 기억무시 지적이면 표시(관련 기억 있었는데 되물음).
+      if(cur && amn && cur.recall_called) cur.amnesia_next_prompt=true;
+      if(sig){
+        cur={
+          episode_seq: seq++,
+          episode_start_byte_offset: lineOff,
+          recall_signal: true, recall_called: false, verified_solution_served: false,
+          external_search: false, amnesia_next_prompt: false,
+          first_action_after_recall: null, failure_classes: [],
+          _boundary: firstBoundaryAfter(lineOff),
+          _recallSeen: false,
+        };
+        episodes.push(cur);
+      }
+      // 회상 신호 아닌 user 프롬프트는 현재 episode 를 이어간다(별 처리 없음, spec §3.2).
+      continue;
+    }
+
+    if(role==="assistant" && cur){
+      const c=m.content;
+      const blocks=Array.isArray(c)?c:[];
+      let hadText=false, sawToolThisMsg=false;
+      for(const b of blocks){
+        if(!b||typeof b!=="object") continue;
+        if(b.type==="text" && typeof b.text==="string" && b.text.trim()) hadText=true;
+        if(b.type==="tool_use"){
+          sawToolThisMsg=true;
+          const name=String(b.name||"");
+          const cmd=b.input&&typeof b.input.command==="string"?b.input.command:"";
+          let action="other";
+          if(/recall/i.test(name) || /api\/rookie\/recall/.test(cmd)) action="recall";
+          else if(/^(WebSearch|WebFetch)$/.test(name)) action="external_search";
+          // 외부 Bash HTTP(curl/wget 로 밖에서 답 찾기)도 외부검색 — recall/내부 API·로컬 dev 는 제외(codex P1·P2).
+          else if(name==="Bash" && /\b(curl|wget)\b/.test(cmd) && /https?:\/\//.test(cmd) && !/api\/rookie/.test(cmd) && !/(localhost|127\.0\.0\.1|0\.0\.0\.0)/.test(cmd)) action="external_search";
+          else if(/^(Edit|Write|NotebookEdit)$/.test(name)) action="edit";
+          else if(name==="AskUserQuestion") action="ask";
+          if(action==="recall"){ cur.recall_called=true; cur._recallSeen=true; }
+          if(action==="external_search"){ cur.external_search=true; }
+          // recall 이후의 첫 실질 행동을 1회만 기록.
+          if(cur._recallSeen && action!=="recall" && cur.first_action_after_recall===null){
+            cur.first_action_after_recall=action;
+          }
+        }
+      }
+      // recall 을 받고서 도구 없이 텍스트로만 답하면(=자체 지식/재조사) self_answer 근사.
+      if(cur._recallSeen && !sawToolThisMsg && hadText && cur.first_action_after_recall===null){
+        cur.first_action_after_recall="self_answer";
+      }
+      continue;
+    }
+
+  }
+
+  // ── 실패 클래스 판정 (프록시 — spec §2·§8) ──────────────
+  for(const e of episodes){
+    const fc=[];
+    if(e.recall_signal && !e.recall_called) fc.push("missed_recall");
+    if(e.recall_called && (e.first_action_after_recall==="external_search" || (e.external_search && !["consume","edit","ask"].includes(e.first_action_after_recall||""))))
+      fc.push("external_search_before_consumption");
+    // self_answer(도구 없이 텍스트 답변)는 정상 소비일 수도 있어 이탈로 단정하지 않는다(codex P1) —
+    //  명확한 이탈(외부검색)만 ignored 로 센다. 프록시 한계상 보수적으로(false positive < false negative).
+    if(e.verified_solution_served && e.first_action_after_recall==="external_search")
+      fc.push("ignored_verified_solution");
+    if(e.recall_called && e.amnesia_next_prompt) fc.push("user_correction_after_memory_available");
+    e.failure_classes=fc;
+    delete e._boundary; delete e._recallSeen;
+  }
+
+  // route schema 는 max 500 — 긴 세션이 400 으로 전량 드롭되지 않게 최근 500 episode 만 보낸다(codex P2).
+  process.stdout.write(JSON.stringify(episodes.slice(-500)));
+} catch { process.stdout.write("[]"); }
+' 2>/dev/null)
+
+[ -z "$EPISODES" ] && exit 0
+[ "$EPISODES" = "[]" ] && exit 0
+
+BODY=$(ROOKIE_SID="$SESSION_ID" ROOKIE_EP="$EPISODES" node -e 'try{process.stdout.write(JSON.stringify({session_id:process.env.ROOKIE_SID,episodes:JSON.parse(process.env.ROOKIE_EP)}))}catch{}' 2>/dev/null)
+[ -z "$BODY" ] && exit 0
+
+# 계측 POST — 세션 종료를 지연시키지 않게 background + fail-soft.
+( curl -sS --max-time 8 -X POST \
+    -H "Authorization: Bearer $TOKEN" \
+    -H "x-rookie-hostname: $(hostname)" \
+    -H "x-rookie-user-id: $USER_ID" \
+    -H "Content-Type: application/json" \
+    -d "$BODY" \
+    "$ENDPOINT/api/rookie/metric/recall-episode" >/dev/null 2>&1 || true ) &
+disown 2>/dev/null || true
+
+exit 0

package/templates/hook/bin/work-recall-gate.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+# 작업 착수 회상 보정 넛지 — spec docs/superpowers/specs/2026-07-22-pre-work-recall-gate.md §D3
+#              + 되묻기 전 회상 게이트 — docs/superpowers/plans/2026-07-24-ask-before-recall-gate.md
+#
+# 한 스크립트가 세 갈래를 맡는다:
+#   PostToolUse(Bash)      → 명령이 실제 recall 호출이면 `.recalled` 마커 기록
+#   PreToolUse(Edit|Write) → 마커가 없으면(이 세션 recall 0회) 세션당 1회 넛지 주입
+#   PreToolUse(AskUserQuestion) → soft-deny(pass-토글): 1차 deny + 회상 재확인 지시, 재시도 통과
+#
+# ⚠️ Edit/Write 는 **보정 넛지**다(additionalContext = 다음 모델 입력 리마인더, 차단 아님).
+#    AskUserQuestion 만 permissionDecision deny — 질문은 사용자에게 나가는 순간이 사고라
+#    사후 리마인더로는 못 막는다(2026-07-24: recall 해놓고 안 믿고 되물은 사고, codex R1 P1).
+#    "착수 *전*" 판정은 SKILL.md 의 작업 착수 전 회상 게이트(규범)가 맡는다 — 이 훅은 하한선.
+#
+# 한계(설계 명시): 세션 단위로만 본다. 세션 초반에 무관한 recall 1회를 했으면 이후 다른 기능을
+# 수정해도 침묵한다. 대상 단위 판정은 규범 축 담당.
+#
+# IMPORTANT: set -e 금지. 차단 절대 X — 항상 exit 0.
+set +e
+
+# self-reference 방지: 차차 internal LLM 호출에서 발사된 hook 은 즉시 종료.
+[ "${ROOKIE_INTERNAL_INVOCATION:-}" = "1" ] && exit 0
+
+INPUT=$(cat 2>/dev/null) || exit 0
+[ -z "$INPUT" ] && exit 0
+command -v node >/dev/null 2>&1 || exit 0
+
+GATE_DIR="${ROOKIE_RECALL_GATE_DIR:-$HOME/.rookie/recall-gate}"
+
+# payload 는 tool_response 까지 포함해 커질 수 있다 — argv 금지, stdin 으로 넘긴다(ARG_MAX).
+printf '%s' "$INPUT" | ROOKIE_GATE_DIR="$GATE_DIR" node -e '
+let raw="";
+process.stdin.on("data",c=>raw+=c).on("end",()=>{
+  const MSG="✋ 이 세션에서 recall 을 한 번도 안 한 채 파일 수정에 들어갑니다. 이 파일·기능이 전에 하던 작업과 이어지는 것이라면 GET /api/rookie/recall 로 먼저 확인하세요 — 이미 고친 걸 다시 고치는 사고의 방지선입니다.";
+  try{
+    const fs=require("fs"), path=require("path"), crypto=require("crypto");
+    const gateDir=process.env.ROOKIE_GATE_DIR;
+    let j; try{ j=JSON.parse(raw); }catch{ return; }
+    if(!j || typeof j!=="object") return;
+
+    const sid=String(j.session_id||j.sessionId||process.env.CLAUDE_SESSION_ID||"");
+    if(!sid) return;   // sid 없음 → 미주입(공유 마커로 영구 침묵하는 것보다 안전)
+    const key=crypto.createHash("sha256").update(sid).digest("hex");
+    const tool=j.tool_name;
+    const input=j.tool_input||{};
+
+    // 마커 원자적 생성 — 같은 batch 에 Edit 가 병렬로 여러 개 와도 한 번만 통과한다.
+    const claim=(name)=>{
+      try{
+        fs.mkdirSync(gateDir,{recursive:true,mode:0o700});
+        fs.writeFileSync(path.join(gateDir,key+name),JSON.stringify({session_id:sid}),{flag:"wx",mode:0o600});
+        return true;
+      }catch{ return false; }   // 이미 있음(EEXIST) 또는 쓰기 실패 → 통과 못 함
+    };
+    const has=(name)=>{ try{ return fs.existsSync(path.join(gateDir,key+name)); }catch{ return false; } };
+
+    // ── recall 마커 기록 ────────────────────────────────────────────────
+    // MCP 경로(rookie_recall 툴)도 실제 회상이다 — 툴 이름으로 인정(codex 코드 R1 P2).
+    if(/recall/i.test(String(tool||""))){ claim(".recalled"); return; }
+
+    // PostToolUse(Bash): 실제 recall 호출만 인정.
+    // "api/rookie/recall" 문자열만 보면 rg 검색·문서 열람도 회상으로 세어지고(설계 R2 P2),
+    // curl 동반만 요구하면 `rg "curl.*api/rookie/recall"`·`echo curl …` 도 통과한다(코드 R1 P2).
+    // → curl 이 **명령어 자리**에 있어야 하고, 명령이 검색·출력 도구로 시작하면 배제한다.
+    // 남는 한계(허용): 셸 파서가 아니라 문자열 스캔이라, heredoc·따옴표 안의 "&& curl …/recall" 은
+    // 실제 호출 없이 마커를 만든다. 넛지 1건을 놓치는 비용뿐이고 셸 파싱 없이는 못 가른다.
+    if(tool==="Bash"){
+      const cmd=String(input.command||"");
+      // 구분자 뒤 env 대입(TOKEN=x)·sudo 옵션·개행까지 허용 — 전부 실제 command-position curl 이다(코드 R2 P2).
+      const curlIsCommand=/(^|[;&|(\n]|&&|\|\|)[ \t]*(?:\w+=\S*[ \t]+)*(?:sudo(?:[ \t]+-\w+)*[ \t]+)*curl\b/.test(cmd);
+      const startsWithProbe=/^\s*(rg|grep|egrep|fgrep|ag|ack|echo|printf|cat|less|more|head|tail|sed|awk|find)\b/.test(cmd);
+      if(curlIsCommand && !startsWithProbe && /api\/rookie\/recall/.test(cmd)) claim(".recalled");
+      return;   // Bash 는 넛지 대상 아님
+    }
+
+    // ── PreToolUse(AskUserQuestion): soft-deny pass-토글 ────────────────────
+    // 되묻기는 나가는 순간이 사고 — 1차는 deny + 회상 재확인 지시, 재시도(.ask-pass 소비)는 통과.
+    // plan 2026-07-24 §4.1. deny 는 이 정상 판정 경로에서만 — 예외·IO 실패는 전부 통과(fail-safe).
+    if(tool==="AskUserQuestion"){
+      const DENY_A="✋ 되묻기 전에 회상부터: 이 세션에서 recall 을 한 번도 안 했습니다. 물으려는 내용으로 GET /api/rookie/recall 을 먼저 호출해 관련 있는 최신 결과가 있는지 확인하세요. 없거나 0건이면 그대로 다시 AskUserQuestion 을 호출하세요 — 이번 한 번만 멈춥니다.";
+      const DENY_B="✋ 이 세션에서 이미 recall 을 했습니다. 지금 물으려는 내용의 답이 그 회상 결과에 이미 있진 않은지 다시 보세요 — 단, 그 결과가 이 주제와 무관하거나 0건이었다면 이 주제로 재-recall 하세요. 회상해 놓고 안 믿고 되묻는 것이 \"처음인 것처럼\" 사고의 핵심입니다. 확인 후에도 답이 없으면 그대로 다시 AskUserQuestion 을 호출하세요 — 이번 한 번만 멈춥니다.";
+      const passPath=path.join(gateDir,key+".ask-pass");
+      const NOT_BEFORE=2000;        // 같은 batch 병렬 형제가 방금 만든 pass 즉시 소비 방지(codex R2 P2)
+      const TTL=10*60*1000;         // deny 후 재시도 없이 방치된 stale pass 무검사 통과 방지(codex R2 P2)
+      let st=null; try{ st=fs.statSync(passPath); }catch{}
+      if(st){
+        const age=Date.now()-st.mtimeMs;
+        if(age>=NOT_BEFORE && age<=TTL){
+          // unlink 성공 = 1회 통과권의 원자적 소비(코드검토 R1 P2). ENOENT 만 "형제가 먼저
+          // 소비" — pass 없는 상태로 재판정(아래 발급+deny). 그 외(EACCES·EROFS 등 실제 IO
+          // 실패)는 소비 불가능한 pass 가 남아 deny 가 무한 반복된다 → fail-safe 통과(R2 P1).
+          try{ fs.unlinkSync(passPath); return; }
+          catch(e){ if(e&&e.code==="ENOENT"){ st=null; } else return; }
+        }
+        else if(age>TTL){
+          // stale 폐기도 동일 — 못 지우는 stale pass 를 남긴 채 deny 하면 영구 봉쇄(R2 P1).
+          try{ fs.unlinkSync(passPath); st=null; }
+          catch(e){ if(e&&e.code==="ENOENT"){ st=null; } else return; }
+        }
+        // age<NOT_BEFORE: 병렬 형제 — pass 는 남기고 이 호출도 deny (아래로)
+      }
+      if(!st){
+        // pass 발급(wx). 발급 실패 + 실존도 안 하면(gate dir 권한·FS 오류) deny 금지 —
+        // 재시도 통과권 없는 deny 는 AskUserQuestion 을 영구 봉쇄한다(코드검토 R1 P1). fail-safe 통과.
+        let issued=false;
+        try{ fs.mkdirSync(gateDir,{recursive:true,mode:0o700}); fs.writeFileSync(passPath,JSON.stringify({session_id:sid}),{flag:"wx",mode:0o600}); issued=true; }catch{}
+        if(!issued && !has(".ask-pass")) return;
+      }
+      const reason=has(".recalled")?DENY_B:DENY_A;
+      process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:reason}}));
+      return;
+    }
+
+    // ── PreToolUse(Edit|Write): recall 0회면 세션당 1회 넛지 ────────────────
+    if(tool!=="Edit" && tool!=="Write" && tool!=="NotebookEdit") return;
+    if(has(".recalled")) return;          // 이 세션에서 이미 회상함 → 조용
+    if(!claim(".nudged")) return;         // 이미 넛지함(또는 마커 못 씀) → 조용
+    process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:"PreToolUse",additionalContext:MSG}}));
+  }catch{ /* silent — fail-safe. tool 흐름 차단 절대 X */ }
+});
+' 2>/dev/null
+
+exit 0

package/templates/hook/lib/cross-runtime-sweep.sh

@@ -103,6 +103,15 @@ codex_recover() {
     if command -v identity_pin_check >/dev/null 2>&1 && ! identity_pin_check "$sid" "$token"; then
       _orphan_log_telemetry "$sid" "codex_skip_identity_mismatch"; continue
     fi
+    # spec 2026-07-20-codex-exec-prompt-pollution §4.2.1 — 격리 게이트(위 cwd·config·identity)를
+    # **통과한 뒤에만** 소비 완료 처리한다. 앞에서 marker 를 박으면 타 계정 소유 세션을 현재
+    # config 가 소비해버려 B6-4 를 깬다. 반대로 marker 없이 continue 하면 매 sweep 재후보가 되어
+    # 최신순+cap 아래 사람 세션(Desktop·tui) 회수를 굶긴다.
+    # 재시도 대상이 아니므로 pending·deferred 는 남기지 않는다.
+    if transcript_codex_is_exec "$fp"; then
+      orphan_mark_baseline "$sid" "codex_exec"
+      _orphan_log_telemetry "$sid" "codex_skip_agent_invocation"; continue
+    fi
     messages="$(transcript_messages_json_codex "$fp")"
     mc="$(_orphan_messages_count "$messages")"
     if [ "${mc:-0}" -le 0 ] 2>/dev/null; then