therookie 0.4.27 → 0.4.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "therookie",
-  "version": "0.4.27",
+  "version": "0.4.29",
   "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": [

package/src/commands/doctor.js

@@ -117,6 +117,7 @@ export async function runDoctor(flags) {
   printTemplateManifestStatus(serverStatus)
   printQueueStatus()
   printOrphanPending()
+  printRecallPush()
   printIdentityMismatch()
   await printStage1Metric(cfg)
   await printDedupMetric(cfg)
@@ -423,8 +424,12 @@ function printOrphanPending() {
   }
   const expiredCount =
     countDirEntries(join(root, 'expired')) + countDirEntries(join(root, 'codex', 'expired'))
+  // spec 2026-09-08 §2.4 — 사유별로 나눠 센다. 저장 0건이 쌓이는 것과 비정상 종료가 쌓이는 것은
+  //  원인도 조치도 다르다. 한 숫자로 뭉치면 진짜 복구 대기가 묻힌다.
+  const allMarkers = [...claude.markers, ...codex.markers]
+  const noWrites = allMarkers.filter((m) => m?.reason === 'no_writes').length
   const s = summarizeOrphanBacklog({
-    pendingMarkers: [...claude.markers, ...codex.markers],
+    pendingMarkers: allMarkers,
     expiredCount,
     nowMs: Date.now(),
   })
@@ -443,11 +448,65 @@ function printOrphanPending() {
       )
     }
   }
+  if (noWrites > 0) {
+    console.log(`— 저장 0건 세션: ${noWrites}건 대기 — 그 세션의 결정·사실이 아직 어디에도 없습니다. rookie orphan-extract 로 확인하세요.`)
+  }
   if (s.expiredCount > 0) {
     console.log(`— orphan expired(손실): 누적 ${s.expiredCount}건 — TTL 초과로 tail 미추출 상태로 만료된 세션`)
   }
 }
 
