elanous 0.2.31 → 0.2.34

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[];
 }
 
@@ -96,6 +103,62 @@ export interface VerdictResult { verdict: Verdict; reasons: string[]; nextAction
 /** 부하/코어가 이 값을 넘으면 «기계 압박»(흐름 저하의 사유). 디스크 I/O 신호는 OVW-MACHINE-HB 전까지 없다. */
 export const LOAD_PER_CORE_PRESSURE = 3;
 
+/** 자원 지도의 축 어휘(닫힌 집합 · RES-FLOOR-BINDING). I/O·게이트 예약은 이 칸에 원천이 없어 늘 제외다. */
+export type ResourceKind = 'memory' | 'cpu' | 'io' | 'slots' | 'gate';
+
+/** 구속 조건 — 남은 비율이 최소인 축. 남은 비율 = 남은 양/전체 양(CPU 는 압박선 LOAD_PER_CORE_PRESSURE×코어를 전체로 본다). */
+export interface ResourceBinding {
+  kind: ResourceKind;
+  label: string;
+  remainingRatio: number;
+  /** 남은 양/전체 양의 사람 표기 — `5/64GB` · `0/54코어(압박선 3/코어)` · `0/46자리`. */
+  remainingText: string;
+}
+
+function ratio01(n: number): number {
+  return Math.min(1, Math.max(0, n));
+}
+
+function remainingAmount(n: number): string {
+  return Number.isInteger(n) ? n.toFixed(0) : String(Number(n.toPrecision(3)));
+}
+
+/**
+ * 구속 조건 규칙(RES-FLOOR-BINDING) — 메모리·CPU·I/O·슬롯·게이트 예약 중 «남은 비율 최소»인 축이 흐름을 묶는다.
+ * 못 잰 축(하트비트 없는 호스트 · 용량 못 잼 · 원천 없는 I/O·게이트 예약)은 후보에서 뺀다 — «넉넉»으로도 «바닥»으로도 읽지 않는다.
+ * 측정 축이 하나도 없으면 null. 동율은 정해진 순서(호스트 순 메모리→CPU, 그 다음 슬롯)의 첫 축이 이긴다.
+ */
+export function bindingResource(s: OverviewSnapshot): ResourceBinding | null {
+  const candidates: ResourceBinding[] = [];
+  for (const host of s.machines.hosts) {
+    const l = host.load.value;
+    if (!l) continue;
+    if (l.totalGb > 0) {
+      const remaining = Math.max(0, l.freeGb);
+      candidates.push({ kind: 'memory', label: `${host.name} 메모리`, remainingRatio: ratio01(remaining / l.totalGb), remainingText: `${remainingAmount(remaining)}/${l.totalGb.toFixed(0)}GB` });
+    }
+    if (l.cpuCount > 0) {
+      const cpuCap = l.cpuCount * LOAD_PER_CORE_PRESSURE;
+      const remaining = Math.max(0, cpuCap - l.load5);
+      candidates.push({ kind: 'cpu', label: `${host.name} CPU`, remainingRatio: ratio01(remaining / cpuCap), remainingText: `${remainingAmount(remaining)}/${cpuCap.toFixed(0)}코어(압박선 ${LOAD_PER_CORE_PRESSURE}/코어)` });
+    }
+  }
+  const capacity = s.tasks.capacity.value;
+  if (capacity && capacity.podTarget + capacity.localMax > 0) {
+    const total = capacity.podTarget + capacity.localMax;
+    candidates.push({ kind: 'slots', label: '슬롯', remainingRatio: ratio01(capacity.free / total), remainingText: `${capacity.free}/${total}자리` });
+  }
+  let binding: ResourceBinding | null = null;
+  for (const c of candidates) if (binding === null || c.remainingRatio < binding.remainingRatio) binding = c;
+  return binding;
+}
+
+/** 판정 띠 문구 — 측정된 축 중 «무엇이 흐름을 묶고 있나»를 이름으로 단다. 측정 축이 없으면 null. */
+export function bindingPhrase(b: ResourceBinding | null): string | null {
+  if (!b) return null;
+  return `구속 자원 ${b.label} — 남은 비율 최소 ${Math.round(b.remainingRatio * 100)}% (${b.remainingText})`;
+}
+
 export function computeVerdict(s: OverviewSnapshot): VerdictResult {
   const hits = new Map<Verdict, { reasons: string[]; actions: string[] }>();
   const hit = (v: Verdict, reason: string, action?: string): void => {
@@ -155,14 +218,15 @@ export function computeVerdict(s: OverviewSnapshot): VerdictResult {
     }
   }
 
+  const phrase = bindingPhrase(bindingResource(s));
   for (const v of VERDICTS) {
     const row = hits.get(v);
     if (!row) continue;
     // 이유 사슬: 이긴 판정의 사유 먼저, 그 밑에 진 판정들의 사유도 «부가»로 남긴다(한 사슬에 두 원인이 보이게).
     const rest = VERDICTS.filter((o) => o !== v && hits.has(o)).flatMap((o) => hits.get(o)!.reasons.map((r) => `(+${VERDICT_LABEL[o]}) ${r}`));
-    return { verdict: v, reasons: [...row.reasons, ...rest], nextActions: row.actions };
+    return { verdict: v, reasons: [...row.reasons, ...(phrase ? [phrase] : []), ...rest], nextActions: row.actions };
   }
-  return { verdict: 'flowing', reasons: [], nextActions: [] };
+  return { verdict: 'flowing', reasons: phrase ? [phrase] : [], nextActions: [] };
 }
 
 /** exit code — flowing·degraded 0 · 그 밖의 판정 3(수집기 자체 실패 1 은 호출자 몫). */
@@ -181,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;
 }
