elanous 0.2.24 → 0.2.25

package/scripts/ux-sim.ts

@@ -13,6 +13,9 @@
 //   bun scripts/ux-sim.ts --computer-use normal --from-run <runId> --save-trajectory <name> # 이름으로 저장
 //   bun scripts/ux-sim.ts --computer-use normal --trajectory <name> # 저장한 궤적을 재생
 //   bun scripts/ux-sim.ts --list-trajectories # 저장한 궤적과 출처 목록
+//   bun scripts/ux-sim.ts --fault cred-expiry # 결함 주입: grok 구독 만료 임박 × 갱신 결과 → 디스패처·발사 판정
+//   bun scripts/ux-sim.ts --fault pod-death   # 결함 주입: PARTIAL 줄을 남긴 Pod 가 SIGTERM 으로 지워짐 → 호스트 재방출 판정
+//   bun scripts/ux-sim.ts --fault pool-cap    # 결함 주입: --pod-pool 에 :N 이 빠진 풀 → 승인 판정(limitedBy)
 //
 // ⛔ 이 CLI 는 «실제 위젯 render()» 를 부른다 — 흉내 렌더러가 아니다.
 import { simRenderLogFrame } from '../src/ux-sim/render-frame.js';
@@ -33,7 +36,7 @@ const argv = process.argv.slice(2);
 //  ⛔ 그래서 「알려진 플래그」를 «한 곳»에 두고, 그 밖의 `--` 인자는 거부한다.
 const KNOWN_FLAGS = new Set([
   '--list', '--list-trajectories', '--computer-use', '--trajectory', '--from-run',
-  '--save-trajectory', '--esc', '--queue', '--width', '--height', '--draft',
+  '--save-trajectory', '--esc', '--queue', '--width', '--height', '--draft', '--fault',
 ]);
 {
   const unknown = argv.filter((a) => a.startsWith('--') && !KNOWN_FLAGS.has(a.split('=')[0]));
@@ -46,6 +49,32 @@ const KNOWN_FLAGS = new Set([
 }
 if (argv.includes('--list')) { console.log([...PHASES, 'computer-use: normal | capture-stalls | capture-fails | target-missing'].join('\n')); process.exit(0); }
 
+{
+  // `--fault=<이름>` 꼴도 받는다 — KNOWN_FLAGS 는 등호 꼴을 통과시키므로 여기서 놓치면 조용히 기본 국면으로 빠진다.
+  const eq = argv.find((a) => a.startsWith('--fault='));
+  if (eq) argv.splice(argv.indexOf(eq), 1, '--fault', eq.slice('--fault='.length));
+}
+if (argv.includes('--fault')) {
+  const fault = argv[argv.indexOf('--fault') + 1];
+  if (fault === 'cred-expiry') {
+    const { credExpirySweep, renderCredExpiry } = await import('../src/ux-sim/fault-cred-expiry.js');
+    console.log(renderCredExpiry(credExpirySweep()).join('\n'));
+    process.exit(0);
+  }
+  if (fault === 'pod-death') {
+    const { simPodDeath, renderPodDeath } = await import('../src/ux-sim/fault-pod-death.js');
+    console.log(renderPodDeath(simPodDeath()).join('\n'));
+    process.exit(0);
+  }
+  if (fault === 'pool-cap') {
+    const { poolCapSweep, renderPoolCap } = await import('../src/ux-sim/fault-pool-cap.js');
+    console.log(renderPoolCap(poolCapSweep()).join('\n'));
+    process.exit(0);
+  }
+  console.error(`⛔ 모르는 결함이다: ${fault ?? '(없음)'} — 아는 것: cred-expiry · pod-death · pool-cap`);
+  process.exit(2);
+}
+
 if (argv.includes('--list-trajectories')) {
   const { listSavedBrowserActionTrajectories } = await import('../src/harness/browser-trajectory.js');
   const saved = listSavedBrowserActionTrajectories();

package/skills/youtube-master/scripts/main.ts

@@ -10,7 +10,7 @@ import { fetchSupadataTranscript, judgeTranscriptSufficiency } from '../src/tran
 import { downloadAudio, splitAudio } from '../src/audio.js';
 import { transcribeChunks } from '../src/stt.js';
 import { summarize, parseMetaFromSummary } from '../src/summarize.js';
-import { getSaveDir, saveMarkdown, prepareRunDir, persistArtifacts } from '../src/obsidian.js';
+import { getSaveDir, saveMarkdown, prepareRunDir, persistArtifacts, saveSkipNotice } from '../src/obsidian.js';
 import { classifyDomain, stagingEnabled, stagingSubdir } from '../src/domain-staging.js';
 import { buildStudyNote } from '../src/study-note.js';
 import { decideRoute } from '../src/router.js';
@@ -203,6 +203,7 @@ async function main() {
     });
     console.log(`  저장 완료: ${savedPath}`);
   }
+  const skipNotice = savedPath === null ? saveSkipNotice(route.target, saveDir) : null;
 
   if (flags.print) {
     console.log('\n---BEGIN_YOUTUBE_MASTER_MARKDOWN---\n');
@@ -211,6 +212,8 @@ async function main() {
   }
 
   outputSignals(route);
+
+  if (skipNotice) console.log(skipNotice);
 }
 
 // ── Transcript acquisition (auto-fallback) ──

package/skills/youtube-master/src/obsidian.ts

@@ -21,6 +21,15 @@ export function getStudyNoteSaveDir(): string | null {
   return join(vaultRoot, ...sub.split('/'));
 }
 
+const SAVE_SKIP_NOTICE =
+  '저장 안 됨 · OBSIDIAN_VAULT_ROOT 가 없다 · 고칠 한 줄: export OBSIDIAN_VAULT_ROOT=<vault 경로>';
+
+/** target 이 obsidian 인데 saveDir 이 없으면 세 칸 안내, 아니면 null. */
+export function saveSkipNotice(target: string, saveDir: string | null): string | null {
+  if (target === 'obsidian' && saveDir == null) return SAVE_SKIP_NOTICE;
+  return null;
+}
+
 /* ── Artifact persistence (Cloud STT path) ── */
 
 export async function prepareRunDir(saveDir: string, meta: VideoMeta, videoId: string): Promise<string> {

package/src/agent-substrate/acp-implementer.ts

@@ -1,7 +1,8 @@
 // ── ACP Claude Code 를 «구현» 실행기로 (CLAUDE-IMPL-LANE · `--child-llm-provider claude-acp`) ──
 //
 // acp-reviewer.ts 의 짝이다. 리뷰어는 read-only 라 읽기 툴만 허가하지만, 구현 실행기는 런 워크트리 안에서
-// 쓰기·실행을 허가해야 한다. 그래서 approver 가 «워크트리 밖 경로 쓰기»를 구조적으로 거부한다.
+// 쓰기·실행을 허가해야 한다. 대표 대표 결정(10-12): ACP 세션 권한 모드는 호스트 설정(auto)을 그대로 두고
+// 바꾸지 않으며, approver 가 불려도 «워크트리 밖 경로 쓰기»를 거부하지 않고 허가하되 insideWorktree 로 관측한다.
 // 자식은 claude 구독 ACP 어댑터(`claude-agent-acp`)이며 env 는 subscriptionReviewerSpawn 의 과금 스크럽
 // (ANTHROPIC_API_KEY 등 제거)을 그대로 쓴다 — 지우지 않으면 구독이 아니라 API 로 과금된다.
 import { isAbsolute, relative, resolve } from 'node:path';
@@ -23,6 +24,8 @@ export interface ImplementerPermissionRequest {
 export interface ImplementerPermissionDecision {
   tool: string;
   path: string | null;
+  /** 판정에 쓴 경로가 워크트리 안인가 — 경로가 없으면 null. 밖이어도 허가한다(대표 10-12); 이 칸이 그 관측이다. */
+  insideWorktree: boolean | null;
   decision: 'allow' | 'deny';
 }
 
@@ -37,18 +40,20 @@ function insideWorktree(worktree: string, target: string): boolean {
   return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
 }
 
-/** 허가 판정(순수 함수). 쓰기 계열(edit·delete·move)은 모든 경로가 워크트리 안일 때만 허가하고,
- *  실행(execute)은 cwd 가 워크트리라 허가한다. 읽기 계열은 허가, 그 외는 경로가 있고 전부 안쪽일 때만 허가(보수적). */
+/** 허가 판정(순수 함수). 쓰기 계열(edit·delete·move)은 경로가 있으면 워크트리 안팎을 가리지 않고 허가한다
+ *  (대표 10-12 — 밖 쓰기 거부를 걷었다 · insideWorktree 로 관측만 한다). 실행(execute)·읽기 계열은 허가,
+ *  그 외(모르는 kind)는 경로가 있을 때만 허가 — 경로 없는 쓰기·모르는 요청은 여전히 거부. */
 export function decideImplementerPermission(req: ImplementerPermissionRequest, worktree: string): ImplementerPermissionDecision {
   const paths = requestedPaths(req.rawInput);
   const outside = paths.find((p) => !insideWorktree(worktree, p));
   const tool = req.title.slice(0, 80);
   const shown = outside ?? paths[0] ?? null;
-  const verdict = (allow: boolean): ImplementerPermissionDecision => ({ tool, path: shown, decision: allow ? 'allow' : 'deny' });
-  if (req.kind && WRITE_TOOL_KINDS.has(req.kind)) return verdict(paths.length > 0 && outside === undefined);
+  const inside = paths.length === 0 ? null : outside === undefined;
+  const verdict = (allow: boolean): ImplementerPermissionDecision => ({ tool, path: shown, insideWorktree: inside, decision: allow ? 'allow' : 'deny' });
+  if (req.kind && WRITE_TOOL_KINDS.has(req.kind)) return verdict(paths.length > 0);
   if (req.kind === 'execute') return verdict(true);
   if (isReadOnlyReviewTool(req.kind, req.title)) return verdict(true);
-  return verdict(paths.length > 0 && outside === undefined);
+  return verdict(paths.length > 0);
 }
 
 export interface AcpImplementerOpts {
@@ -96,7 +101,9 @@ export function makeAcpImplementer(opts: AcpImplementerOpts): (prompt: string) =
       permissionApprover: async (req) => {
         const verdict = decideImplementerPermission(req, opts.worktree);
         if (verdict.decision === 'allow') allowed++; else denied++;
-        debug.log(OBS, 'permission', { ...verdict });
+        debug.log(OBS, 'permission', {
+          tool: verdict.tool, path: verdict.path, insideWorktree: verdict.insideWorktree, allowed: verdict.decision === 'allow',
+        });
         return verdict.decision === 'allow';
       },
     };

package/src/agent-substrate/pr-reviewer.ts

@@ -683,8 +683,9 @@ function isLongNoFindingBracket(text: string): boolean {
   return NO_FINDING_HEAD.test(remark) && !LONG_REMARK_DISSENT.test(remark);
 }
 /** must-fix 항목이 «지적 없음» 표지인가 — must-fix 를 세는 자리는 전부 `parseReviewResult` 를 거친다
- *  (`self review --json` 의 `mustFix` → TA `parseReviewResultOutput` → `pr land --overlap-evidence` 의 `review-must-fix-N`). */
-function isNoneSentinelFinding(finding: string): boolean {
+ *  (`self review --json` 의 `mustFix` → TA `parseReviewResultOutput` → `pr land --overlap-evidence` 의 `review-must-fix-N`).
+ *  ⭐ export — `parseReviewResultOutput` 가 «같은» 판정으로 저장된 결과의 표지 줄을 다시 접는다(PR-LAND-MUSTFIX-NONE · 복제 금지). */
+export function isNoneSentinelFinding(finding: string): boolean {
   const text = finding.trim();
   if (BARE_SENTINEL.test(text)) return true;
   const bracketed = BRACKETED_SENTINEL.exec(text);
@@ -765,6 +766,25 @@ function reviewedResultFromRaw(raw: string, runId: string | undefined, pass?: {
   return { verdict: 'pass', mustFix: [], shouldFix: [], reviewed: false, failureReason: NO_VERDICT_LINE_REASON };
 }
 
+/** REVIEW-PROMPT-SIZE — llmReview 호출 하나(단일·청크 패스)마다 프롬프트·응답 크기를 남긴다.
+ *  관측이 리뷰를 막지 않는다(다른 review.* 관측과 같은 계약). */
+function logReviewPromptSize(
+  prompt: string,
+  response: string,
+  pass: { pass: number; chunked: boolean },
+  runId: string | undefined,
+): void {
+  try {
+    debug.log('review.prompt-size', 'call', {
+      pass: pass.pass,
+      promptChars: prompt.length,
+      responseChars: response.length,
+      chunked: pass.chunked,
+      ...(runId !== undefined ? { runId } : {}),
+    });
+  } catch { /* Observation must not prevent the review. */ }
+}
+
 function failureReasonText(error: unknown): string {
   if (error instanceof Error) return safeLogText(error.message, 400);
   if (typeof error === 'string') return safeLogText(error, 400);
@@ -916,10 +936,11 @@ export async function reviewPullRequest(
             + ' 「여기 안 보인다」를 결함으로 판정하지 마십시오.',
           ].filter(Boolean).join('\n'),
         };
-        passResults.push(reviewedResultFromRaw(await llmReview(
-          buildReviewPrompt(passInput, passBudget, '', passContext[index]?.budget),
-          reviewImages.length > 0 && index === 0 ? reviewImages : undefined,
-        ), input.reviewContext?.runId, { index, of: plan.passes.length }));
+        const passPrompt = buildReviewPrompt(passInput, passBudget, '', passContext[index]?.budget);
+        const passImages = reviewImages.length > 0 && index === 0 ? reviewImages : undefined;
+        const passRaw = await llmReview(passPrompt, passImages);
+        logReviewPromptSize(passPrompt, passRaw, { pass: index + 1, chunked: true }, input.reviewContext?.runId);
+        passResults.push(reviewedResultFromRaw(passRaw, input.reviewContext?.runId, { index, of: plan.passes.length }));
       }
       return {
         ...foldReviewResults(passResults),
@@ -943,10 +964,9 @@ export async function reviewPullRequest(
         } : {}),
       };
     }
-    const raw = await llmReview(
-      buildReviewPrompt(input, diffBudget, referencedContext.text, singleContextBudget),
-      reviewImages.length > 0 ? reviewImages : undefined,
-    );
+    const prompt = buildReviewPrompt(input, diffBudget, referencedContext.text, singleContextBudget);
+    const raw = await llmReview(prompt, reviewImages.length > 0 ? reviewImages : undefined);
+    logReviewPromptSize(prompt, raw, { pass: 1, chunked: false }, input.reviewContext?.runId);
     return {
       ...reviewedResultFromRaw(raw, input.reviewContext?.runId),
       diffBudget: {

package/src/agent-substrate/self-review-cli.ts

@@ -14,6 +14,9 @@
 //
 // index.ts 의 액션은 옵션 파싱과 실제 의존 배선만 남는다(얇은 껍데기).
 
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { tierModel } from '../llm/model-defaults.js';
 import { buildReviewObservation, safeLogText } from './review-observation.js';
 import { DEFAULT_REVIEW_BACKEND } from './acp-reviewer.js';
@@ -75,13 +78,13 @@ export interface SelfReviewCliDeps {
    *
    * ⚠️ API 백엔드(`makeApiLlm`)는 이 인자를 안 받는다 — ACP 경로만 이미지를 나른다.
    */
-  makeAcpLlm(o: { backend: string; model?: string; timeoutMs: number }): (prompt: string, images?: readonly ReviewImage[]) => Promise<string>;
+  makeAcpLlm(o: { backend: string; model?: string; timeoutMs: number; cwd?: string }): (prompt: string, images?: readonly ReviewImage[]) => Promise<string>;
   /**
    * Reviewer ACP lane selected by `roleLlm.reviewer` (no explicit flag). Returns the LLM when the
    * subscription is usable, or a reason code when it is not — the caller then reviews on the API
    * exactly as before. Absent seam = the lane is unavailable (`role-reviewer-seam-missing`).
    */
-  makeRoleReviewerLlm?(spec: SubscriptionReviewerSpec, o: { timeoutMs: number }):
+  makeRoleReviewerLlm?(spec: SubscriptionReviewerSpec, o: { timeoutMs: number; cwd?: string }):
     | { llm: (prompt: string, images?: readonly ReviewImage[]) => Promise<string>; backend: string }
     | { reason: string };
   /**
@@ -1164,6 +1167,65 @@ export function renderReviewerContextStatus(loaded: LoadedReviewerContext, decom
   return `Reviewer context: ${loaded.items.length} loaded, ${loaded.failed.length} not loaded.${source}${truncation}${decompositionStatus}${labels ? `\n${labels}` : ''}${failures ? `\n${failures}` : ''}`;
 }
 
+/**
+ * 머지된 PR 의 사후 리뷰 격리 — 리뷰어 cwd 가 main 최신이면 그 뒤 수리를 인용한다.
+ * `merged` 는 그 PR 의 머지 커밋, `open` 은 종전(cwd 불변), `unpinnable` 은 MERGED 인데 머지 커밋을 못 구한 경우다.
+ */
+type PrMergeState =
+  | { kind: 'open' }
+  | { kind: 'merged'; commit: string }
+  | { kind: 'unpinnable'; reason: 'merge-commit-unknown' };
+
+function readPrMergeState(pr: string, deps: SelfReviewCliDeps): PrMergeState {
+  const view = deps.gh(['pr', 'view', pr, '--json', 'state,mergeCommit'], 15_000);
+  if (view.status !== 0) return { kind: 'open' };
+  try {
+    const parsed = JSON.parse(view.stdout) as { state?: unknown; mergeCommit?: { oid?: unknown } | null };
+    if (parsed?.state !== 'MERGED') return { kind: 'open' };
+    const oid = parsed.mergeCommit?.oid;
+    return typeof oid === 'string' && COMMIT_OID.test(oid)
+      ? { kind: 'merged', commit: oid }
+      : { kind: 'unpinnable', reason: 'merge-commit-unknown' };
+  } catch {
+    return { kind: 'open' };
+  }
+}
+
+interface ReviewWorktree {
+  cwd: string;
+  commit: string;
+  /** 멱등 — 두 번 불러도 안전하다. */
+  remove(): void;
+}
+
+type ReviewWorktreeResult = ReviewWorktree | { reason: 'no-git-seam' | 'worktree-add-failed' };
+
+function createDetachedReviewWorktree(commit: string, deps: SelfReviewCliDeps): ReviewWorktreeResult {
+  const git = deps.git;
+  if (!git) return { reason: 'no-git-seam' };
+  const parent = mkdtempSync(join(tmpdir(), 'elanous-review-pin-'));
+  const cwd = join(parent, 'wt');
+  const add = () => git(['worktree', 'add', '--detach', cwd, commit], 120_000);
+  let added = add();
+  if (added.status !== 0) {
+    git(['fetch', 'origin', commit], 120_000);
+    added = add();
+  }
+  let removed = false;
+  const remove = (): void => {
+    if (removed) return;
+    removed = true;
+    git(['worktree', 'remove', '--force', cwd], 60_000);
+    rmSync(parent, { recursive: true, force: true });
+    // ⛔ `git worktree prune` 은 부르지 않는다 — 저장소 «전체»의 stale 메타데이터를 지워 남의 worktree 까지 건드린다.
+  };
+  if (added.status !== 0) {
+    remove();
+    return { reason: 'worktree-add-failed' };
+  }
+  return { cwd, commit, remove };
+}
+
 /** `elanous self review <pr...>` 본문. read-only — 머지하지 않는다. */
 /**
  * `self review --json` stdout 한 줄 — 결과가 하나면 객체, 여럿이면 배열. index.ts 액션이 이것을 그대로 쓴다.
@@ -1177,6 +1239,20 @@ export async function runSelfReviewCliCommand(
   prArgs: string[],
   opts: SelfReviewCliOpts,
   deps: SelfReviewCliDeps,
+): Promise<SelfReviewCliOutcome> {
+  const pins: ReviewWorktree[] = [];
+  try {
+    return await runSelfReviewCliCommandPinned(prArgs, opts, deps, pins);
+  } finally {
+    for (const pin of pins) pin.remove();
+  }
+}
+
+async function runSelfReviewCliCommandPinned(
+  prArgs: string[],
+  opts: SelfReviewCliOpts,
+  deps: SelfReviewCliDeps,
+  pins: ReviewWorktree[],
 ): Promise<SelfReviewCliOutcome> {
   // 관측 sink는 모든 종료 경로보다 먼저 등록해 거부도 운영 로그에 남긴다.
   await deps.registerSink('self-review');
@@ -1272,6 +1348,7 @@ export async function runSelfReviewCliCommand(
     // ⛔ `relation-unknown` 도 경고한다(위 주석 · 리뷰가 두 라운드 반복 지적) — 그 밖 unavailable 은 조용하다.
     //    ⭐ 경고 여부 판정은 `localHeadWarningDetails` 한 곳에 있다(호출부에서 같은 함수를 두 번 부르지 않는다).
     const mismatchWarning = localHeadWarningDetails(localHeadComparison);
+    const mergeState = readPrMergeState(pr, deps);
     const view = deps.gh(['pr', 'view', pr, '--json', 'title,body'], 15_000);
     let prView: { title?: string; body?: string } | undefined;
     if (view.status === 0) {
@@ -1399,6 +1476,36 @@ export async function runSelfReviewCliCommand(
       else deps.print(`\n━━ PR ${pr} (${primaryModel}) ━━\n${renderStaleRefusal(diffRead)}\n${reviewerContextStatus}`);
       continue;
     }
+    // ⭐ 머지된 PR 만 머지 커밋 detached worktree 에서 리뷰한다 — main 최신이 아니라 그 PR 이 머지된 시점의 코드를 본다.
+    //    열린 PR 은 종전 그대로(cwd = process.cwd() · 리뷰어 심이 cwd 를 받지 않는다).
+    let reviewPin: ReviewWorktree | undefined;
+    let reviewCwdPinFallbackReason: string | undefined;
+    // cwd 를 받는 레인(ACP · role 리뷰어)일 때만 worktree 를 뜬다 — API 리뷰어는 cwd 를 안 받으므로 떠도 그 위에서 돌지 않는다.
+    const pinLane = useAcp || Boolean(roleReviewer && opts.roleReviewer && deps.makeRoleReviewerLlm);
+    let rolePinned = false;
+    if (!pinLane) {
+      // 비-ACP 레인 — 격리하지 않는다(종전 그대로 · reviewCwdCommit 없음).
+    } else if (mergeState.kind === 'merged') {
+      const made = createDetachedReviewWorktree(mergeState.commit, deps);
+      if ('cwd' in made) {
+        reviewPin = made;
+        pins.push(made);
+      } else reviewCwdPinFallbackReason = made.reason;
+    } else if (mergeState.kind === 'unpinnable') reviewCwdPinFallbackReason = mergeState.reason;
+    const reviewCwd = reviewPin?.cwd;
+    const prAcpReviewLLM = reviewCwd && useAcp
+      ? deps.makeAcpLlm({ backend: acpBackend, ...(acpModel ? { model: acpModel } : {}), timeoutMs: acpTimeoutSec * 1000, cwd: reviewCwd })
+      : acpReviewLLM;
+    let prRoleReviewer = roleReviewer;
+    if (reviewCwd && roleReviewer && opts.roleReviewer && deps.makeRoleReviewerLlm) {
+      try {
+        const pinned = deps.makeRoleReviewerLlm(opts.roleReviewer, { timeoutMs: acpTimeoutSec * 1000, cwd: reviewCwd });
+        if ('llm' in pinned) { prRoleReviewer = { llm: pinned.llm, model: `acp:${pinned.backend}` }; rolePinned = true; }
+        else reviewCwdPinFallbackReason = 'role-reviewer-cwd-unavailable';
+      } catch {
+        reviewCwdPinFallbackReason = 'role-reviewer-cwd-unavailable';
+      }
+    }
     const startedAt = deps.now();
     // Role-config lane builds the API reviewer only when it falls back (`made().api` stays 0 on ACP success).
     const responded: { provider?: string; model?: string } = {};
@@ -1406,7 +1513,7 @@ export async function runSelfReviewCliCommand(
       pinProvider: Boolean(opts.model?.trim()),
       onResolved: (provider, respondedModel) => { responded.provider = provider; responded.model = respondedModel; },
     });
-    const llmReview = roleReviewer ? undefined : (acpReviewLLM ?? makeApi());
+    const llmReview = prRoleReviewer ? undefined : (prAcpReviewLLM ?? makeApi());
     // ⛔ evidenceNote 는 **별도 채널**이다 — phaseIntent 에 섞으면 의도 채널이 오염된다(실측: 그렇게
     //   했다가 intent 배선 테스트 3개가 즉시 깨졌다).
     // ⛔ 사람 `--intent`(phaseIntent) 와 골 acceptance 는 다른 인자 — 충돌하지 않고, 충돌해도 intent 가 이긴다.
@@ -1426,10 +1533,10 @@ export async function runSelfReviewCliCommand(
     let roleReview: ReviewResult | undefined;
     let roleReviewerFallbackReason = roleReviewerUnavailableReason;
     let roleReviewMs: number | undefined;
-    if (roleReviewer) {
+    if (prRoleReviewer) {
       const roleStartedAt = deps.now();
       try {
-        const attempt = await deps.reviewPullRequest(reviewInput, roleReviewer.llm);
+        const attempt = await deps.reviewPullRequest(reviewInput, prRoleReviewer.llm);
         if (attempt.reviewed === true) roleReview = attempt;
         // Code, not the reviewer's raw failure text (same rule as the throw path above).
         else roleReviewerFallbackReason = 'acp-review-not-completed';
@@ -1445,8 +1552,8 @@ export async function runSelfReviewCliCommand(
         }, { level: 'warn' });
       }
     }
-    let review = roleReview ?? await deps.reviewPullRequest(reviewInput, llmReview ?? acpReviewLLM ?? makeApi());
-    let selectedModel = roleReview && roleReviewer ? roleReviewer.model : model;
+    let review = roleReview ?? await deps.reviewPullRequest(reviewInput, llmReview ?? prAcpReviewLLM ?? makeApi());
+    let selectedModel = roleReview && prRoleReviewer ? prRoleReviewer.model : model;
     let reviewRoute: 'api' | 'acp' | 'acp-fallback' = useAcp || roleReview ? 'acp' : 'api';
     let fallbackAttempted = false;
     let fallbackBackend: string | undefined;
@@ -1466,7 +1573,7 @@ export async function runSelfReviewCliCommand(
         try {
           const fallbackReview = await deps.reviewPullRequest(
             reviewInput,
-            deps.makeAcpLlm({ backend, timeoutMs: acpTimeoutSec * 1000 }),
+            deps.makeAcpLlm({ backend, timeoutMs: acpTimeoutSec * 1000, ...(reviewCwd ? { cwd: reviewCwd } : {}) }),
           );
           if (fallbackReview.reviewed === true) {
             review = fallbackReview;
@@ -1482,6 +1589,14 @@ export async function runSelfReviewCliCommand(
         }
       }
     }
+    reviewPin?.remove();
+    // reviewCwdCommit 은 «최종 판정을 낸 LLM 이 실제로 그 cwd 를 받았을 때만» 싣는다(role 실패 → API 폴백이면 안 싣는다).
+    const reviewedOnPin = Boolean(reviewPin) && (roleReview ? rolePinned : reviewRoute === 'acp-fallback' ? true : reviewRoute === 'acp' && useAcp);
+    if (reviewPin && !reviewedOnPin) reviewCwdPinFallbackReason ??= 'final-reviewer-not-pinned';
+    const reviewCwdOutput = {
+      ...(reviewPin && reviewedOnPin ? { reviewCwdCommit: reviewPin.commit } : {}),
+      ...(reviewCwdPinFallbackReason ? { reviewCwdPinFallbackReason } : {}),
+    };
     if (!fallbackAttempted) {
       fallbackNotAttemptedReason = useAcp ? 'explicit-acp' : 'primary-review-succeeded';
     }
@@ -1522,20 +1637,21 @@ export async function runSelfReviewCliCommand(
         goalLoaded: goalAcceptance.goalLoaded,
         acceptanceChars: goalAcceptance.acceptanceChars,
         ...reviewerSelection,
+        ...reviewCwdOutput,
       },
       { level: review.reviewed === false ? 'warn' : 'info' });
     // --acp 는 대표가 명시 요청한 리뷰 — fail-soft(reviewed=false)면 조용히 pass 하지 말고 표면화(관측=acp-review).
     if (useAcp && review.reviewed === false) {
       const err = 'ACP 리뷰 실행 실패(reviewed=false) — 관측: elanous logs --category acp-review';
       const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
-      if (opts.json) results.push({ pr, error: err, ...review, verdict: null, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...provenance, ...contextOutput });
+      if (opts.json) results.push({ pr, error: err, ...review, verdict: null, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...reviewCwdOutput, ...provenance, ...contextOutput });
       else deps.error(`PR ${pr}: ${err}\n${renderProvenance(diffRead)}\n${reviewerContextStatus}`);
       failed += 1;
       continue;
     }
     const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
     const jsonReview = review.reviewed === true ? review : { ...review, verdict: null };
-    if (opts.json) results.push({ pr, model: selectedModel, ...jsonReview, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...provenance, ...contextOutput, evidence: evidence.evidence, prDiffFiles: evidence.prDiffFiles, ...(evidence.authoredFiles !== undefined ? { authoredFiles: evidence.authoredFiles } : {}) });
+    if (opts.json) results.push({ pr, model: selectedModel, ...jsonReview, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...reviewCwdOutput, ...provenance, ...contextOutput, evidence: evidence.evidence, prDiffFiles: evidence.prDiffFiles, ...(evidence.authoredFiles !== undefined ? { authoredFiles: evidence.authoredFiles } : {}) });
     else deps.print(`\n━━ PR ${pr} (${selectedModel}) ━━\n${renderProvenance(diffRead)}\n${evidenceLine}\n${reviewerContextStatus}\n${deps.renderReview(review)}`);
     // REVIEW-ERROR-RC — 기본(API)·role 경로가 1차·폴백 모두 실패해 reviewed≠true 로 끝나도 «못 리뷰한 PR» 이다(verdict:null).
     if (review.reviewed !== true) failed += 1;

package/src/budget/cost-tier-advisor.ts

@@ -0,0 +1,91 @@
+// Cost-tier advisor — when forecast says warn/throttle, suggest one step down
+// (premium → balanced → economy). Tier table values are estimates until
+// MODEL-BENCH replaces them.
+
+import { debug } from '../debug/log.js';
+import type { ForecastResult } from './forecaster.js';
+
+export type CostTier = 'premium' | 'balanced' | 'economy';
+
+export const COST_TIERS: Record<CostTier, {
+  label: string;
+  stages: { authoring: string; implement: string; review: string; judge: string };
+  usdPerTaskEstimate: number;
+  qualityRisk: string;
+  source: 'estimate';
+}> = {
+  premium: {
+    label: '프리미엄',
+    stages: {
+      authoring: 'claude-opus-4-7',
+      implement: 'gpt-6-astra',
+      review: 'claude-opus-4-7',
+      judge: 'grok-4.7',
+    },
+    usdPerTaskEstimate: 1.2,
+    qualityRisk: '낮음 — 최고 품질 유지',
+    source: 'estimate',
+  },
+  balanced: {
+    label: '균형',
+    stages: {
+      authoring: 'claude-sonnet-4-6',
+      implement: 'gpt-5.6-terra',
+      review: 'claude-sonnet-4-6',
+      judge: 'grok-4.6',
+    },
+    usdPerTaskEstimate: 0.45,
+    qualityRisk: '중간 — 대부분 작업에 충분',
+    source: 'estimate',
+  },
+  economy: {
+    label: '절약',
+    stages: {
+      authoring: 'claude-haiku-4-5',
+      implement: 'gpt-6-luna',
+      review: 'gemini-2.5-flash',
+      judge: 'gemini-3.5-flash-lite',
+    },
+    usdPerTaskEstimate: 0.12,
+    qualityRisk: '높음 — 단순·반복 작업에 적합',
+    source: 'estimate',
+  },
+};
+
+const DOWN_ONE: Record<CostTier, CostTier | null> = {
+  premium: 'balanced',
+  balanced: 'economy',
+  economy: null,
+};
+
+export function adviseCostTier(input: {
+  current: CostTier;
+  forecast: Pick<ForecastResult, 'recommendation' | 'usedPercent' | 'atCurrentPaceReachesLimitAt'>;
+}): {
+  from: CostTier;
+  to: CostTier;
+  savingPercent: number;
+  qualityRisk: string;
+  reason: string;
+} | null {
+  const { current, forecast } = input;
+  if (forecast.recommendation === 'safe') return null;
+
+  const to = DOWN_ONE[current];
+  if (!to) return null;
+
+  const fromTier = COST_TIERS[current];
+  const toTier = COST_TIERS[to];
+  const savingPercent = Math.round((1 - toTier.usdPerTaskEstimate / fromTier.usdPerTaskEstimate) * 100);
+  const reason = `예산 사용 ${forecast.usedPercent}% · 예측 ${forecast.recommendation} → ${toTier.label}로 내리면 약 ${savingPercent}% 절감`;
+
+  debug.log('budget.cost-tier', 'advised', { from: current, to, savingPercent });
+
+  return {
+    from: current,
+    to,
+    savingPercent,
+    qualityRisk: toTier.qualityRisk,
+    reason,
+  };
+}

package/src/budget/shadow-arms.ts

@@ -0,0 +1,77 @@
+// Shadow-arm launch plan — estimate which candidate models fit today's
+// shadow budget. Plans only: no live LLM calls.
+
+import { debug } from '../debug/log.js';
+import { estimateLlmCost } from './llm-cost.js';
+
+export type ShadowStage = 'authoring' | 'implement' | 'review' | 'judge';
+
+export type ShadowDifficulty = 'small' | 'medium' | 'umbrella' | 'rework';
+
+export interface PlanShadowArmsInput {
+  stage: ShadowStage;
+  difficulty: ShadowDifficulty;
+  inputTokens: number;
+  expectedOutputTokens: number;
+  candidates: string[];
+  spentTodayUsd: number;
+  dailyCapUsd: number;
+}
+
+export interface ShadowArmFire {
+  model: string;
+  estUsd: number;
+}
+
+export interface ShadowArmSkipped {
+  model: string;
+  reason: 'over-daily-cap' | 'unknown-price';
+}
+
+export interface ShadowArmsPlan {
+  fire: ShadowArmFire[];
+  skipped: ShadowArmSkipped[];
+  remainingUsd: number;
+}
+
+export function planShadowArms(input: PlanShadowArmsInput): ShadowArmsPlan {
+  const fire: ShadowArmFire[] = [];
+  const skipped: ShadowArmSkipped[] = [];
+  let remainingUsd = input.dailyCapUsd - input.spentTodayUsd;
+  let overDailyCap = false;
+
+  for (const model of input.candidates) {
+    // Once the cap is crossed, every later arm is over-daily-cap — even one
+    // whose price is unknown (the cap decision comes first).
+    if (overDailyCap) {
+      skipped.push({ model, reason: 'over-daily-cap' });
+      continue;
+    }
+    const estimate = estimateLlmCost({
+      model,
+      inputTokens: input.inputTokens,
+      outputTokens: input.expectedOutputTokens,
+    });
+    if (estimate.kind !== 'known') {
+      skipped.push({ model, reason: 'unknown-price' });
+      continue;
+    }
+    if (estimate.usd > remainingUsd) {
+      skipped.push({ model, reason: 'over-daily-cap' });
+      overDailyCap = true;
+      continue;
+    }
+    fire.push({ model, estUsd: estimate.usd });
+    remainingUsd -= estimate.usd;
+  }
+
+  debug.log('budget.shadow-arms', 'planned', {
+    stage: input.stage,
+    difficulty: input.difficulty,
+    fire: fire.length,
+    skipped: skipped.length,
+    remainingUsd,
+  });
+
+  return { fire, skipped, remainingUsd };
+}

package/src/budget/types.ts

@@ -158,8 +158,9 @@ export type ResetCreditExpiryAxis =
   | { readonly status: 'expired'; readonly expiresAt: string; readonly hasUnknownExpiry: boolean };
 
 export interface AccountUsageRow {
-  /** `zai` = GLM Coding Plan(ZAI-CODING-PLAN-PROVIDER) — `ZAI_API_KEY` 가 있을 때만 행이 생긴다. */
-  readonly provider: 'codex' | 'grok' | 'openrouter' | 'zai';
+  /** `zai` = GLM Coding Plan(ZAI-CODING-PLAN-PROVIDER) — `ZAI_API_KEY` 가 있을 때만 행이 생긴다.
+   *  `claude` = Claude Code 구독(CLAUDE-USAGE-WINDOW) — OAuth 토큰이 있을 때만 행이 생긴다. */
+  readonly provider: 'codex' | 'claude' | 'grok' | 'openrouter' | 'zai';
   readonly accountName: string;
   readonly accountCount: number;
   readonly soleAccount: boolean;
@@ -173,7 +174,8 @@ export interface AccountUsageRow {
 export interface UnifiedUsageReport {
   readonly rows: readonly AccountUsageRow[];
   /** `zai` 는 키가 있을 때만 실린다(없으면 종전 JSON 과 같다). */
-  readonly accountCounts: Readonly<Record<'codex' | 'grok' | 'openrouter', number>> & { readonly zai?: number };
+  /** `claude` 도 토큰이 있을 때만 실린다(없으면 종전 JSON 과 같다). */
+  readonly accountCounts: Readonly<Record<'codex' | 'grok' | 'openrouter', number>> & { readonly claude?: number; readonly zai?: number };
   /** GLM Coding Plan 상세(창 · 우리 적산 · 잔액 사용 · 마지막 한도 코드) — 키가 있을 때만. */
   readonly zaiCodingPlan?: import('../llm/zai-coding-plan.js').ZaiUsageView;
 }