+// spec 2026-09-08 §5.1 — 회상 푸시 무주입률. recall-push.sh 가 로컬에 남긴 계측을 읽는다.
+// 서버 전송 없음. 파일이 없으면(아직 안 돌았거나 구버전) 침묵한다.
+export function summarizeRecallPush(lines, max = 1000) {
+  const rows = []
+  // 파일은 append 전용이라 최신이 뒤에 온다 — 뒤에서부터 max 줄만 집계한다.
+  for (let i = lines.length - 1; i >= 0 && rows.length < max; i--) {
+    try {
+      const o = JSON.parse(lines[i])
+      if (o && typeof o.injected === 'number') rows.push(o)
+    } catch {
+      /* 깨진 줄은 건너뛴다 */
+    }
+  }
+  if (rows.length === 0) return null
+  const silent = rows.filter((r) => r.injected === 0).length
+  // 중앙값은 chars 기준이다 — 컨텍스트 예산은 문자·토큰 감각이고, 한국어는 바이트가 3배라
+  // 바이트로 재면 합격 기준(§4.1)이 왜곡된다. bytes 는 파일에만 남긴다.
+  const chars = rows.map((r) => (typeof r.chars === 'number' ? r.chars : 0)).sort((a, b) => a - b)
+  const median = chars[Math.floor(chars.length / 2)]
+  const epochs = new Set(rows.map((r) => String(r.epoch ?? '')))
+  return {
+    turns: rows.length,
+    silent,
+    silentRatio: silent / rows.length,
+    medianChars: median,
+    epochs: epochs.size,
+  }
+}
+
+function printRecallPush() {
+  const dir = join(homedir(), '.rookie', 'recall-push')
+  const f = join(dir, 'metrics.jsonl')
+  // 훅이 크기 초과 시 .1 로 로테이트한다 — 직후에는 현재 파일이 거의 비어 있어
+  // 이것만 읽으면 최근 1000턴을 과소 집계한다(codex 코드검토 R2 P1). 앞에 이어 붙인다.
+  const rotated = f + '.1'
+  if (!existsSync(f) && !existsSync(rotated)) return
+  let s = null
+  try {
+    const read = (p) => (existsSync(p) ? readFileSync(p, 'utf8').split('\n').filter(Boolean) : [])
+    s = summarizeRecallPush([...read(rotated), ...read(f)])
+  } catch {
+    console.log('— 회상 푸시: 계측 읽기 실패')
+    return
+  }
+  if (!s) return
+  const pct = Math.round(s.silentRatio * 100)
+  console.log(
+    `— 회상 푸시: 최근 ${s.turns}턴 중 무주입 ${s.silent}건(${pct}%), 주입 길이 중앙값 ${s.medianChars}자, epoch ${s.epochs}개`
+  )
+}
+
 // B6-3 (spec 2026-07-11 §B6): 세션 identity pinning 위반 가시화 — 세션 도중 계정 전환으로
 // flush 가 중단된 이력. Stop hook(flush-session.sh)이 남긴 로그를 집계한다. 0건이면 침묵.
 function printIdentityMismatch() {

package/src/commands/save.js

@@ -13,6 +13,7 @@ import { execFileSync } from 'node:child_process'
 import { readFileSync } from 'node:fs'
 import { loadConfig, getHostname } from '../config.js'
 import { apiPost } from '../api.js'
+import { recordSessionWrite } from '../lib/session-write-marker.js'
 
 // 저장된 층을 **빠짐없이** 화면에 센다. 여기 없는 층은 서버가 저장해도 0건처럼 보인다 —
 // 2026-09-02 저장에서 durable fact 3건이 그렇게 안 보였고, metric·recall 로 따로 확인해야
@@ -116,6 +117,12 @@ export async function runSave(flags) {
     throw err
   }
 
+  // spec 2026-09-08 §2.4 — 이 세션에 저장이 있었다는 로컬 마커. Stop hook 이 없으면 미추출 큐에 넣는다.
+  //  --session 미전달이면 아무것도 안 한다(기존 호출자 호환).
+  if (res.all_committed !== false) {
+    recordSessionWrite(typeof flags.session === 'string' ? flags.session : '')
+  }
+
   if (flags.json) {
     // 서버 raw 응답 그대로 — 재가공 없음. SKILL 은 summary.working_cards.ids[0]·superseded_count 를 읽는다.
     console.log(JSON.stringify(res))

package/src/lib/orphan-extract-core.js

@@ -32,6 +32,9 @@ export function listPendingExtractions({ orphanRoot }) {
           sid,
           runtime,
           transcriptPath: m.transcript_path || '',
+          // spec 2026-09-08 §2.4 — 'no_writes'(저장 0건) 와 비정상 종료를 구분해 표시한다.
+          //  섞이면 진짜 복구 대기가 묻힌다.
+          reason: m.reason || 'crash',
           recoveredAt: m.recovered_at || null,
           // codex marker 는 codex 서브루트에 산다 — marker 명령이 이 루트를 겨냥해야
           // 큐에서 실제로 빠진다(코드검토 P2). orphan-recovery.sh 의 ROOKIE_ORPHAN_DIR 규약.
@@ -101,7 +104,11 @@ export function buildDraft(messages, { userMax = 300, assistantMax = 400, pathCa
 export function renderDraft(entry, draft) {
   const lines = []
   const clean = (s) => redactDraftText(s).redacted.replace(/\s+/g, ' ').trim()
-  lines.push(`◦ [${entry.runtime}] 세션 ${hashId8(entry.sid)} (recovered ${entry.recoveredAt ?? 'unknown'})`)
+  // spec 2026-09-08 §2.4 — 사유를 앞에 붙인다. 저장 0건과 비정상 종료는 봐야 할 것이 다르다.
+  const why = entry.reason === 'no_writes' ? '저장 0건' : '비정상 종료'
+  lines.push(
+    `◦ [${entry.runtime}] 세션 ${hashId8(entry.sid)} · ${why} (recovered ${entry.recoveredAt ?? 'unknown'})`
+  )
   if (draft.lastUser) lines.push(`  마지막 user: ${clean(draft.lastUser)}`)
   if (draft.lastAssistant) lines.push(`  마지막 assistant: ${clean(draft.lastAssistant)}`)
   if (draft.filePaths.length) lines.push(`  파일 경로: ${draft.filePaths.map((p) => clean(p)).join(' · ')}`)

package/src/lib/session-write-marker.js

@@ -0,0 +1,57 @@
+// spec 2026-09-08-session-continuity-two-gaps.md §2.4 — 저장 0건 세션 감지용 로컬 마커.
+//
+// 서버는 그 세션에 저장이 있었는지 모른다 — `rookie save` 가 세션 식별자를 보내지 않아
+// batch-mutate 를 세션에 귀속시킬 수 없다. 로컬에서 아는 편이 싸고 정확하다.
+//
+// 키에 epoch 를 넣는 이유: session_id 는 /clear·compact 후에도 같은 값이다(그래서 recall-push 가
+// 구간 경계를 skill-gate 의 .epoch 로 따로 감지한다). 세션 단위 키만 쓰면 clear 이전 구간에
+// 저장이 있었다는 이유로 이후 구간이 통째로 면제된다.
+import { createHash } from 'node:crypto'
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+export function markerDir() {
+  return process.env.ROOKIE_SESSION_WRITES_DIR || join(homedir(), '.rookie', 'session-writes')
+}
+
+function gateDir() {
+  return process.env.ROOKIE_SKILL_GATE_DIR || join(homedir(), '.rookie', 'skill-gate')
+}
+
+/** 세션의 현재 구간 epoch. 파일이 없으면 빈 문자열(현행 recall-push 관행과 동일). */
+export function readEpoch(sessionId) {
+  if (!sessionId) return ''
+  try {
+    const key = createHash('sha256').update(sessionId).digest('hex')
+    return String(readFileSync(join(gateDir(), key + '.epoch'), 'utf8')).trim()
+  } catch {
+    return ''
+  }
+}
+
+export function markerKey(sessionId, epoch) {
+  return createHash('sha256').update(`${sessionId}:${epoch}`).digest('hex')
+}
+
+/** 저장 성공 기록. sessionId 미전달이면 조용히 넘어간다(기존 호출자 호환). */
+export function recordSessionWrite(sessionId) {
+  if (!sessionId) return false
+  try {
+    const dir = markerDir()
+    mkdirSync(dir, { recursive: true, mode: 0o700 })
+    writeFileSync(join(dir, markerKey(sessionId, readEpoch(sessionId))), '', { mode: 0o600 })
+    return true
+  } catch {
+    return false // 마커 실패가 저장을 되돌리지는 않는다
+  }
+}
+
+export function hasSessionWrite(sessionId, epoch) {
+  if (!sessionId) return true // 판정 불가 — 큐에 넣지 않는다(오탐보다 무동작이 안전)
+  try {
+    return existsSync(join(markerDir(), markerKey(sessionId, epoch ?? readEpoch(sessionId))))
+  } catch {
+    return true
+  }
+}

package/templates/hook/bin/recall-push.sh

@@ -1,14 +1,16 @@
 #!/bin/bash
 # UserPromptSubmit hook — 무조건 회상 푸시 (unconditional recall push).
-# 설계: docs/superpowers/specs/2026-08-08-unconditional-recall-push-design.md
+# 설계: docs/superpowers/specs/2026-09-08-recall-always-inject-redesign.md (선행 2026-08-08)
 #
 # - 발동 조건 없음(E1 결정 제거): 매 사용자 발화를 그대로 recall 질의로 던진다. 빈 발화만 skip —
-#   길이 하한·낱말 필터는 결정의 재도입이라 두지 않는다(§1.1).
-# - hit(THRESH 이상 상위 K)만 additionalContext 로 그 턴의 생성 컨텍스트에 주입(E2). 무-hit → 0바이트.
-# - THRESH 기본 0.0165 = rrf k=60 단일 신호 최대치 1/61 바로 위 — "FTS·벡터 두 신호가 합의한
-#   결과만 주입"이라는 기계적 의미(worklog §96 분포 실측). 모델 판단·어휘 패턴 매칭이 아니다.
+#   길이 하한·낱말 필터는 결정의 재도입이라 두지 않는다.
+# - 주입 판정 없음: 상위 K 를 점수와 무관하게 넣는다. 옛 THRESH(0.0165)는 관련도가 아니라
+#   "어휘 암과 벡터 암이 같은 문서를 물었는가" 라는 검색 내부 사정을 재는 불리언이었고,
+#   실측에서 주입의 78%를 죽였다(2026-09-08 §1 — '이어서 진행해' 0/5, '안녕' 4/5).
+# - 관련도를 보증하지 않으므로 라벨에 그렇게 적고, 날짜·출처를 문장 앞에 놓아 절삭에도 살아남게 한다.
 # - 세션 dedup: 같은 기억 id 는 세션당 1회. /clear·compact 는 skill-gate <key>.epoch 값 변화로
 #   감지해 리셋한다(컨텍스트가 비워졌으니 재주입이 옳다).
+# - 계측은 로컬 전용 — <push_dir>/metrics.jsonl. 서버 전송·스키마 변경 없다(§5.1).
 # - fail-soft: 타임아웃(늦으면 그 턴 무주입)·네트워크·파싱 실패 전부 조용히 무주입 종료.
 #   아무것도 막지 않는다 — deny 0, 기존 user-prompt-skill-gate.sh 불변.
 set -u
@@ -37,7 +39,7 @@ PUSH_DIR="${ROOKIE_RECALL_PUSH_DIR:-$HOME/.rookie/recall-push}"
 GATE_DIR="${ROOKIE_SKILL_GATE_DIR:-$HOME/.rookie/skill-gate}"
 HOST_VAL="$(hostname 2>/dev/null || echo "")"
 
-# payload 는 stdin 으로(ARG_MAX 회피). 질의·필터·dedup·주입 결정 전부 node 한 덩어리 —
+# payload 는 stdin 으로(ARG_MAX 회피). 질의·dedup·주입 전부 node 한 덩어리 —
 # code 안에 작은따옴표 미사용(bash single-quote 보호).
 printf '%s' "$INPUT" | \
   ROOKIE_PUSH_DIR="$PUSH_DIR" ROOKIE_GATE_DIR="$GATE_DIR" \
@@ -45,29 +47,51 @@ printf '%s' "$INPUT" | \
   ROOKIE_HOST="$HOST_VAL" ROOKIE_CWD="$PWD" node -e '
 let d="";
 process.stdin.on("data",c=>d+=c).on("end",async()=>{
+  const fs=require("fs"),path=require("path"),crypto=require("crypto");
+  const METRIC_MAX_BYTES=parseInt(process.env.ROOKIE_RECALL_PUSH_METRIC_MAX_BYTES||"262144",10);
+  let epoch="";
+  // 로컬 계측 — 무주입도 반드시 남긴다(무주입률이 이 설계의 1차 관측 대상). 실패는 무시.
+  //
+  // 병렬 세션 안전: 쓰기는 append 전용(O_APPEND, 한 줄은 원자적)이고, 크기 초과 시에만
+  // rename 으로 로테이트한다. 파일을 읽어 다시 쓰는 방식은 두 세션이 같은 스냅샷을 보고
+  // 서로의 줄을 덮어쓸 수 있어 쓰지 않는다(codex 코드검토 R1 P1).
+  const metric=(layer,candidates,injected,text)=>{
+    try{
+      const dir=process.env.ROOKIE_PUSH_DIR;
+      const f=path.join(dir,"metrics.jsonl");
+      const s=String(text||"");
+      const line=JSON.stringify({
+        ts:new Date().toISOString(),epoch,layer,candidates,injected,
+        chars:s.length,bytes:Buffer.byteLength(s)
+      })+"\n";
+      fs.mkdirSync(dir,{recursive:true,mode:0o700});
+      try{
+        if(fs.statSync(f).size>METRIC_MAX_BYTES) fs.renameSync(f,f+".1");
+      }catch{}                                // 파일 없음·경합으로 이미 로테이트됨 — 둘 다 정상
+      fs.appendFileSync(f,line,{mode:0o600});
+    }catch{}
+  };
   try{
-    const fs=require("fs"),path=require("path"),crypto=require("crypto");
     const p=JSON.parse(d);
     const sid=String(p.session_id||p.sessionId||"");
     let prompt=String(p.prompt||"").trim();
     if(!prompt) return;                       // 빈 발화 = 질의 불성립(유일한 기계 조건)
-    prompt=prompt.slice(0,500);               // RecallQuerySchema q max(500) — 초과는 400 무주입(R1 P1)
-    const THRESH=Number(process.env.ROOKIE_RECALL_PUSH_THRESH||"0.0165");
+    prompt=prompt.slice(0,500);               // RecallQuerySchema q max(500) — 초과는 400 무주입
     const K=parseInt(process.env.ROOKIE_RECALL_PUSH_TOPK||"3",10);
-    const CAP=parseInt(process.env.ROOKIE_RECALL_PUSH_CAP||"1200",10);
+    const CAP=parseInt(process.env.ROOKIE_RECALL_PUSH_CAP||"600",10);
+    const ITEM=parseInt(process.env.ROOKIE_RECALL_PUSH_ITEM_CHARS||"200",10);
     const TIMEOUT=parseInt(process.env.ROOKIE_RECALL_PUSH_TIMEOUT_MS||"3500",10);
 
     // 세션 dedup 상태 — epoch(skill-gate 기록) 가 바뀌었으면 /clear·compact 경계로 보고 리셋.
     const key=sid?crypto.createHash("sha256").update(sid).digest("hex"):"";
-    let epoch="";
     if(key){ try{ epoch=String(fs.readFileSync(path.join(process.env.ROOKIE_GATE_DIR,key+".epoch"),"utf8")).trim(); }catch{} }
     const stFile=key?path.join(process.env.ROOKIE_PUSH_DIR,key+".injected"):null;
     let st={epoch,ids:[]};
     if(stFile){ try{ const j=JSON.parse(fs.readFileSync(stFile,"utf8")); if(j&&j.epoch===epoch&&Array.isArray(j.ids)) st=j; }catch{} }
     const seen=new Set(st.ids);
 
-    // 무조건 질의 — scope=all(현 구현상 project boost 없음, R1 P2).
-    // x-rookie-hostname + repo_path 동시 전달 = workspace 격리 기억 가시성 계약(R2 P2, fail-closed).
+    // 무조건 질의 — scope=all(현 구현상 project boost 없음).
+    // x-rookie-hostname + repo_path 동시 전달 = workspace 격리 기억 가시성 계약(fail-closed).
     const u=new URL("/api/rookie/recall",process.env.ROOKIE_EP);
     u.searchParams.set("q",prompt);
     u.searchParams.set("scope","all");
@@ -80,32 +104,33 @@ process.stdin.on("data",c=>d+=c).on("end",async()=>{
     if(!res.ok) return;
     const body=await res.json();
     const results=Array.isArray(body&&body.results)?body.results:[];
+    // 임계 없음 — 걸러내는 것은 형식 불량(id·요약 없음, 점수 비수치)과 기주입뿐이다.
     const cands=results
-      .filter(r=>r&&typeof r.relevance==="number"&&r.relevance>=THRESH&&r.id&&typeof r.summary==="string"&&r.summary.trim()&&!seen.has(r.id))
+      .filter(r=>r&&typeof r.relevance==="number"&&r.id&&typeof r.summary==="string"&&r.summary.trim()&&!seen.has(r.id))
       .sort((a,b)=>b.relevance-a.relevance)
       .slice(0,K);
-    if(!cands.length) return;                 // 무-hit(또는 전부 기주입) → 0바이트
+    if(!cands.length){ metric("B",results.length,0,""); return; }
 
-    // 주입 문구는 지시가 아니라 자료다(§3.2) — 요약 + 시각 + 출처 프로젝트(전역이면 명시).
-    const MARK=["①","②","③","④","⑤"];
-    let msg="🧠 관련 기억:";
+    // 주입 문구는 지시가 아니라 자료다. 관련도를 보증하지 않으므로 라벨에 명시하고,
+    // 날짜·출처를 앞에 놓아 ITEM 절삭에 잘려 나가지 않게 한다.
+    let msg="🧠 저장소 항목 (질의 연동, 관련도 미보증):";
     const used=[];
-    for(let i=0;i<cands.length;i++){
-      const r=cands[i];
+    for(const r of cands){
       const when=r.memory_at?String(r.memory_at).slice(0,10):"시각 미상";
       const src=r.project_name?String(r.project_name):"전역";
-      const summary=String(r.summary).replace(/\s+/g," ").trim().slice(0,400);
-      const item="\n"+(MARK[i]||"-")+" "+summary+" ("+when+", "+src+")";
+      const summary=String(r.summary).replace(/\s+/g," ").trim().slice(0,ITEM);
+      const item="\n- ["+when+" · "+src+"] "+summary;
       if(msg.length+item.length>CAP) break;   // 총량 상한 — relevance 순 절삭
       msg+=item; used.push(r.id);
     }
-    if(!used.length) return;
+    if(!used.length){ metric("B",results.length,0,""); return; }
     if(stFile){
       try{
         fs.mkdirSync(process.env.ROOKIE_PUSH_DIR,{recursive:true,mode:0o700});
         fs.writeFileSync(stFile,JSON.stringify({epoch,ids:st.ids.concat(used)}),{mode:0o600});
       }catch{}                                // dedup 기록 실패 → 다음 턴 중복 주입 위험만, 주입은 진행
     }
+    metric("B",results.length,used.length,msg);
     process.stdout.write(JSON.stringify({hookSpecificOutput:{hookEventName:"UserPromptSubmit",additionalContext:msg}}));
   }catch{ /* fail-soft — 조용히 무주입 */ }
 });

package/templates/hook/flush-session.sh

@@ -301,6 +301,14 @@ if [ "$HTTP_CODE" = "200" ]; then
   if command -v orphan_mark_flushed >/dev/null 2>&1 && [ "${MESSAGE_COUNT:-0}" -gt 0 ] 2>/dev/null; then
     orphan_mark_flushed "$SESSION_ID" "stop" "$MESSAGE_COUNT" || true
   fi
+  # spec 2026-09-08 §2.4 — 이 세션 구간에 `rookie save` 성공이 한 번도 없었으면 결정·사실이
+  # 어디에도 남지 않는다. transcript 는 있으므로 다음 세션이 건지도록 미추출 큐에 올린다.
+  # 내용 없는 세션(MESSAGE_COUNT=0)은 제외 — 건질 게 없다.
+  if command -v orphan_session_had_write >/dev/null 2>&1 \
+    && [ "${MESSAGE_COUNT:-0}" -gt 0 ] 2>/dev/null \
+    && ! orphan_session_had_write "$SESSION_ID"; then
+    orphan_mark_no_writes "$SESSION_ID" "$TRANSCRIPT_PATH" || true
+  fi
 else
   # §17 H-2: 큐 적재 + 1회 chain drain (일시적 깜빡임 회복)
   if command -v queue_enqueue >/dev/null 2>&1; then

package/templates/hook/lib/orphan-recovery.sh

@@ -84,6 +84,48 @@ orphan_mark_baseline() {
     "$(printf '{"status":"baseline_skipped","reason":"%s"}' "$reason")"
 }
 
+# spec 2026-09-08-session-continuity-two-gaps.md §2.4 — 저장 0건 세션을 미추출 큐에 넣는다.
+#
+# 세션 안에서 `rookie save` 가 한 번도 성공하지 않았으면 그 세션의 결정·사실은 어디에도 없다.
+# transcript 는 남아 있으므로 다음 세션이 orphan-extract 로 건질 수 있게 큐에 올린다.
+#
+# 마커 키에 epoch 를 넣는 이유: session_id 는 /clear·compact 후에도 같은 값이라(그래서 recall-push 가
+# 구간 경계를 .epoch 로 따로 본다), 세션 단위 키만 쓰면 clear 이전 구간의 저장이 이후 구간을 면제한다.
+_orphan_session_write_key() {
+  local sid="$1" gate_dir epoch
+  gate_dir="${ROOKIE_SKILL_GATE_DIR:-$HOME/.rookie/skill-gate}"
+  local sid_hash
+  sid_hash="$(printf '%s' "$sid" | shasum -a 256 2>/dev/null | cut -d" " -f1)"
+  epoch="$(cat "$gate_dir/$sid_hash.epoch" 2>/dev/null | tr -d "[:space:]")"
+  printf '%s:%s' "$sid" "$epoch" | shasum -a 256 2>/dev/null | cut -d" " -f1
+}
+
+# 이 세션 구간에 저장이 있었는가. 판정 불가(빈 sid·shasum 없음)면 "있었다"로 본다 —
+# 무동작이 오탐보다 안전하다.
+orphan_session_had_write() {
+  local sid="$1"
+  [ -n "$sid" ] || return 0
+  command -v shasum >/dev/null 2>&1 || return 0
+  local dir="${ROOKIE_SESSION_WRITES_DIR:-$HOME/.rookie/session-writes}"
+  local key
+  key="$(_orphan_session_write_key "$sid")"
+  [ -n "$key" ] || return 0
+  [ -f "$dir/$key" ]
+}
+
+# 저장 0건이면 pending-extraction 에 reason=no_writes 로 올린다.
+# 비정상 종료(crash) 사유와 섞이지 않게 reason 을 남긴다 — 섞이면 진짜 복구 대기가 묻힌다.
+orphan_mark_no_writes() {
+  local sid="$1" transcript="${2:-}"
+  [ -n "$sid" ] || return 1
+  # 이미 추출을 마쳤거나 대기 중이면 덮지 않는다.
+  [ -f "$(_orphan_client_extracted_dir)/$sid.json" ] && return 0
+  [ -f "$(_orphan_pending_dir)/$sid.json" ] && return 0
+  _orphan_write_marker "$(_orphan_pending_dir)" "$sid" \
+    "$(printf '{"status":"pending_extraction","reason":"no_writes","transcript_path":"%s","recovered_at":"%s"}' \
+      "$transcript" "$(date -u +%Y-%m-%dT%H:%M:%SZ)")"
+}
+
 # P0.4 — 짧고 내용 없는(low_value) 세션 marker. record_pending 대신 호출 → 재적재 차단.
 orphan_mark_low_value() {
   local sid="$1" reason="${2:-low_value}" mc="${3:-0}"

package/version.json

@@ -1,4 +1,4 @@
 {
-  "cli_version": "0.4.27",
+  "cli_version": "0.4.29",
   "skill_version": "1.39.0"
 }