@@ -220,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 };
@@ -28,8 +31,11 @@ export type Census = { status: 'checked'; total: number; rows: readonly CensusRo
   | { status: 'unknown'; reason: string };
 export interface DiffHunk { path: string; start: number; end: number }
 export type GuardCode = 'inventory-unknown' | 'candidate-unknown' | 'goal-only' | 'file-overlap' | 'hunk-overlap' | 'same-cell' | 'seat-cap' | 'seat-unattributed';
-export interface GuardReason { code: GuardCode; detail: string; prs?: readonly number[] }
-export interface GuardVerdict { status: 'allow' | 'refuse' | 'unknown'; reasons: readonly GuardReason[]; warnings: readonly GuardReason[] }
+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[];
+  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;
@@ -47,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[] = [];
@@ -154,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);
@@ -209,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[] }, 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 });
@@ -226,8 +239,21 @@ export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat
   const sameCell = input.cellId ? inventory.prs.filter(pr => pr.cellId === input.cellId) : [];
   if (sameCell.length) reasons.push({ code: 'same-cell', detail: `같은 칸 ${input.cellId} OPEN PR이 있음`, prs: sameCell.map(pr => pr.number) });
   const overlaps = inventory.prs.filter(pr => pr.files.some(file => candidate.has(file)));
-  const sameHunk = overlaps.filter(pr => pr.hunks?.some(other => input.hunks?.some(own => own.path === other.path && own.start <= other.end && other.start <= own.end)));
-  if (sameHunk.length) reasons.push({ code: 'hunk-overlap', detail: '같은 파일의 수정 줄 범위가 겹침', prs: sameHunk.map(pr => pr.number) });
+  const hunkFiles = new Set<string>();
+  const sameHunk = overlaps.filter(pr => {
+    const paths = (pr.hunks ?? []).filter(other => input.hunks?.some(own => own.path === other.path && own.start <= other.end && other.start <= own.end)).map(other => other.path);
+    for (const path of paths) hunkFiles.add(path);
+    return paths.length > 0;
+  });
+  if (sameHunk.length) {
+    const refuseHunk = input.hunkOverlap === 'refuse';
+    (refuseHunk ? reasons : warnings).push({
+      code: 'hunk-overlap',
+      detail: refuseHunk ? '같은 파일의 수정 줄 범위가 겹침' : '같은 파일의 수정 줄 범위가 겹침 · 착지 때 머지로 푼다',
+      prs: sameHunk.map(pr => pr.number),
+      files: [...hunkFiles],
+    });
+  }
   if (overlaps.length) warnings.push({ code: 'file-overlap', detail: '같은 파일의 OPEN PR이 있음 · 줄 겹침은 별도 판정', prs: overlaps.map(pr => pr.number) });
   const seat = seatValue(input.seat);
   if (input.seat !== undefined && input.seat !== null && !seat) reasons.push({ code: 'candidate-unknown', detail: '호출자 자리 값 오류' });
@@ -245,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. */