elanous 0.2.35 → 0.2.37

package/src/autopilot/lineage/sources.ts

@@ -30,7 +30,7 @@ export function harnessRunsToLineage(entries: readonly RunLedgerTimelineEntry[])
     store: 'observation' as const,
     at: entry.executedAt,
     seq: entry.pieceIndex,
-    summary: `self-implement run ${entry.runId}${entry.orchestrationId ? ` · orchestration ${entry.orchestrationId}` : ''}${entry.shardId ? ` · shard ${entry.shardId}` : ''}${entry.pieceTotal !== undefined ? ` · ${entry.pieceTotal} pieces` : ''}`,
+    summary: `self-implement run ${entry.runId}${entry.orchestrationId ? ` · orchestration ${entry.orchestrationId}` : ''}${entry.shardId ? ` · shard ${entry.shardId}` : ''}${entry.pieceTotal !== undefined ? ` · ${entry.pieceTotal} pieces` : ''}${entry.unitVisits?.orphanCount ? ` · graph.unit orphan ${entry.unitVisits.orphanCount}` : ''}`,
   }));
 }
 

package/src/autopilot/mission-codebase-gate.ts

@@ -28,6 +28,116 @@ import { llmUsageCostFields } from '../budget/llm-cost.js';
 
 const execFileAsync = promisify(execFile);
 
