elanous 0.2.32 → 0.2.34

package/src/oauth/claude-pty-maturity.ts

@@ -1,3 +1,7 @@
+import { debug } from '../debug/log.js';
+import { classifyLedgerRun, queryUsageOutcomes, type UsageOutcomesDeps } from '../budget/usage-outcomes.js';
+import { loadRunLedger } from '../self-implement/run-ledger.js';
+
 export type ClaudePtyMaturity =
   | { readonly mature: true }
   | { readonly mature: false; readonly why: 'too-few-samples' | 'completion-below-70' | 'unknown-screen-above-10' | 'intervention-above-0.2' | 'sample-unreadable' };
@@ -9,6 +13,68 @@ export type ClaudePtyMaturitySample = {
   readonly interventionCount: number;
 };
 
+/** Read the latest Claude PTY runs from the run ledger without changing the ledger or fallback path. */
+export function collectClaudePtyMaturitySample(
+  deps: UsageOutcomesDeps & { readonly limit?: number },
+): ClaudePtyMaturitySample | null {
+  const limit = deps.limit ?? 10;
+  const nowMs = deps.nowMs ?? Date.now();
+  let runCount = 0;
+  let completedCount = 0;
+  let readable = Number.isSafeInteger(limit) && limit > 0;
+  let sample: ClaudePtyMaturitySample | null = null;
+
+  if (readable) {
+    const ledgers: { readonly runId: string; readonly entries: NonNullable<ReturnType<NonNullable<UsageOutcomesDeps['load']>>> }[] = [];
+    const load = deps.load ?? loadRunLedger;
+    try {
+      // The maturity sample is over the latest runs, not over a recent time window.
+      // Number.MAX_SAFE_INTEGER days covers the full JavaScript Date range.
+      const report = queryUsageOutcomes(Number.MAX_SAFE_INTEGER, {
+        ...deps,
+        load: (runId, dir, read) => {
+          const entries = load(runId, dir, read);
+          if (entries) ledgers.push({ runId, entries });
+          return entries;
+        },
+      });
+      const runs = ledgers.flatMap(({ runId, entries }) => {
+        const classified = classifyLedgerRun(entries, nowMs);
+        return classified?.provider === 'claude-pty' ? [{ runId, entries, classified }] : [];
+      }).sort((left, right) => right.classified.atMs - left.classified.atMs || right.runId.localeCompare(left.runId))
+        .slice(0, limit);
+      runCount = runs.length;
+      completedCount = runs.filter(({ classified }) => classified.outcome === 'landed').length;
+      readable = report.unreadableLedgers === 0 && runs.every(({ entries }) => {
+        const hasUnknownScreens = entries.some((entry) => Object.hasOwn(entry.data, 'claudePtyUnknownScreens'));
+        const hasInterventions = entries.some((entry) => Object.hasOwn(entry.data, 'humanInterventions'));
+        const unknownScreens = entries.find((entry) => Object.hasOwn(entry.data, 'claudePtyUnknownScreens'))?.data.claudePtyUnknownScreens;
+        const interventions = entries.find((entry) => Object.hasOwn(entry.data, 'humanInterventions'))?.data.humanInterventions;
+        return hasUnknownScreens && hasInterventions
+          && typeof unknownScreens === 'number' && Number.isSafeInteger(unknownScreens) && unknownScreens >= 0
+          && typeof interventions === 'number' && Number.isSafeInteger(interventions) && interventions >= 0;
+      });
+      if (readable) {
+        sample = runs.reduce<ClaudePtyMaturitySample>((total, { entries }) => {
+          const unknownScreens = entries.find((entry) => Object.hasOwn(entry.data, 'claudePtyUnknownScreens'))!.data.claudePtyUnknownScreens as number;
+          const interventions = entries.find((entry) => Object.hasOwn(entry.data, 'humanInterventions'))!.data.humanInterventions as number;
+          return {
+            runCount: total.runCount + 1,
+            completedCount: total.completedCount,
+            unknownScreenCount: total.unknownScreenCount + unknownScreens,
+            interventionCount: total.interventionCount + interventions,
+          };
+        }, { runCount: 0, completedCount, unknownScreenCount: 0, interventionCount: 0 });
+      }
+    } catch {
+      readable = false;
+    }
+  }
+
+  debug.log('oauth.claude-pty', 'maturity-sample', { runCount, completedCount, readable });
+  return readable ? sample : null;
+}
+
 /** 최근 런의 계수만 판정한다. 표본을 못 읽거나 계수가 불가능하면 성숙으로 추정하지 않는다. */
 export function judgeClaudePtyMaturity(sample: ClaudePtyMaturitySample | null | undefined): ClaudePtyMaturity {
   if (!sample || ![sample.runCount, sample.completedCount, sample.unknownScreenCount, sample.interventionCount]

package/src/oauth/codex-access-mirror.ts

@@ -0,0 +1,55 @@
+/** Codex access-only credential copies for hosts that must never own refresh authority. */
+
+export interface CodexAccessMirrorInput {
+  account: string;
+  store: { version?: number; providers: Record<string, Record<string, unknown>> };
+  codexAuth: { [key: string]: unknown; auth_mode?: string; tokens: Record<string, unknown> };
+}
+
+export interface CodexAccessMirror {
+  /** Minimal elanous auth store containing only this account's access token. */
+  elanousAuth: string;
+  /** Codex CLI auth document with refresh authority removed. */
+  codexAuth: string;
+  expiresAt: number;
+}
+
+/** Build the same refresh-less access-token copies used by Pod credentials. */
+export function createCodexAccessMirror(input: CodexAccessMirrorInput): CodexAccessMirror {
+  const storeKey = input.account === 'default' ? 'openai-codex' : `openai-codex:${input.account}`;
+  const entry = input.store.providers[storeKey] as {
+    tokens?: Record<string, unknown>; lastRefresh?: string; authMode?: string;
+  } | undefined;
+  if (!entry?.tokens) throw new Error(`${storeKey} 계정이 없다`);
+
+  const accessToken = input.codexAuth.tokens.access_token;
+  if (typeof accessToken !== 'string' || !accessToken) throw new Error(`${storeKey} access token 이 없다`);
+  // The Codex auth document is the authority for its own auth_mode. Store metadata
+  // remains available in elanousAuth, but must not be synthesized into auth.json.
+  const authMode = input.codexAuth.auth_mode;
+  if (authMode !== undefined && (typeof authMode !== 'string' || !authMode.trim())) throw new Error(`${storeKey} Codex CLI auth_mode 가 비어 있다`);
+  let payload: { exp?: unknown };
+  try {
+    payload = JSON.parse(Buffer.from(accessToken.split('.')[1] ?? '', 'base64url').toString('utf8')) as { exp?: unknown };
+  } catch { throw new Error(`${storeKey} access token 만료를 읽을 수 없다`); }
+  const expiresAt = Number(payload.exp) * 1000;
+  if (!Number.isFinite(expiresAt) || expiresAt <= 0) throw new Error(`${storeKey} access token 만료를 읽을 수 없다`);
+
+  const elanousAuth = JSON.stringify({
+    version: input.store.version ?? 1,
+    providers: {
+      'openai-codex': {
+        tokens: { ...entry.tokens, accessToken, expiresAt, refreshToken: '', refresh_token: '' },
+        lastRefresh: entry.lastRefresh,
+        authMode: entry.authMode,
+        chatGPT: { accountId: input.codexAuth.tokens.account_id },
+      },
+    },
+  });
+  const codexAuth = JSON.stringify({
+    ...input.codexAuth,
+    auth_mode: authMode,
+    tokens: { ...input.codexAuth.tokens, refresh_token: '', refreshToken: '' },
+  });
+  return { elanousAuth, codexAuth, expiresAt };
+}

package/src/oauth/fallback-chain.ts

@@ -28,7 +28,7 @@ import type { ClaudePtyMaturity } from './claude-pty-maturity.js';
  *    그 grok 마저 못 쓰면 갈 곳이 없었다 — 이 칸을 grok «뒤»에 두면 그때만 크레딧으로 돌아온다.
  *    ⛔ 첫 칸의 크레딧 금지(`codexQuotaPolicy`)는 그대로다 — 이 칸은 «체인이 여기까지 왔을 때»만 돈을 쓴다.
  *    ⛔ 기본 체인에는 «없다» — 돈이라 사람이 config 에 «명시»할 때만 켜진다. */
-export const FALLBACK_STEPS = ['codex-rotate', 'grok', 'claude-pty', 'openrouter', 'codex-credits'] as const;
+export const FALLBACK_STEPS = ['codex-rotate', 'grok', 'zai', 'claude-pty', 'openrouter', 'codex-credits'] as const;
 export type FallbackStep = (typeof FALLBACK_STEPS)[number];
 
 /** 기본 체인 — ⛔⭐ **2026-08-20 에 `grok` 이 «기본»으로 들어왔다**(대표 지시).

package/src/onboarding/first-run.ts

@@ -33,12 +33,14 @@ export type MenuAnswer =
   | { kind: 'miss' };
 
 // FIRST10-FIX: 첫 화면의 오타 한 번이 first-run 전체를 취소하던 마찰 — 빈 입력(취소 의사)과 달리
-// 선택지를 가리키지 못하는 입력(오타·범위 밖·전각 숫자)은 취소가 아니라 다시 묻는다.
+// 선택지를 가리키지 못하는 입력(범위 밖·전각·비정수)은 취소가 아니라 다시 묻는다.
+// 메뉴 답으로 인정하는 건 반각 십진 자릿수 문자열뿐이다 — Number() 는 '1e0'·'0x1'·'+1' 같은
+// 수식 표기를 정수로 강제 변환해 선택지로 샌다(0.2.35 재측정).
 export function parseMenuAnswer(answer: string, choices: readonly LLMProviderName[]): MenuAnswer {
   const trimmed = answer.trim();
   if (trimmed === '') return { kind: 'cancel' };
-  const index = Number(trimmed) - 1;
-  const provider = Number.isInteger(index) && index >= 0 ? choices[index] : undefined;
+  if (!/^[0-9]+$/.test(trimmed)) return { kind: 'miss' };
+  const provider = choices[Number(trimmed) - 1];
   return provider !== undefined ? { kind: 'chosen', provider } : { kind: 'miss' };
 }
 

package/src/onboarding/non-interactive.ts

@@ -10,6 +10,7 @@
 
 import type { WizardIO } from '../onboarding.js';
 import type { ChoiceOption, ChooseOpts, StepSpec } from './io-extended.js';
+import type { LlmDetectDeps } from '../cli/llm-detect-cli.js';
 import {
   loadAnswerFile,
   buildEnvOverrides,
@@ -25,6 +26,10 @@ export interface NonInteractiveOptions {
   answers?: AnswerFile;
   /** Inject a custom `process.env` for the env-bridge layer. */
   env?: NodeJS.ProcessEnv;
+  /** Existing configured provider; an explicit choice suppresses auto-probing. */
+  initialProvider?: string;
+  /** Inject `llm detect` dependencies in tests while retaining its real probe selection logic. */
+  llmDetectDeps?: LlmDetectDeps;
 }
 
 interface ResolvedAnswers {
@@ -76,6 +81,28 @@ export function nonInteractiveIO(opts: NonInteractiveOptions = {}): WizardIO {
   let section: AnswerSection | undefined;
   let printedCodexSkipGuidance = false;
   const consumed = new Set<string>();
+  let detectedProvider: string | null | undefined;
+  let providerDetection: Promise<string | null> | undefined;
+
+  const detectProvider = async (): Promise<string | null> => {
+    if (detectedProvider !== undefined) return detectedProvider;
+    providerDetection ??= (async () => {
+      const [{ runLlmDetect }, { detectProviders }] = await Promise.all([
+        import('../cli/llm-detect-cli.js'),
+        import('../llm/provider-detect.js'),
+      ]);
+      const env = opts.env ?? process.env;
+      const result = await runLlmDetect({ probe: true }, {
+        ...opts.llmDetectDeps,
+        detect: opts.llmDetectDeps?.detect ?? (() => detectProviders({ env })),
+        output: () => {},
+      });
+      return result.selected;
+    })();
+    try { detectedProvider = await providerDetection; }
+    catch { detectedProvider = null; }
+    return detectedProvider;
+  };
 
   const peek = (key: string): unknown => {
     if (!section) return undefined;
@@ -112,18 +139,33 @@ export function nonInteractiveIO(opts: NonInteractiveOptions = {}): WizardIO {
       chooseOpts: ChooseOpts = {},
       stepId?: string,
       pickerId?: string,
-    ) => resolveChoice(
-      choices,
-      chooseOpts,
-      stepId,
-      pickerId,
-      section,
-      merged,
-      () => printedCodexSkipGuidance,
-      () => { printedCodexSkipGuidance = true; },
-      (trackedSection, field) => { consumed.add(`${trackedSection}.${field}`); },
-      print,
-    ),
+    ) => {
+      const answerSection = sectionForPicker(stepId, pickerId, section);
+      const field = answerSection === 'llm' ? 'provider' : undefined;
+      const configured = answerSection && field ? merged[answerSection]?.[field] : undefined;
+      const savedProvider = answerSection === 'llm' && configured === undefined
+        && opts.initialProvider !== undefined && opts.initialProvider !== 'auto'
+        ? opts.initialProvider
+        : undefined;
+      const provider = pickerId === 'provider' && answerSection === 'llm' && configured === undefined
+        && (opts.initialProvider === undefined || opts.initialProvider === 'auto')
+        ? await detectProvider()
+        : null;
+      return resolveChoice(
+        choices,
+        chooseOpts,
+        stepId,
+        pickerId,
+        section,
+        merged,
+        () => printedCodexSkipGuidance,
+        () => { printedCodexSkipGuidance = true; },
+        (trackedSection, answerField) => { consumed.add(`${trackedSection}.${answerField}`); },
+        print,
+        provider,
+        savedProvider,
+      );
+    },
     showStep: (spec: StepSpec) => {
       section = STEP_SECTIONS[spec.index];
     },
@@ -145,6 +187,8 @@ function resolveChoice<T>(
   markCodexSkipGuidancePrinted: () => void,
   markConsumed: (section: AnswerSection, field: string) => void,
   print: (text: string) => void,
+  detectedProvider: string | null = null,
+  savedProvider?: string,
 ): T {
   if (choices.length === 0) throw new Error('nonInteractiveIO.choose: options array must not be empty.');
 
@@ -173,7 +217,14 @@ function resolveChoice<T>(
     : choices.find((choice) => choiceValueKey(choice.value) === configured);
   if (answerSection && field && selected) markConsumed(answerSection, field);
 
-  return selected?.value ?? choiceForValue(choices, configured, opts);
+  const detected = answerSection === 'llm' && field === 'provider' && configured === undefined && detectedProvider
+    ? choices.find((choice) => choiceValueKey(choice.value) === detectedProvider)
+    : undefined;
+  const saved = answerSection === 'llm' && field === 'provider' && configured === undefined && savedProvider
+    ? choices.find((choice) => choiceValueKey(choice.value) === savedProvider)
+    : undefined;
+
+  return selected?.value ?? detected?.value ?? saved?.value ?? choiceForValue(choices, configured, opts);
 }
 
 function choiceForValue<T>(

package/src/onboarding.ts

@@ -38,7 +38,7 @@ import {
 } from './user-config.js';
 import {
   GROK_MODEL, OPENAI_MODEL, ANTHROPIC_MODEL, LOCAL_LLM_MODEL, GEMINI_MODEL,
-  KIMI_MODEL, QWEN_MODEL, GLM_MODEL,
+  KIMI_MODEL, QWEN_MODEL, GLM_MODEL, OPENROUTER_MODEL,
 } from './config.js';
 import { CODEX_DEFAULT_MODEL } from './llm.js';
 import { suggestSetupModel } from './model-tier/index.js';
@@ -514,7 +514,10 @@ const PROVIDER_CHOICES: ProviderChoice[] = [
     defaultBaseUrl: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1' },
   { key: 'glm',          label: 'GLM (Zhipu · Z.ai · GLM-5.1 754B MoE)', defaultModel: GLM_MODEL, needsBaseUrl: true, needsApiKey: true,
     defaultBaseUrl: 'https://open.bigmodel.cn/api/paas/v4' },
+  // Keep `auto` at its established numeric position; scripted onboarding
+  // answers and existing users rely on the stable numbered choices.
   { key: 'auto',         label: 'Auto-detect (pick from env at runtime)', needsBaseUrl: false, needsApiKey: false },
+  { key: 'openrouter',   label: 'OpenRouter', defaultModel: OPENROUTER_MODEL, needsBaseUrl: false, needsApiKey: true },
 ];
 
 /** PLAN-model-intelligence-router · Phase B4 — decide whether the model
@@ -1753,15 +1756,20 @@ export async function runOnboardingNonInteractive(
     answerFilePath?: string;
     /** Override the resolved env when reading env-bridge layer. */
     env?: NodeJS.ProcessEnv;
+    /** Test seam for `llm detect` dependencies while retaining its probe selection logic. */
+    llmDetectDeps?: import('./cli/llm-detect-cli.js').LlmDetectDeps;
   } = {},
 ): Promise<UserConfig> {
   // Lazy import — keeps `expression/config/` out of the cold path.
   const { nonInteractiveIO } = await import('./onboarding/non-interactive.js');
+  const initial = opts.initial ?? buildUserConfig(opts.path ?? userConfigPath());
   const io = nonInteractiveIO({
     answerFilePath: opts.answerFilePath,
     env: opts.env,
+    initialProvider: initial.llm?.provider,
+    llmDetectDeps: opts.llmDetectDeps,
   });
-  const config = await runOnboarding({ ...opts, io, deferComplete: true });
+  const config = await runOnboarding({ ...opts, initial, io, deferComplete: true });
   io.complete?.();
   return config;
 }

package/src/ops/overview-collect.ts

@@ -15,6 +15,7 @@ import { measureLandingThroughput, type LandingThroughput } from '../task-agent/
 import {
   okCell, unmeasured, type Cell, type CapacityInfo, type ChecklistCounts, type LaunchableInfo, type LoopRow, type MachineRow,
   type OverviewSnapshot, type OwnerTaskRow, type ParentsInfo, type PodMemberRow, type ReleaseRunInfo, type ScheduleInfo,
+  type SchedulerMetrics,
 } from './overview.js';
 import { SEAT_ERA_SOURCE, readDispatcherBeats, readDispatcherCapacity, readSeatEraHanded, seatEraFeederDir } from './overview-seat-era.js';
 import { matchesOverviewOwner, normalizeOverviewOwner } from './overview-owner.js';
@@ -204,8 +205,11 @@ function collectMachines(root: string, ledgerRows: ResourceView[] | Error, poolS
   return { hosts, pods, parents };
 }
 
+export interface SchedulerExecutionObservation { ts_ms: number; data: string | null }
+
 export interface CollectDeps {
   listSchedules?: () => ReleaseSchedule[];
+  readSchedulerRuns?: (sinceMs: number, untilMs: number) => SchedulerExecutionObservation[] | Promise<SchedulerExecutionObservation[]>;
   listChecklist?: (v: string) => Checklist;
   readRuns?: (dir: string) => ReturnType<Parameters<typeof collectRelease>[4]>;
   readCards?: () => TaskCard[];
@@ -222,6 +226,14 @@ async function defaultDeps(root: string): Promise<Required<CollectDeps>> {
   ]);
   return {
     listSchedules: () => listSchedules(),
+    readSchedulerRuns: async (sinceMs, untilMs) => {
+      const { LogStore, logsDbPath } = await import('../mss/logging/log-store.js');
+      const store = LogStore.openReadOnly(logsDbPath());
+      try {
+        return store.queryAll({ exactCategories: ['schedule.run'], sinceMs, untilMs })
+          .map(({ ts_ms, data }) => ({ ts_ms, data }));
+      } finally { store.close(); }
+    },
     listChecklist: (v) => listChecklist(v),
     readRuns: (dir) => readReleaseRuns(null, dir),
     readCards: () => {
@@ -351,7 +363,30 @@ export async function collectOverview(opts: CollectOptions, injected: CollectDep
       beat: okCell({ lastAt: b.lastAt, ageSeconds: b.ageSeconds, alive: b.alive }, `${SEAT_ERA_SOURCE} dispatcher-${b.seat}.pid`, b.lastAt) });
   }
 
-  return { generatedAt: iso(now), instanceRoot: root, since: opts.sinceLabel, release, tasks, machines, landings, throughput, loops };
+  let schedulerMetrics: OverviewSnapshot['schedulerMetrics'];
+  try {
+    const runs = await deps.readSchedulerRuns(now - 86_400_000, now);
+    const isCrontabRecord = (row: SchedulerExecutionObservation): boolean => {
+      try {
+        const data = row.data ? JSON.parse(row.data) as { via?: unknown } : null;
+        return data?.via === 'crontab';
+      } catch { return false; }
+    };
+    const lastHourRuns = runs.filter((row) => row.ts_ms >= now - 3_600_000);
+    const crontabRuns = lastHourRuns.filter(isCrontabRecord).length;
+    const crontabRunsLast24h = runs.filter(isCrontabRecord).length;
+    const metrics: SchedulerMetrics = {
+      scheduleRuns: lastHourRuns.length,
+      bunLaunches: crontabRuns,
+      bunLaunchesLast24h: crontabRunsLast24h,
+    };
+    const source = 'logs.db(schedule.run · via=crontab 기록 건수 · 전체 Bun 기동 아님)';
+    schedulerMetrics = okCell(metrics, source, iso(now));
+  } catch (error) {
+    schedulerMetrics = unmeasured<SchedulerMetrics>('logs.db(schedule.run)', errText(error));
+  }
+
+  return { generatedAt: iso(now), instanceRoot: root, since: opts.sinceLabel, release, tasks, machines, landings, throughput, schedulerMetrics, loops };
 }
 
 export function parseSince(raw: string | undefined): { ms: number; label: string } {

package/src/ops/overview.ts

@@ -55,6 +55,11 @@ export interface MachineLoad { load1: number; load5: number; load15: number; cpu
 export interface MachineRow { name: string; load: Cell<MachineLoad> }
 export interface PodMemberRow { context: string; capacity: number; occupied: Cell<number> }
 export interface ParentsInfo { count: number; staleOver6h: number; oldestHours: number | null }
+export interface SchedulerMetrics {
+  scheduleRuns: number | null;
+  bunLaunches: number | null;
+  bunLaunchesLast24h: number | null;
+}
 export interface LoopRow {
   name: string;
   /** product = 제품 원장 · seat-era = 자리 시대 원천(제품 밖 · 임시) */
@@ -88,6 +93,8 @@ export interface OverviewSnapshot {
   landings: Cell<{ count: number; recent: string[] }>;
   /** Optional until launch/PR/age sources are wired; existing snapshots keep their exact output. */
   throughput?: Cell<LandingThroughput>;
+  /** Scheduler-wrapper observations for the trailing hour and day; absent on legacy snapshots. */
+  schedulerMetrics?: Cell<SchedulerMetrics>;
   loops: LoopRow[];
 }
 
@@ -238,6 +245,7 @@ export function unmeasuredCells(s: OverviewSnapshot): string[] {
   for (const p of s.machines.pods) visit(`pods.${p.context}`, p.occupied);
   visit('machines.parents', s.machines.parents); visit('landings', s.landings);
   if (s.throughput) visit('throughput', s.throughput);
+  if (s.schedulerMetrics) visit('schedulerMetrics', s.schedulerMetrics);
   for (const l of s.loops) visit(`loops.${l.name}`, l.beat);
   return out;
 }
@@ -277,6 +285,9 @@ export function renderOverview(s: OverviewSnapshot, v: VerdictResult, meta: { el
   lines.push(`       Pod ${s.machines.pods.map((p) => `${p.context} ${show(p.occupied, String)}/${p.capacity}`).join(' · ') || '못 잼(풀 설정 없음)'}`);
   lines.push(`       하니스 부모(이 기계) ${show(s.machines.parents, (p) => `${p.count} · 6h 넘음 ${p.staleOver6h}${p.oldestHours !== null ? ` · 최고 ${p.oldestHours}h` : ''}`)}`);
   lines.push(`착지   ${s.since} ${show(s.landings, (l) => `${l.count}`)} [${s.landings.source}]`);
+  if (s.schedulerMetrics) {
+    lines.push(`스케줄 로그 기록(최근 1시간) ${show(s.schedulerMetrics, (m) => `schedule.run ${m.scheduleRuns === null ? '못 잼' : `${m.scheduleRuns}건`} · crontab 경유 기록 ${m.bunLaunches === null ? '못 잼' : `${m.bunLaunches}건`} · 최근 24h crontab 경유 기록 ${m.bunLaunchesLast24h === null ? '못 잼' : `${m.bunLaunchesLast24h}건`}`)} [${s.schedulerMetrics.source}]`);
+  }
   if (s.throughput) {
     lines.push(`${show(s.throughput, formatLandingThroughput)} [${s.throughput.source}]`);
   }

package/src/pr-tool/census.ts

@@ -11,6 +11,7 @@ export type PrToolCommand = (command: string, args: readonly string[], opts?: {
 export type Seat = 'OP' | 'TC' | 'MK' | 'UX';
 export interface OpenPr {
   number: number;
+  headRefName?: string;
   title: string;
   draft: boolean;
   updatedAt: string;
@@ -20,6 +21,8 @@ export interface OpenPr {
   seat: Seat | null;
   lastCommitAt?: string;
   cellId: string | null;
+  cardId?: string | null;
+  cardMarkerPresent?: boolean;
   hunks?: readonly DiffHunk[];
 }
 export type Inventory = { status: 'checked'; prs: readonly OpenPr[] } | { status: 'unknown'; reason: string };
@@ -31,7 +34,8 @@ export type GuardCode = 'inventory-unknown' | 'candidate-unknown' | 'goal-only'
 export interface GuardReason { code: GuardCode; detail: string; prs?: readonly number[]; files?: readonly string[] }
 /** PR-GUARD-HUNK-WARN (대표 10-17): 줄 겹침은 기본 경고 — 착지 쪽 스마트 머지가 푼다. 'refuse' = 옛 거부 동작. */
 export type HunkOverlapMode = 'refuse' | 'warn';
-export interface GuardVerdict { status: 'allow' | 'refuse' | 'unknown'; reasons: readonly GuardReason[]; warnings: readonly GuardReason[] }
+export interface GuardVerdict { status: 'allow' | 'refuse' | 'unknown'; reasons: readonly GuardReason[]; warnings: readonly GuardReason[];
+  sameCellReuse?: { number: number; branch: string; headSha: string; cellId: string; cardId: string; legacyBound?: true } }
 
 const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
 const DEFAULT_SEAT_CAP = 30;
@@ -49,6 +53,13 @@ function seatFromLabels(labels: readonly string[]): Seat | null {
 export function cellIdFromBody(body: string): string | null {
   return /^\s*(?:[-*]\s*)?칸\s*:\s*([A-Z][A-Z0-9-]{2,})\s*$/m.exec(body)?.[1] ?? null;
 }
+export function cardIdFromBody(body: string): string | null {
+  const ids = [...body.matchAll(/^\s*(?:[-*]\s*)?카드\s*:\s*([^\r\n]*)$/gm)].map(match => match[1]!.trim());
+  return ids.length > 0 && ids.every(id => /^[A-Za-z0-9][A-Za-z0-9._:-]{2,}$/.test(id) && id === ids[0]) ? ids[0]! : null;
+}
+export function hasCardMarker(body: string): boolean {
+  return /^\s*(?:[-*]\s*)?카드\s*:/m.test(body);
+}
 
 export function parseDiffHunks(patch: string): DiffHunk[] {
   const hunks: DiffHunk[] = [];
@@ -156,10 +167,10 @@ export function readOpenPrs(run: PrToolCommand, options: {
       const body = typeof row.body === 'string' ? row.body : '';
       const seat = seatValue(options.seatOfPr?.({ number: number as number, headRefName, body, labels: labelNames })) ?? seatFromLabels(labelNames);
       const pr: OpenPr = {
-        number: number as number, title: text(row.title, `PR #${number} title`), draft: row.draft,
+        number: number as number, headRefName, title: text(row.title, `PR #${number} title`), draft: row.draft,
         updatedAt: date(row.updated_at, `PR #${number} updated_at`), headSha, labels: labelNames,
         files: projected.get(number as number) ?? pathsForPr(run, number as number, options.cwd), seat,
-        cellId: cellIdFromBody(body),
+        cellId: cellIdFromBody(body), cardId: cardIdFromBody(body), cardMarkerPresent: hasCardMarker(body),
       };
       if (options.candidateFiles?.some(file => pr.files.includes(file))) {
         const patch = run('gh', ['pr', 'diff', String(number), '--patch'], options.cwd ? { cwd: options.cwd } : undefined);
@@ -211,7 +222,7 @@ export function censusOpenPrs(inventory: Inventory, now = Date.now()): Census {
   return result;
 }
 
-export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat | null; seatCap?: number; cellId?: string | null; hunks?: readonly DiffHunk[]; hunkOverlap?: HunkOverlapMode }, inventory: Inventory): GuardVerdict {
+export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat | null; seatCap?: number; cellId?: string | null; cardId?: string | null; boundPrNumber?: number; hunks?: readonly DiffHunk[]; hunkOverlap?: HunkOverlapMode }, inventory: Inventory): GuardVerdict {
   if (!input.files || input.files.length === 0 || input.files.some(file => !file || file.startsWith('/') || file.includes('..'))) {
     const reasons: GuardReason[] = [{ code: 'candidate-unknown', detail: '새 PR 변경 파일을 확인할 수 없음' }];
     debug.log('pr.tool', 'guard-refuse', { status: 'unknown', reasons });
@@ -260,7 +271,14 @@ export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat
   const status = reasons.some(reason => reason.code === 'candidate-unknown') ? 'unknown' : reasons.length ? 'refuse' : 'allow';
   if (status !== 'allow') debug.log('pr.tool', 'guard-refuse', { status, reasons, warnings });
   else if (warnings.length) debug.log('pr.tool', 'guard-warn', { warnings });
-  return { status, reasons, warnings };
+  const legacyBound = sameCell.length === 1 && sameCell[0]?.cardMarkerPresent === false
+    && input.boundPrNumber === sameCell[0].number;
+  const reusable = status === 'refuse' && reasons.length === 1 && reasons[0]?.code === 'same-cell'
+    && input.cardId && sameCell.length === 1 && (sameCell[0]?.cardId === input.cardId || legacyBound)
+    && sameCell[0].headRefName && /^[0-9a-f]{40}$/i.test(sameCell[0].headSha)
+    ? { number: sameCell[0].number, branch: sameCell[0].headRefName, headSha: sameCell[0].headSha,
+      cellId: input.cellId!, cardId: input.cardId, ...(legacyBound ? { legacyBound: true as const } : {}) } : undefined;
+  return { status, reasons, warnings, ...(reusable ? { sameCellReuse: reusable } : {}) };
 }
 
 /** Persist the unknown-read budget across harness processes sharing one instance state root. */