+/** git 서브프로세스 대역 — term grep 동시성 계약을 실제 git 없이 재기 위한 교체점. */
+export type ExecFileLike = (
+  file: string,
+  args: readonly string[],
+  options: { cwd?: string; encoding: 'utf-8'; maxBuffer: number },
+) => Promise<{ stdout: string; stderr?: string }>;
+
+const defaultExecFile: ExecFileLike = execFileAsync as unknown as ExecFileLike;
+let execFileImpl: ExecFileLike = defaultExecFile;
+
+/** 테스트 seam — null/미지정이면 실제 git 서브프로세스로 되돌린다. */
+export function setExecFileForTest(fn?: ExecFileLike | null): void {
+  execFileImpl = fn ?? defaultExecFile;
+}
+
+/** term 별 git grep 동시 실행 상한(기본 3 · OP 06:3x 실측 13개 동시 부하 101 을 막는다). */
+export const TERM_GREP_CONCURRENCY = 3;
+let termGrepConcurrency: number = TERM_GREP_CONCURRENCY;
+
+/** 테스트 seam — 상한 없음(Infinity)과 결과 불변을 비교하기 위해 올린다. */
+export function setTermGrepConcurrencyForTest(value?: number | null): void {
+  termGrepConcurrency = value ?? TERM_GREP_CONCURRENCY;
+}
+
+/** 상한 클램프 — 풀 크기와 관측값이 같은 규칙을 쓰게 한 곳에 둔다. */
+function effectiveConcurrency(concurrency: number, width: number): number {
+  const limit = Number.isFinite(concurrency) ? Math.max(1, Math.floor(concurrency)) : width;
+  return Math.max(1, Math.min(limit, width));
+}
+
+/** 동시 실행 상한 풀 — 결과 순서는 입력 순서 그대로(순위 계산이 순서에 의존하지 않게). */
+async function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  worker: (item: T) => Promise<R>,
+): Promise<R[]> {
+  const results = new Array<R>(items.length);
+  const size = effectiveConcurrency(concurrency, items.length);
+  let cursor = 0;
+  await Promise.all(
+    Array.from({ length: size }, async () => {
+      for (let index = cursor++; index < items.length; index = cursor++) {
+        results[index] = await worker(items[index]!);
+      }
+    }),
+  );
+  return results;
+}
+
+/** cwd seam 복원의 **단일 소유** — `process.chdir` 로 되돌리는 곳은 이 묶음(acquire/release) 하나뿐이다.
+ *
+ *  ⛔ 왜 «생산» 이 소유하나: 한 번의 grounding 런은 persistent 코드 채널·skill 도구처럼 **임의 코드**를
+ *  지나고(`dispatchTool` → shell·pty), 그 코드가 cwd 를 옮긴 채 끝날 수 있다. 되돌리기를 «각 의존성» 에
+ *  맡기면 런이 마감(타임아웃)·예외로 끝나는 순간 그 되돌리기가 통째로 빠지고, 다음 런의 seam
+ *  (`deps.cwd ?? process.cwd()`)이 **엉뚱한 트리를 저장소 루트로 읽어** 조용히 0건 grounding 을 낸다
+ *  (#29343 r3 지적: 타임아웃 뒤 cwd seam 오염).
+ *
+ *  ⛔ 소유는 «런마다» 가 아니라 «겹친 런 묶음» 하나다 — cwd 는 프로세스 전역이므로 런별 스냅샷은 겹침에서
+ *  깨진다(A 가 임시 트리로 옮긴 사이 B 가 시작하면 B 가 그 임시 트리를 «시작 자리» 로 저장하고, A 가 되돌린
+ *  뒤 B 가 다시 임시 트리로 되돌린다). ⇒ 첫 런이 시작 자리를 한 번 스냅샷하고, 겹쳐 들어온 런은 그 값을
+ *  seam 으로 «물려받으며», 마지막으로 나가는 런만 되돌린다. 마감으로 «버려진» 런도 본문이 끝날 때까지
+ *  holder 로 남으므로, 마감 뒤에 재개된 본문이 cwd 를 옮겨도 그 뒤의 런은 오염된 자리를 seam 으로 읽지 않고
+ *  본문이 끝나는 순간 되돌려진다.
+ *  ⛔ 복원 보장의 «경계»: 복원은 런의 수명 안에서만 소유한다. 호출자가 마감으로 버렸는데 본문이 «끝나지
+ *  않으면» 전역 cwd 는 그 본문이 끝날 때까지 옮겨진 채 남는다 — 이 함수에는 호출자의 마감 신호가 들어오지
+ *  않고, 진행 중인 본문 밑의 cwd 를 남이 바꾸면 그 본문을 깨뜨린다. 그 사이 보장되는 것은 «겹쳐 들어온
+ *  grounding 런의 seam 이 오염된 자리를 읽지 않는다» 이고, 본문이 끝나는 순간 마지막 holder 가 되돌린다
+ *  (mission-codebase-gate.test.ts «마감 뒤 재개» 시험이 이 경계를 그대로 잰다).
+ *  ⛔ 되돌리기 실패는 grounding 결과를 바꾸지 않되 «조용히 삼키지» 않는다 — `mission.grounding`
+ *  `cwd-restore-failed` 로 남긴다(기존 이벤트 형식은 그대로). */
+interface CwdSeamOwner { root: string; holders: number }
+let cwdSeamOwner: CwdSeamOwner | null = null;
+
+/** 소유 토큰 — `owned=false` 면 이 런은 묶음에 들지 않았다(시작 자리를 못 읽었다) ⇒ 되돌릴 것도 없다.
+ *  ⛔ 절대 throw 하지 않는다: 지워진 cwd 에서도 `deps.cwd` 를 받은 호출은 예전처럼 진행해야 한다. */
+interface CwdSeamLease { root: string | null; owned: boolean }
+
+function acquireCwdSeam(): CwdSeamLease {
+  if (!cwdSeamOwner) {
+    let root: string;
+    try { root = process.cwd(); } catch { return { root: null, owned: false }; }
+    cwdSeamOwner = { root, holders: 0 };
+  }
+  cwdSeamOwner.holders += 1;
+  return { root: cwdSeamOwner.root, owned: true };
+}
+
+function releaseCwdSeam(lease: CwdSeamLease): void {
+  if (!lease.owned) return;
+  const owner = cwdSeamOwner;
+  if (!owner) return;
+  owner.holders -= 1;
+  if (owner.holders > 0) return;
+  cwdSeamOwner = null;
+  let current: string | null = null;
+  try { current = process.cwd(); } catch { /* 지워진 자리 — 아래에서 되돌린다 */ }
+  if (current === owner.root) return;
+  try {
+    process.chdir(owner.root);
+  } catch (e) {
+    try {
+      debug.log('mission.grounding', 'cwd-restore-failed', {
+        root: owner.root,
+        current,
+        error: e instanceof Error ? e.message.slice(0, 200) : String(e).slice(0, 200),
+      }, { level: 'warn' });
+    } catch { /* 관측 실패가 grounding 을 바꾸지 않는다 */ }
+  }
+}
+
 function logLlmUsage(site: 'codebase-gate-injected' | 'codebase-gate-dynamic', model: string, usage: LLMUsage): void {
   try {
     debug.log('llm.usage', 'llm-usage', {
@@ -215,28 +325,37 @@ export function commonTermCoverageWeight(matchLines: number): number {
 }
 
 async function searchRepository(terms: string[], limit: number, cwd: string | undefined, paths: string[], commonPaths = paths): Promise<string[]> {
-  if (!terms.length) return [];
+  // 같은 키워드는 한 번만 실행한다 — 실행·랭킹이 같은 목록을 쓰므로 결과는 결정적이다.
+  const uniqueTerms = [...new Set(terms)];
+  if (!uniqueTerms.length) return [];
   const fileTerms = new Map<string, Set<string>>(); // file → 매칭된 서로 다른 term
   const fileLines = new Map<string, number>();       // file → 총 매칭 라인 수
   const fileTermLines = new Map<string, Map<string, number>>(); // file → term별 매칭 라인 수
   const tooCommon = new Set<string>();               // 200+ 파일 매칭 = 밀도 감쇠 대상
-  const trackedPaths = await execFileAsync('git', ['ls-files', '--', ...paths], { ...(cwd ? { cwd } : {}), encoding: 'utf-8', maxBuffer: 8_000_000 })
+  const trackedPaths = await execFileImpl('git', ['ls-files', '--', ...paths], { ...(cwd ? { cwd } : {}), encoding: 'utf-8', maxBuffer: 8_000_000 })
     .then(({ stdout }) => stdout.split('\n').filter(Boolean))
     .catch(() => [] as string[]);
-  const pathMatches = new Map(terms.map((term) => [term, trackedPaths.filter((file) => file.toLowerCase().includes(term)).length]));
-  // term별 git grep 을 병렬 실행(순차 spawnSync ~16초 → 병렬 ~2초). git grep=현재 워킹트리
-  // 파일 검색(history 아님)·gitignore/바이너리 자동 제외. 호출자가 코드와 문서를 분리한다.
-  const perTerm = await Promise.all(terms.map(async (t) => {
+  const pathMatches = new Map(uniqueTerms.map((term) => [term, trackedPaths.filter((file) => file.toLowerCase().includes(term)).length]));
+  // term별 git grep 을 동시 실행 상한 풀(기본 3)로 돌린다 — 무제한 병렬은 mbp 1분 부하 101·git grep
+  // 13개 동시(OP 06:3x 실측)를 만들었다. git grep=현재 워킹트리 파일 검색(history 아님)·
+  // gitignore/바이너리 자동 제외. 호출자가 코드와 문서를 분리한다.
+  const termGrepStartedAt = Date.now();
+  const perTerm = await mapWithConcurrency(uniqueTerms, termGrepConcurrency, async (t) => {
     try {
       // -c: file:count. -i 무시·-I 바이너리제외. term 하나씩(어느 term 이 걸렸는지 추적).
-      const { stdout } = await execFileAsync('git', ['grep', '-c', '-i', '-I', '-e', t, '--', ...paths], { ...(cwd ? { cwd } : {}), encoding: 'utf-8', maxBuffer: 8_000_000 });
+      const { stdout } = await execFileImpl('git', ['grep', '-c', '-i', '-I', '-e', t, '--', ...paths], { ...(cwd ? { cwd } : {}), encoding: 'utf-8', maxBuffer: 8_000_000 });
       const rows = stdout.split('\n').filter(Boolean);
-      const commonRows = commonPaths === paths ? rows : await execFileAsync('git', ['grep', '-c', '-i', '-I', '-e', t, '--', ...commonPaths], { ...(cwd ? { cwd } : {}), encoding: 'utf-8', maxBuffer: 8_000_000 })
+      const commonRows = commonPaths === paths ? rows : await execFileImpl('git', ['grep', '-c', '-i', '-I', '-e', t, '--', ...commonPaths], { ...(cwd ? { cwd } : {}), encoding: 'utf-8', maxBuffer: 8_000_000 })
         .then(({ stdout }) => stdout.split('\n').filter(Boolean))
         .catch(() => [] as string[]);
       return { t, rows, commonCount: commonRows.length };
     } catch { return { t, rows: [] as string[], commonCount: 0 }; } // git grep no-match = exit 1(throw) → 빈 결과
-  }));
+  });
+  debug.log('grounding.search', 'term-grep-batch', {
+    terms: uniqueTerms.length,
+    concurrency: effectiveConcurrency(termGrepConcurrency, uniqueTerms.length),
+    ms: Date.now() - termGrepStartedAt,
+  });
   for (const { t, rows, commonCount } of perTerm) {
     if (commonCount > 200) {
       tooCommon.add(t);
@@ -260,7 +379,7 @@ async function searchRepository(terms: string[], limit: number, cwd: string | un
     const cover = [...ts].reduce((total, term) => total + (tooCommon.has(term)
       ? commonTermCoverageWeight(termLines?.get(term) ?? 0)
       : 1), 0);
-    const nameTerms = terms.filter((t) => f.toLowerCase().includes(t));
+    const nameTerms = uniqueTerms.filter((t) => f.toLowerCase().includes(t));
     const nameWeight = nameTerms.reduce((total, term) => {
       const matches = pathMatches.get(term) ?? 0;
       // 경로상 유일한 식별자는 강한 +25를 유지하고, 공유 조각은 매칭 경로 수에 반비례해 감쇠한다.
@@ -531,8 +650,12 @@ export async function groundMissionInCodebase(
   goal: string, deps: { cwd?: string; seedPaths?: readonly string[]; searchTerms?: SearchTermFn; skillIndex?: SkillIndexFn; pickSkills?: SkillPickFn; recallMemory?: RecallMemoryFn; recallSelf?: RecallSelfFn; refDigest?: RefDigestFn; persistent?: PersistentGroundingDeps | false } & CapsuleGroundingDeps = {},
 ): Promise<CodebaseGrounding> {
   // 호출자가 준 root를 모든 저장소 채널과 corpus 관측에 공유한다. 미지정 호출은 기존처럼 프로세스 cwd를 쓴다.
+  // ⛔ seam 은 «읽기» 만 하지 않는다 — 시작 자리를 소유자(acquireCwdSeam)에게서 받고 finally 에서 돌려준다.
+  //    겹친 런은 첫 런의 스냅샷을 물려받으므로, 다른 런이 옮겨 놓은 cwd 를 시작 자리로 읽지 않는다.
+  const cwdLease = acquireCwdSeam();
   const cwdSource = deps.cwd === undefined ? 'process' : 'caller';
-  const searchRoot = deps.cwd ?? process.cwd();
+  // 시작 자리를 못 읽었으면(지워진 cwd) 소유하지 않는다 — caller root 는 그대로 쓰고, 미지정이면 예전처럼 process.cwd() 가 판정한다.
+  const searchRoot = deps.cwd ?? cwdLease.root ?? process.cwd();
   const startedAt = performance.now();
   let searchTermsElapsedMs = 0;
   let persistentElapsedMs = 0;
@@ -695,7 +818,13 @@ export async function groundMissionInCodebase(
     debug.log('mission.grounding', 'corpus', { grounded: false, reason: 'error', cwd: searchRoot, cwdSource, error: e instanceof Error ? e.message.slice(0, 200) : String(e).slice(0, 200), persistentEvidence: null, persistentStopReason: null, codeChannel: 'failed' }, { level: 'warn' });
     return { grounded: false, context: '', files: [], persistentEvidence: [], skillFacts: [], codeFacts: [], memoryFacts: [], documentFacts: [], refFacts: [], ptyFacts: [] };
   } finally {
-    observeTiming();
+    // 정상·예외·타임아웃 어느 경로로 끝났든 소유를 돌려준다 — 마지막 holder 가 시작 자리로 되돌린다.
+    //    되돌리기를 관측보다 «먼저» 둔다: 관측이 무엇을 하든 복원이 빠지지 않는다.
+    try {
+      releaseCwdSeam(cwdLease);
+    } finally {
+      observeTiming();
+    }
   }
 }
 

package/src/autopilot/pr-manager.ts

@@ -127,7 +127,7 @@ export interface UpsertPrResult { url: string; reused: boolean }
  *  나머지 reason(add/commit/push/gh)은 진짜 실패로 detail(stderr)과 함께 관측·pr-failed. */
 export type UpsertPrOutcome =
   | { ok: true; url: string; reused: boolean; labelsApplied?: boolean; labelsOmitted?: boolean;
-      supersededPr?: number }
+      supersededPr?: number; boundCardHeadRefName?: string }
   | { ok: false; reason: 'add' | 'commit' | 'base' | 'noop' | 'push' | 'gh' | 'guard'; detail: string;
       incident?: PrCreateFailureIncident };
 
@@ -186,9 +186,9 @@ function readPrMergeState(run: CmdRunner, prNumber: number, cwd?: string): Merge
 
 /** 열린 PR 조회의 판별 가능한 결과. `SKIPPED`는 기본 브랜치 표식이라 gh를 호출하지 않았음을 뜻한다. */
 export type FindPrForBranchOutcome =
-  | { status: 'ok OUTPUT'; url: string }
-  | { status: 'ok EMPTY'; url: null }
-  | { status: 'FAILED'; url: null; rc?: number; stderrTail?: string }
+  | { status: 'ok OUTPUT'; url: string; rc?: number; stderrTail?: string }
+  | { status: 'ok EMPTY'; url: null; rc?: number; stderrTail?: string }
+  | { status: 'FAILED'; url: null; rc?: number; stderrTail?: string; stdoutTail?: string }
   | { status: 'SKIPPED'; url: null };
 
 export interface PrManager {
@@ -264,10 +264,10 @@ export function prBaseFromComparison(comparisonBase: string): string {
  * Feature-branch HEAD-only commits are excluded because the range is the base
  * ref itself, not `HEAD`. Network/`gh` are never used.
  */
-export function landingHistoryGitLogArgs(since: string, baseRef: string): string[] {
+export function landingHistoryGitLogArgs(since: string | null, baseRef: string): string[] {
   return [
     'log',
-    `--since=${since}`,
+    ...(since === null ? [] : [`--since=${since}`]),
     '--pretty=format:commit %H',
     '--name-only',
     '--no-merges',
@@ -338,8 +338,12 @@ export interface PrCreateStageObservation {
   ran: boolean;
   rc?: number;
   stderrTail?: string;
+  stdoutTail?: string;
   /** push 단계 전용 — force-push 최종 성공 여부. */
   ok?: boolean;
+  /** gh 단계 전용 — 재시도 전후의 목록 조회와 생성 명령을 각각 보존한다. */
+  lookup?: PrCreateStageObservation;
+  create?: PrCreateStageObservation;
 }
 /** PR 생성 실패 한 건 — push/gh 두 단계 관측을 하나의 기록에. */
 export interface PrCreateFailureIncident {
@@ -380,8 +384,26 @@ export function recordPrCreateFailureIncident(incident: PrCreateFailureIncident)
     ...(incident.runId ? { runId: sanitizeCredentialText(incident.runId) } : {}),
     branch: sanitizeCredentialText(incident.branch),
     remote: sanitizeCredentialText(incident.remote),
-    push: { ...incident.push, ...(incident.push.stderrTail ? { stderrTail: stderrTailOf(incident.push.stderrTail) } : {}) },
-    gh: { ...incident.gh, ...(incident.gh.stderrTail ? { stderrTail: stderrTailOf(incident.gh.stderrTail) } : {}) },
+    push: {
+      ...incident.push,
+      ...(incident.push.stderrTail ? { stderrTail: stderrTailOf(incident.push.stderrTail) } : {}),
+      ...(incident.push.stdoutTail ? { stdoutTail: stderrTailOf(incident.push.stdoutTail) } : {}),
+    },
+    gh: {
+      ...incident.gh,
+      ...(incident.gh.stderrTail ? { stderrTail: stderrTailOf(incident.gh.stderrTail) } : {}),
+      ...(incident.gh.stdoutTail ? { stdoutTail: stderrTailOf(incident.gh.stdoutTail) } : {}),
+      ...(incident.gh.lookup ? { lookup: {
+        ...incident.gh.lookup,
+        ...(incident.gh.lookup.stderrTail ? { stderrTail: stderrTailOf(incident.gh.lookup.stderrTail) } : {}),
+        ...(incident.gh.lookup.stdoutTail ? { stdoutTail: stderrTailOf(incident.gh.lookup.stdoutTail) } : {}),
+      } } : {}),
+      ...(incident.gh.create ? { create: {
+        ...incident.gh.create,
+        ...(incident.gh.create.stderrTail ? { stderrTail: stderrTailOf(incident.gh.create.stderrTail) } : {}),
+        ...(incident.gh.create.stdoutTail ? { stdoutTail: stderrTailOf(incident.gh.create.stdoutTail) } : {}),
+      } } : {}),
+    },
   };
   debug.log('autopilot.pr-manager', 'pr-create-failure-incident', safe);
   return safe;
@@ -533,17 +555,37 @@ function reuseSameCellPr(run: CmdRunner, input: UpsertPrInput, target: NonNullab
     if (!runKey) return fail(input.runId ? 'new run id invalid for scratch ref' : 'run id required for scratch ref');
     const scratch = `self-impl/pr-create-r${runKey}-${randomUUID()}`;
     const scratchRef = `refs/heads/${scratch}`;
+    // ⛔ push 보고는 원격의 진실이 아니다 — ref 를 만든 뒤에도 exit≠0 으로 끝날 수 있고, 삭제가
+    //    실패로 보고돼도 이미 지워졌을 수 있다. 그래서 새 draft 결과가 확정되는 즉시 **이 시도가
+    //    만든 scratch ref 하나만** 상대로 「남았나 보고 → 지운다」. 지우지 못하면 그 이유를 원장에
+    //    남긴다(다른 ref·가지·PR 은 건드리지 않는다).
+    const reapScratchRef = (outcome: 'branch-created' | 'create-refused' | 'upload-failed'): void => {
+      // 업로드가 실패로 보고돼도 원격에 ref 가 남아 있을 수 있다 — 먼저 읽고 건너뛰면 «읽은 뒤
+      // 늦게 착지한» ref 가 남는 창이 생긴다. 그래서 결과와 무관하게 늘 삭제를 시도하고,
+      // 원격이 «그런 ref 없음» 이라 답하면 이미 없는 것이므로 정리 실패로 세지 않는다.
+      let removed = run('git', ['-C', cwd, 'push', 'origin', `:${scratchRef}`]);
+      if (!removed.ok && isTransientPushFailure(removed.err || removed.out))
+        removed = run('git', ['-C', cwd, 'push', 'origin', `:${scratchRef}`]);
+      if (removed.ok) return;
+      if (/remote ref does not exist/i.test(`${removed.err ?? ''}\n${removed.out ?? ''}`)) {
+        debug.log('autopilot.pr-manager', 'same-cell-scratch-absent', { scratchRef, outcome });
+        return;
+      }
+      debug.log('autopilot.pr-manager', 'same-cell-scratch-cleanup-failed',
+        { scratchRef, outcome, detail: removed.err || removed.out,
+          stderr: removed.err ?? '', stdout: removed.out, truncated: false }, { level: 'warn' });
+    };
     const uploaded = run('git', ['-C', cwd, 'push', 'origin', `HEAD:${scratchRef}`]);
-    if (!uploaded.ok) return fail(`new run object upload failed: ${(uploaded.err || uploaded.out).slice(0, 220)}`);
+    if (!uploaded.ok) {
+      reapScratchRef('upload-failed');
+      return fail(`new run object upload failed: ${(uploaded.err || uploaded.out).slice(0, 220)}`);
+    }
     const repository = run('gh', ['repo', 'view', '--json', 'nameWithOwner', '-q', '.nameWithOwner'], { cwd });
     const repoName = repository.out.trim();
     const createdRef = repository.ok && /^[^/\s]+\/[^/\s]+$/.test(repoName)
       ? run('gh', ['api', '--method', 'POST', `repos/${repoName}/git/refs`, '-f', `ref=${newRef}`, '-f', `sha=${localHead.out.trim()}`], { cwd })
       : { ok: false, out: '', err: 'repository identity unavailable' };
-    const removedScratch = run('git', ['-C', cwd, 'push', 'origin', `:${scratchRef}`]);
-    if (!removedScratch.ok) debug.log('autopilot.pr-manager', 'same-cell-scratch-cleanup-failed',
-      { scratchRef, detail: removedScratch.err || removedScratch.out,
-        stderr: removedScratch.err ?? '', stdout: removedScratch.out, truncated: false }, { level: 'warn' });
+    reapScratchRef(createdRef.ok ? 'branch-created' : 'create-refused');
     if (!createdRef.ok) return fail(`new run branch create refused: ${(createdRef.err || createdRef.out).slice(0, 220)}`);
     const stateLabels = new Set(labelsForAxis('state').map(label => label.name));
     const labels = [...new Set([...(input.labels ?? []).filter(label => !stateLabels.has(label as typeof PR_LABEL_NAMES.running)),
@@ -595,7 +637,8 @@ function reuseSameCellPr(run: CmdRunner, input: UpsertPrInput, target: NonNullab
   if (!pushed.ok) return fail(`fast-forward push refused: ${(pushed.err || pushed.out).slice(0, 220)}`);
   debug.log('autopilot.pr-manager', 'same-cell-push-decision', { ...pushEvidence, outcome: 'allowed', reason: 'bound-card-pr-head-fast-forward' });
   debug.log('autopilot.pr-manager', 'same-cell-reused', { pr: target.number, cellId: target.cellId, cardId: target.cardId, branch: target.branch });
-  return editExistingPr(run, input, pr.url);
+  const edited = editExistingPr(run, input, pr.url);
+  return edited.ok ? { ...edited, boundCardHeadRefName: target.branch } : edited;
 }
 
 /** ★ PR 매니저 팩토리(대표 2026-07-12) — CmdRunner 주입(테스트 스텁). 실 배선은 기본 러너. */
@@ -622,13 +665,23 @@ export function makePrManager(
     }
     const r = run('gh', ['pr', 'list', '--head', branch, '--state', 'open', '--json', 'url', '--jq', '.[0].url // ""'], cwd ? { cwd } : undefined);
     const url = r.out.trim() || null;
+    const lookupEvidence = {
+      ...(typeof r.rc === 'number' ? { rc: r.rc } : {}),
+      ...(stderrTailOf(r.err) ? { stderrTail: stderrTailOf(r.err) } : {}),
+    };
+    const lookupFailureEvidence = {
+      ...lookupEvidence,
+      ...(stderrTailOf(r.out) ? { stdoutTail: stderrTailOf(r.out) } : {}),
+    };
     const outcome: FindPrForBranchOutcome = !r.ok
-      ? { status: 'FAILED', url: null,
-          ...(typeof r.rc === 'number' ? { rc: r.rc } : {}),
-          ...(stderrTailOf(r.err || r.out) ? { stderrTail: stderrTailOf(r.err || r.out) } : {}) }
+      ? { status: 'FAILED', url: null, ...lookupFailureEvidence }
       : url
         ? { status: 'ok OUTPUT', url }
         : { status: 'ok EMPTY', url: null };
+    if (r.ok) {
+      for (const [key, value] of Object.entries(lookupEvidence))
+        if (value !== undefined) Object.defineProperty(outcome, key, { value, enumerable: false });
+    }
     debug.log('autopilot.pr-manager', 'lookup', {
       branch,
       // ⚠️ 조회는 --jq '.[0].url' 이라 최대 한 줄이다 — "매칭된 PR 수"가 아니라 "돌아온 URL 줄 수"다.
@@ -825,11 +878,22 @@ export function makePrManager(
       const waitForPushRetry = input.waitForPushRetry ?? defaultWaitForPushRetry;
       // ★ 칸 PR-CREATE-FAIL-OBSERVE-FU — push/gh 단계 관측을 쌓아 실패 시 한 incident 로.
       const pushStage: PrCreateStageObservation = { stage: 'push', ran: false };
-      const ghStage: PrCreateStageObservation = { stage: 'gh', ran: false };
+      const ghStage: PrCreateStageObservation = {
+        stage: 'gh', ran: false,
+        lookup: { stage: 'gh', ran: false },
+        create: { stage: 'gh', ran: false },
+      };
+      const observeGhCommand = (r: CmdResult): PrCreateStageObservation => ({
+        stage: 'gh', ran: true, ...(typeof r.rc === 'number' ? { rc: r.rc } : {}),
+        ...(stderrTailOf(r.err) ? { stderrTail: stderrTailOf(r.err) } : {}),
+        ...(stderrTailOf(r.out) ? { stdoutTail: stderrTailOf(r.out) } : {}),
+      });
       const markGhRan = (r: CmdResult): CmdResult => {
         ghStage.ran = true;
         ghStage.rc = r.rc;
         ghStage.stderrTail = stderrTailOf(r.err);
+        ghStage.stdoutTail = stderrTailOf(r.out);
+        ghStage.create = observeGhCommand(r);
         return r;
       };
       const failedCreate = (reason: 'push' | 'gh', detail: string): UpsertPrOutcome =>
@@ -857,9 +921,16 @@ export function makePrManager(
       const existing = findPrForBranchOutcome(input.branch, cwd);
       if (existing.status !== 'SKIPPED') {
         ghStage.ran = true;
+        ghStage.lookup = {
+          stage: 'gh', ran: true,
+          ...(typeof existing.rc === 'number' ? { rc: existing.rc } : {}),
+          ...(existing.stderrTail ? { stderrTail: existing.stderrTail } : {}),
+          ...(existing.status === 'FAILED' && existing.stdoutTail ? { stdoutTail: existing.stdoutTail } : {}),
+        };
         if (existing.status === 'FAILED') {
           ghStage.rc = existing.rc;
           ghStage.stderrTail = existing.stderrTail;
+          ghStage.stdoutTail = existing.stdoutTail;
         }
       }
       if (existing.url) {

package/src/boot/daemon-runtime.ts

@@ -54,6 +54,7 @@ import type { CoreTurnDispatchTool } from '../core-turn/index.js';
 import { elanousSelfAccessPrompt } from '../agent/self-ambient.js';
 import { createToolCwdResolver, type ToolCwdResolver } from './tool-cwd.js';
 import { resolveSessionProjectContext } from '../project/session-context.js';
+import { buildUniversalPreamble, loadProjectAnchorWithMeta } from '../prompt-library/universal-preamble.js';
 import { debug } from '../debug/log.js';
 import { resolvePersonaAddress } from '../intake-plane/persona-answer.js';
 import { awaitGlobalPersonaLoad, getGlobalPersonaRegistry } from '../persona/global-registry.js';
@@ -601,13 +602,34 @@ export function createDaemonRunTurn(
   }
   const killNonDetachedPty = opts.killNonDetachedPty;
 
+  // TUI-CONTINUE-SESSION (0.2.35) — inject the daemon TUI preamble once per
+  // runtime, even when `--continue` reattaches persisted history. Never use
+  // the ACP client's cwd as an anchor path; project/session context is server-owned.
+  const preambleInjectedSessions = new Set<string>();
+
   const deps: CoreTurnBridgeDeps = {
     // Persists the user message AND builds the LLM-facing list. See
     // daemon-history-helper.ts for the per-turn shape. Cleanup C1
     // moved this out of an inline closure to fix the user-message
     // persistence bug uniformly across all daemon paths.
     getMessages: ({ sessionId, userText, promptBlocks, promptMeta }) => {
-      const projectInstructions = resolveSessionProjectContext(sessionId)?.instructions;
+      const isFirstTurn = history.get(sessionId).length === 0;
+      const projectContext = resolveSessionProjectContext(sessionId);
+      const inputSource = readInputSourceMeta(promptMeta as Record<string, unknown> | undefined);
+      // The daemon API is the local CLI/TUI prompt route. Other ACP surfaces
+      // keep their existing system prompt unchanged.
+      const isDaemonTuiTurn = inputSource?.kind === 'daemon-api';
+      const anchorCwd = isDaemonTuiTurn ? projectContext?.cwd : undefined;
+      const firstTurnPreamble = anchorCwd && !preambleInjectedSessions.has(sessionId)
+        ? buildUniversalPreamble({
+            cwd: anchorCwd,
+            ...(surface.specs.length > 0 ? { enabledTools: surface.specs.map((spec) => spec.name) } : {}),
+          })
+        : [];
+      if (firstTurnPreamble.length > 0) preambleInjectedSessions.add(sessionId);
+      // `buildUniversalPreamble` carries the project AGENTS.md on the TUI's
+      // first attached turn. Do not also append `projectInstructions` there.
+      const projectInstructions = firstTurnPreamble.length > 0 ? undefined : projectContext?.instructions;
       const baseSystemPrompt = [composeDaemonSystemPrompt(opts.systemPrompt, promptMeta, sessionId), projectInstructions]
         .filter(Boolean).join('\n\n');
       // Image-pipeline followup #4 (2026-05-05) — append daemon webterm
@@ -631,11 +653,21 @@ export function createDaemonRunTurn(
       const hasNonTextBlock = !!promptBlocks?.some(
         (b) => (b as { type?: string }).type !== 'text',
       );
-      const isFirstTurn = history.get(sessionId).length === 0;
       const messages = hasNonTextBlock
         ? appendUserPromptBlocksAndBuildMessages(history, sessionId, promptBlocks!, systemPrompt)
         : appendUserAndBuildMessages(history, sessionId, userText, systemPrompt);
-      return prependChatPersonaOnLaterTurn(messages, isFirstTurn);
+      const withPersona = prependChatPersonaOnLaterTurn(messages, isFirstTurn);
+      if (firstTurnPreamble.length === 0) return withPersona;
+      const anchor = loadProjectAnchorWithMeta(anchorCwd!);
+      debug.log('boot.daemon-runtime', 'first-turn-universal-preamble', {
+        sessionId,
+        cwd: anchorCwd,
+        source: projectContext ? 'project' : 'daemon',
+        systemMessages: firstTurnPreamble.length,
+        anchorFiles: anchor.files.map((file) => file.filename),
+        localAnchorFiles: anchor.files.filter((file) => file.local).map((file) => file.filename),
+      });
+      return [...firstTurnPreamble, ...withPersona];
     },
     getTools: () => surface.specs,
     dispatchTool: terminalCapableDispatch(surfaceHasPtyShell, async (name, args, ctx) => {

package/src/boot/daemon-tools/pty-shell.ts

@@ -106,9 +106,10 @@ export async function dispatchPtyShellTool(
   ctx?: DaemonToolDispatchCtx,
 ): Promise<unknown> {
   switch (name) {
-    case 'PtyShellStart':
+    case 'PtyShellStart': {
       // Autonomous surface — auto-approve the spawn (no HITL babysitting).
       return dispatchPtyShellStart(args, { requireApproval: false });
+    }
     case 'PtyShellPoll':
       return dispatchPtyShellPoll(args);
     case 'PtyShellSend':

package/src/boot/daemon-tools/self-implement.ts

@@ -286,6 +286,7 @@ export async function dispatchSelfImplement(
     goalFile = (await authorGoal(goalSourceText, ctx.cwd, {
       goalTitle: feature,
       decomposeSteps: createDecomposeSteps(ctx.signal, {
+        repositoryRoot: ctx.cwd,
         ...(adversarialReview !== undefined ? { adversarialReview } : {}),
         ...(recentStepCounts !== undefined ? { recentStepCounts } : {}),
       }),

package/src/budget/run-usage-rollup.ts

@@ -6,6 +6,7 @@ export interface RunUsageInput {
   site?: string | null;
   role?: string | null;
   phase?: string | null;
+  jobKind?: string | null;
   model?: string | null;
   billingProvider?: string | null;
   billing?: BillingRoute | null;
@@ -30,9 +31,11 @@ export interface RunUsageRow {
   runId: string;
   role?: string;
   site?: string;
-  model: string;
-  billingProvider: string;
-  billing: string;
+  jobKind?: string;
+  /** by:'job' 행은 종류별·호스트 합산 표이므로 실지 않는다(첫 행 대표값 오표출 방지). */
+  model?: string;
+  billingProvider?: string;
+  billing?: string;
   hostIds: string[];
   calls: number;
   inputTokens: number;
@@ -47,21 +50,23 @@ export interface RunUsageRow {
 }
 
 /** Aggregate llm-usage observations without turning unavailable prices into a known zero. */
-export function rollupRunUsage(...[rows, opts]: [rows: readonly RunUsageInput[], opts?: { by?: 'run' | 'role' }]): RunUsageRow[] {
+export function rollupRunUsage(...[rows, opts]: [rows: readonly RunUsageInput[], opts?: { by?: 'run' | 'role' | 'job' }]): RunUsageRow[] {
   const groups = new Map<string, RunUsageRow>();
   const byRole = opts?.by === 'role';
+  const byJob = opts?.by === 'job';
   for (const data of rows) {
-    const runId = byRole ? '(all)' : data.runId ?? '(none)';
+    const runId = byRole || byJob ? '(all)' : data.runId ?? '(none)';
     const role = data.role ?? '(none)';
     const site = data.site ?? '(none)';
+    const jobKind = data.jobKind ?? '(none)';
     const model = data.model ?? '(none)';
     const billingProvider = data.billingProvider ?? '(none)';
     const billing = data.billing ?? '(none)';
-    const key = JSON.stringify(byRole ? [role, site, model, billingProvider, billing] : [runId, model, billingProvider, billing]);
+    const key = JSON.stringify(byRole ? [role, site, model, billingProvider, billing] : byJob ? [jobKind] : [runId, model, billingProvider, billing]);
     let row = groups.get(key);
     if (!row) {
       row = {
-        runId, ...(byRole ? { role, site } : {}), model, billingProvider, billing, hostIds: [], calls: 0,
+        runId, ...(byRole ? { role, site } : {}), ...(byJob ? { jobKind } : { model, billingProvider, billing }), hostIds: [], calls: 0,
         inputTokens: 0, outputTokens: 0, cacheReadInputTokens: 0,
         cacheCreationInputTokens: 0, reasoningOutputTokens: 0,
         usdKnown: 0, unknownCostCalls: 0, includedCalls: 0, apiEquivalentUsd: 0,

package/src/budget/unified-usage.ts

@@ -458,6 +458,7 @@ function subscriptionFromCodexSnapshot(snap: UsageSnapshot): SubscriptionAxis {
  *  ⛔ 키가 없으면 행을 «안» 만든다(accounts=0 → 「없음」) — 키 없음은 «0달러»가 아니다.
  *  📏 응답 모양(실측 2026-09-23): `{data:{total_credits, total_usage}}` (USD). */
 export const OPENROUTER_CREDITS_ENDPOINT = 'https://openrouter.ai/api/v1/credits';
+export const OPENROUTER_KEY_ENDPOINT = 'https://openrouter.ai/api/v1/key';
 async function collectOpenRouterRows(deps: UnifiedUsageDeps): Promise<AccountUsageRow[]> {
   // ⛔ 시험 런타임은 seam 이 없으면 «키 없음»으로 본다 — 키 캐시는 «파일»이라 env 스크럽을 통과해
   //   기존 시험들이 실제 네트워크를 치게 된다(seam 을 모르는 옛 시험이 다수).
@@ -483,8 +484,27 @@ async function collectOpenRouterRows(deps: UnifiedUsageDeps): Promise<AccountUsa
     const used = typeof body.data?.total_usage === 'number' ? body.data.total_usage : null;
     if (total === null || used === null) return [{ ...base, credits: { status: 'error', detail: 'upstream-shape' } }];
     const balance = Math.round((total - used) * 100) / 100;
+    let note: string | undefined;
+    try {
+      const keyRes = await (deps.fetchOpenRouterImpl ?? fetch)(OPENROUTER_KEY_ENDPOINT, {
+        headers: { authorization: `Bearer ${key}` },
+        signal: AbortSignal.timeout(10_000),
+      });
+      if (keyRes.ok) {
+        const keyBody = (await keyRes.json()) as { data?: { limit?: unknown; limit_remaining?: unknown } };
+        const limit = keyBody.data?.limit;
+        const limitRemaining = keyBody.data?.limit_remaining;
+        if (typeof limit === 'number' && Number.isFinite(limit)
+          && typeof limitRemaining === 'number' && Number.isFinite(limitRemaining)) {
+          note = `키 한도 남은 금액 $${limitRemaining.toFixed(2)}`;
+        }
+      }
+    } catch {
+      // Key metadata is optional; preserve the successful credits row when unavailable.
+    }
     return [{
       ...base,
+      ...(note ? { note } : {}),
       credits: {
         status: 'ok',
         usedPercent: total > 0 ? Math.round((used / total) * 1000) / 10 : null,

package/src/budget/usage-outcomes.ts

@@ -70,6 +70,8 @@ export function providerLabel(entries: readonly RunLedgerEntry[]): string {
 }
 
 function blockReason(entry: RunLedgerEntry): string | undefined {
+  // Intermediate events (notably node-skipped(reason=condition)) are not stop reasons.
+  if (entry.event !== 'failed' && !(entry.event === 'run-status' && entry.data.runStatus === 'failed')) return undefined;
   return stringField(entry.data, 'stopReason')
     ?? stringField(entry.data, 'reason')
     ?? stringField(entry.data, 'verdict')
@@ -95,11 +97,13 @@ export function classifyLedgerRun(entries: readonly RunLedgerEntry[], nowMs: num
   ).size;
   const merged = [...entries].reverse().find((entry) => entry.event === 'merged' && entry.data.merged === true);
   const drafted = [...entries].reverse().find((entry) => entry.event === 'pr-opened' && entry.data.draft !== false);
-  const failed = [...entries].reverse().find((entry) => entry.event === 'failed' || entry.event === 'run-status' && (entry.data.runStatus === 'failed' || entry.data.runStatus === 'stopped'));
+  const failed = [...entries].reverse().find((entry) => entry.event === 'failed'
+    || entry.event === 'run-status' && entry.data.runStatus === 'failed');
   const outcome: OutcomeKind = merged ? 'landed' : drafted ? 'draft' : failed ? 'failed' : 'open';
-  const reason = outcome === 'failed' || outcome === 'open'
-    ? (failed ? blockReason(failed) : undefined)
-      ?? entries.map(blockReason).reverse().find((value) => value !== undefined)
+  // Only failure events may explain a stop. A trailing failed status marker can
+  // omit the reason supplied by an earlier failed event; intermediate skips cannot.
+  const reason = outcome === 'failed'
+    ? [...entries].reverse().map(blockReason).find((value) => value !== undefined) ?? 'unclassified'
     : undefined;
   return {
     provider: providerLabel(entries),