elanous 0.2.25 → 0.2.28

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

@@ -75,6 +75,66 @@ export function _setCreateGoalAuthorDecomposeStepsForTesting(fn?: CreateGoalAuth
 /** 진행 종료 스테이지(phase='end') — 그 외는 delta(start 제외). */
 const END_STAGES: readonly SelfImplementProgressStage[] = ['pr-opened', 'aborted', 'gate-failed', 'pr-declined'];
 
+// ⭐ 결과 네 꼴(HARNESS-RESULT-CONTRACT · RFC-tui-tool-surface-on-graph-harness §4 · 0.2.26) —
+//   종전 `{observed:true}` 한 비트는 모델이 «안 됐다 → 직접 편집»으로 읽었다(UX S1-02 · 47 도구).
+//   ⇒ launched / pending / observed-only / failed 네 꼴로 구조화해 «다음 행동»을 문면으로 고정한다.
+//   ⚠️ launched 꼴은 SelfImplementResult 필드를 **그대로 보존**한다 — runId 조인·원장 소비자 무손상.
+export type SelfImplementLaunchedToolResult = SelfImplementResult & { runId: string; kind: 'launched'; message: string; next: string; missing: string[] };
+export type SelfImplementPendingToolResult = Partial<SelfImplementResult> & { kind: 'pending'; message: string; next: string; missing: string[] };
+export type SelfImplementObservedOnlyToolResult = { kind: 'observed-only'; observed: true; message: string; next: string; missing: ['runId', 'node'] };
+export type SelfImplementFailedToolResult = Partial<SelfImplementResult> & { kind: 'failed'; reason: string; message: string; next: string; missing: string[] };
+export type SelfImplementToolResult = SelfImplementLaunchedToolResult | SelfImplementPendingToolResult | SelfImplementObservedOnlyToolResult | SelfImplementFailedToolResult;
+
+/** 하니스가 런을 맡았다 — 파일 편집은 하니스 몫이므로 모델의 직접 Write/Edit 을 문면으로 막는다. */
+export function buildLaunchedToolResult(result: SelfImplementResult): SelfImplementLaunchedToolResult | SelfImplementPendingToolResult {
+  if (!result.runId) return buildPendingToolResult(result);
+  const runId = result.runId;
+  const node = result.node || null;
+  const missing = node ? [] : ['node'];
+  const query = `eln self run ${runId}`;
+  return {
+    ...result,
+    runId,
+    kind: 'launched',
+    next: query,
+    missing,
+    message: `하니스가 맡았습니다 · 런 ${runId} · 노드 ${node ?? '미관측'} · 다음 조회: ${query} · 이 턴에서 파일을 직접 편집하지 마세요`,
+  };
+}
+
+/** 완료 또는 접수는 관측했지만 실제 런 ID가 없어 발사를 단언할 수 없다. */
+export function buildPendingToolResult(result: SelfImplementResult): SelfImplementPendingToolResult {
+  const { runId: _unconfirmedRunId, ...observed } = result;
+  return {
+    ...observed,
+    kind: 'pending',
+    next: 'eln self running-runs',
+    missing: ['runId', ...(result.node ? [] : ['node'])],
+    message: '하니스 응답을 받았지만 런 식별자는 아직 미관측입니다 · 진행 중 런 조회: eln self running-runs · 일치하는 런이 없으면 요청을 다시 보내세요 · 이 턴에서 파일을 직접 편집하지 마세요',
+  };
+}
+
+/** 관측 전용 — 런이 발사되지 «않았다»는 사실과 «구현 실패가 아니다»를 함께 말한다. */
+export function buildObservedOnlyToolResult(): SelfImplementObservedOnlyToolResult {
+  return {
+    kind: 'observed-only',
+    observed: true,
+    missing: ['runId', 'node'],
+    next: '실제 발사를 원하면 관측 전용 모드를 끈 뒤 다시 요청하세요',
+    message: '관측 전용이라 런을 발사하지 않았습니다 · 코드도 안 바꿨습니다 · 이 결과를 구현 실패로 읽고 직접 Write/Edit 하지 마세요 · 실제 발사를 원하면 관측 전용 모드를 끈 뒤 다시 요청하세요',
+  };
+}
+
+/** 거부·실패 — 이유와 다음 행동을 구조화해 모델이 재시도·포기·인계를 판단하게 한다. */
+export function buildFailedToolResult(reason: string, result?: SelfImplementResult): SelfImplementFailedToolResult {
+  const next = result?.runId ? `eln self run ${result.runId}` : '요청과 실패 이유를 확인한 뒤 다시 요청하세요';
+  return {
+    ...(result ?? {}), kind: 'failed', reason, next,
+    missing: [...(result?.runId ? [] : ['runId']), ...(result?.node ? [] : ['node'])],
+    message: `하니스가 발사되지 않았거나 실패했습니다: ${reason} · 다음: ${next} · 이 턴에서 파일을 직접 편집하지 마세요`,
+  };
+}
+
 /**
  * ★ base seam 에 막(SurfaceUx) 배선을 얹는다(P0·테스트 가능). approvePr=ux.confirm(fail-closed)·
  * onProgress=ux.progress. 코어(runSelfImplement)·다른 seam(worktree/implement/gate/openPr)은 무손상.
@@ -180,9 +240,10 @@ export async function dispatchSelfImplement(
   authorGoal: SelfImplementGoalAuthor = writeAuthoredGoal,
   runCli: RunSelfImplementCliFn = runSelfImplementCliCommand,
   seamsFactory?: SelfImplementSeamsFactory,
-): Promise<unknown> {
+): Promise<SelfImplementToolResult> {
   const feature = typeof args.feature === 'string' ? args.feature.trim() : '';
-  if (!feature) return { error: 'SelfImplement: `feature` is required' };
+  if (!feature) return buildFailedToolResult('SelfImplement: `feature` is required');
+  try {
   const base = typeof args.base === 'string' && args.base.trim() ? args.base.trim() : undefined;
   const draft = typeof args.draft === 'boolean' ? args.draft : true;
   const entry = resolveDispatchEntry(ctx);
@@ -216,7 +277,7 @@ export async function dispatchSelfImplement(
   debug.log('daemon-tools.self-implement', 'runtime.observe-only-decision', { surface: ux.surface, observeOnly: observeOnly.enabled, observeOnlySource: observeOnly.source });
   if (observeOnly.enabled) {
     debug.log('daemon-tools.self-implement', 'runtime.observed', { surface: ux.surface, observeOnly: observeOnly.enabled, observeOnlySource: observeOnly.source });
-    return { observed: true };
+    return buildObservedOnlyToolResult();
   }
 
   let goalFile: string | undefined;
@@ -298,5 +359,12 @@ export async function dispatchSelfImplement(
   // ⭐ runId 를 반드시 싣는다 — 관측이 전부 runId 로 키잉되므로(`self run <runId>`·`logs --grep`)
   //   이게 없으면 **이 경계에서 조인이 끊긴다**(N3 재측정 2026-07-28: 계약은 섰는데 로그가 못 따라갔다).
   debug.log('daemon-tools.self-implement', 'done', { runId: result.runId, stage: result.stage, ok: result.ok, pr: result.prUrl ?? null });
-  return result;
+  return !result.ok
+    ? buildFailedToolResult(result.detail ?? result.stage, result)
+    : result.runId ? buildLaunchedToolResult(result) : buildPendingToolResult(result);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    debug.log('daemon-tools.self-implement', 'failed', { reason, stage: 'dispatch' });
+    return buildFailedToolResult(reason);
+  }
 }

package/src/briefing/brief-items.ts

@@ -49,6 +49,15 @@ export interface AddBriefItem {
   dedupeWithinMs?: number;
 }
 
+export interface BriefTelegramFeedback {
+  botId: string;
+  chatId: number;
+  messageId: number;
+  updateId: string;
+  reaction: BriefReaction;
+  itemId?: number;
+}
+
 export interface BriefItemsOptions {
   stateDir?: string;
   now?: () => Date;
@@ -112,7 +121,11 @@ export function composeBriefMarkdown(items: readonly BriefItem[], slot: BriefSlo
 }
 
 /** The ids are exactly the rows represented by the composed page, after deduplication. */
-export function composeBriefPage(items: readonly BriefItem[], slot: BriefSendSlot, now: Date): { markdown: string; ids: number[] } {
+export function composeBriefPage(
+  items: readonly BriefItem[], slot: BriefSendSlot, now: Date,
+  actions?: BriefWeeklyActions,
+  observedKinds?: ReadonlySet<BriefDomain>,
+): { markdown: string; ids: number[] } {
   const today = dateKey(now, { timeZone: KST });
   // A duplicate left out of a delivered page stays unsent in the ledger, but must not reappear on a later page.
   // A new undeliverable observation after a sent page is a new occurrence, not an old duplicate.
@@ -138,11 +151,22 @@ export function composeBriefPage(items: readonly BriefItem[], slot: BriefSendSlo
     for (const item of decisions) lines.push(itemLine(item));
     lines.push('');
   }
-  for (const domain of BRIEF_DOMAINS) {
+  const domains = [...BRIEF_DOMAINS];
+  // Measured action leads. An unobserved kind keeps its normal position; a sent-but-unobserved
+  // item is not evidence of being ignored. Keep every domain heading in this first slice.
+  if (actions && Object.values(actions.byKind).some(count => count.acted > 0)) {
+    domains.sort((a, b) => {
+      const x = actions.byKind[a], y = actions.byKind[b];
+      const xRate = observedKinds?.has(a) ? x.rate : 0;
+      const yRate = observedKinds?.has(b) ? y.rate : 0;
+      return yRate - xRate || BRIEF_DOMAINS.indexOf(a) - BRIEF_DOMAINS.indexOf(b);
+    });
+  }
+  for (const domain of domains) {
     const group = unique.filter(item => item.domain === domain && !decisionIds.has(item.id));
     if (group.length === 0) continue;
     lines.push(`## ${domain}`, '');
-    for (const item of group.sort((a, b) => a.id - b.id)) lines.push(itemLine(item));
+    for (const item of group) lines.push(itemLine(item));
     lines.push('');
   }
   return { markdown: `${lines.join('\n').trimEnd()}\n`, ids: unique.map(item => item.id) };
@@ -203,12 +227,12 @@ export class BriefItemsLedger {
     this.requirementFunnel = options.requirementFunnel ?? ((now) => readRequirementFunnel({ stateDir: options.stateDir, now }));
   }
 
-  private using<T>(work: (db: Database) => T): T {
+  private using<T>(work: (db: Database) => T, busyTimeoutMs = 10000): T {
     mkdirSync(dirname(this.path), { recursive: true });
     const db = new Database(this.path, { create: true, strict: true });
     try {
       chmodSync(this.path, 0o600);
-      db.exec('PRAGMA busy_timeout = 10000');
+      db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
       migrateLegacyItems(db, this.log);
       db.exec(`CREATE TABLE IF NOT EXISTS items (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -237,7 +261,20 @@ export class BriefItemsLedger {
         reacted_at TEXT NOT NULL
       );
       CREATE INDEX IF NOT EXISTS reactions_item_time ON reactions(item_id, reacted_at);
-      CREATE INDEX IF NOT EXISTS sends_time ON sends(sent_at);`);
+      CREATE INDEX IF NOT EXISTS sends_time ON sends(sent_at);
+      CREATE TABLE IF NOT EXISTS telegram_sends (
+        bot_id TEXT NOT NULL,
+        chat_id INTEGER NOT NULL,
+        message_id INTEGER NOT NULL,
+        item_id INTEGER NOT NULL REFERENCES items(id),
+        PRIMARY KEY (bot_id, chat_id, message_id, item_id)
+      );
+      CREATE TABLE IF NOT EXISTS telegram_feedback_events (
+        bot_id TEXT NOT NULL,
+        chat_id INTEGER NOT NULL,
+        update_id TEXT NOT NULL,
+        PRIMARY KEY (bot_id, chat_id, update_id)
+      );`);
       if (!(db.query("SELECT name FROM pragma_table_info('items')").all() as { name: string }[]).some(column => column.name === 'dedupe_key')) {
         db.exec('ALTER TABLE items ADD COLUMN dedupe_key TEXT');
       }
@@ -318,34 +355,72 @@ export class BriefItemsLedger {
     this.log('briefing.items', 'reaction-recorded', { itemId, reaction });
   }
 
+  /** Attribute one update to an item in its delivered Telegram message, without rewriting send history. */
+  recordTelegramFeedback(event: BriefTelegramFeedback): boolean {
+    if (!event.botId || !Number.isSafeInteger(event.chatId) || !Number.isSafeInteger(event.messageId)
+      || event.messageId < 1 || !event.updateId || !(BRIEF_REACTIONS as readonly string[]).includes(event.reaction)) {
+      throw new BriefItemsInputError('invalid telegram feedback');
+    }
+    if (event.itemId !== undefined && (!Number.isSafeInteger(event.itemId) || event.itemId < 1)) {
+      throw new BriefItemsInputError('invalid item id');
+    }
+    const recorded = this.using(db => {
+      // Wait for an in-flight brief send before looking up its coordinates. A deferred read
+      // could see the pre-send snapshot and discard an early callback as unmatched.
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        const linked = db.query('SELECT item_id FROM telegram_sends WHERE bot_id = ? AND chat_id = ? AND message_id = ? ORDER BY item_id')
+          .all(event.botId, event.chatId, event.messageId) as Array<{ item_id: number }>;
+        const targets = event.itemId === undefined ? (linked.length === 1 ? linked : []) : linked.filter(row => row.item_id === event.itemId);
+        if (targets.length !== 1) { db.exec('COMMIT'); return false; }
+        if (!db.query('INSERT OR IGNORE INTO telegram_feedback_events (bot_id, chat_id, update_id) VALUES (?, ?, ?) RETURNING update_id')
+          .get(event.botId, event.chatId, event.updateId)) { db.exec('COMMIT'); return false; }
+        db.query('INSERT INTO reactions (item_id, reaction, reacted_at) VALUES (?, ?, ?)')
+          .run(targets[0]!.item_id, event.reaction, this.now().toISOString());
+        db.exec('COMMIT');
+        return targets[0]!.item_id;
+      } catch (cause) {
+        try { db.exec('ROLLBACK'); } catch { /* connection closes next */ }
+        throw cause;
+      }
+    }, 120000);
+    if (recorded) this.log('briefing.items', 'reaction-recorded', { itemId: recorded, reaction: event.reaction, source: 'telegram' });
+    return recorded !== false;
+  }
+
   /** KST Monday through now: distinct sent items acted on (button/reply/correction), grouped by domain. */
   weeklyActions(): BriefWeeklyActions {
-    const now = this.now();
+    return this.using(db => this.weeklyActionsFromDb(db, this.now()));
+  }
+
+  private weekStart(now: Date): string {
     const today = dateKey(now, { timeZone: KST });
     const day = new Date(`${today}T00:00:00Z`);
     day.setUTCDate(day.getUTCDate() - ((day.getUTCDay() + 6) % 7));
-    const since = new Date(`${day.toISOString().slice(0, 10)}T00:00:00+09:00`).toISOString();
+    return new Date(`${day.toISOString().slice(0, 10)}T00:00:00+09:00`).toISOString();
+  }
+
+  private weeklyActionsFromDb(db: Database, now: Date): BriefWeeklyActions {
+    const since = this.weekStart(now);
     const until = now.toISOString();
-    return this.using(db => {
-      const rows = db.query(`SELECT items.domain AS kind,
-        COUNT(*) AS total,
-        SUM(CASE WHEN EXISTS (
-          SELECT 1 FROM reactions r WHERE r.item_id = items.id
-            AND r.reaction IN ('버튼', '답장', '정정') AND r.reacted_at >= ? AND r.reacted_at <= ?
-        ) THEN 1 ELSE 0 END) AS acted
-        FROM items WHERE EXISTS (
-          SELECT 1 FROM sends s WHERE s.item_id = items.id AND s.sent_at >= ? AND s.sent_at <= ?
-        ) GROUP BY items.domain`).all(since, until, since, until) as Array<{ kind: BriefDomain; total: number; acted: number }>;
-      const byKind = Object.fromEntries(BRIEF_DOMAINS.map(kind => [kind, { acted: 0, total: 0, rate: 0 }])) as Record<BriefDomain, BriefActionCount>;
-      let acted = 0;
-      let total = 0;
-      for (const row of rows) {
-        byKind[row.kind] = { acted: row.acted, total: row.total, rate: row.acted / row.total };
-        acted += row.acted;
-        total += row.total;
-      }
-      return { acted, total, rate: total === 0 ? 0 : acted / total, byKind };
-    });
+    const rows = db.query(`SELECT items.domain AS kind,
+      COUNT(*) AS total,
+      SUM(CASE WHEN EXISTS (
+        SELECT 1 FROM reactions r WHERE r.item_id = items.id
+          AND r.reaction IN ('버튼', '답장', '정정') AND r.reacted_at >= ? AND r.reacted_at <= ?
+      ) THEN 1 ELSE 0 END) AS acted
+      FROM items WHERE EXISTS (
+        SELECT 1 FROM sends s WHERE s.item_id = items.id AND s.sent_at >= ? AND s.sent_at <= ?
+      ) GROUP BY items.domain`).all(since, until, since, until) as Array<{ kind: BriefDomain; total: number; acted: number }>;
+    const byKind = Object.fromEntries(BRIEF_DOMAINS.map(kind => [kind, { acted: 0, total: 0, rate: 0 }])) as Record<BriefDomain, BriefActionCount>;
+    let acted = 0;
+    let total = 0;
+    for (const row of rows) {
+      byKind[row.kind] = { acted: row.acted, total: row.total, rate: row.acted / row.total };
+      acted += row.acted;
+      total += row.total;
+    }
+    return { acted, total, rate: total === 0 ? 0 : acted / total, byKind };
   }
 
   /** Insertion order. Optional domain filter. Item text is the stored original. */
@@ -388,7 +463,14 @@ export class BriefItemsLedger {
         this.log('briefing.items', 'requirement-funnel-failed', { slot, error: error instanceof Error ? error.message : String(error) });
       }
     }
-    const composed = composeBriefPage([...items, ...funnelItems], slot, now);
+    const since = this.weekStart(now);
+    const until = now.toISOString();
+    const observedKinds = new Set((db.query(`SELECT DISTINCT i.domain FROM items i
+      JOIN reactions r ON r.item_id = i.id
+      WHERE r.reacted_at >= ? AND r.reacted_at <= ? AND EXISTS (
+        SELECT 1 FROM sends s WHERE s.item_id = i.id AND s.sent_at >= ? AND s.sent_at <= ?
+      )`).all(since, until, since, until) as Array<{ domain: BriefDomain }>).map(row => row.domain));
+    const composed = composeBriefPage([...items, ...funnelItems], slot, now, this.weeklyActionsFromDb(db, now), observedKinds);
     // Ephemeral funnel lines appear on the page but have no ledger row to mark sent.
     const page = { markdown: composed.markdown, ids: composed.ids.filter(id => id > 0) };
     const candidates = (slot === 'realtime' ? pendingRealtime(items, now) : items.filter(item => item.sent_at === null && beforeSlot(item.created_at, slot, now))).length;
@@ -403,24 +485,58 @@ export class BriefItemsLedger {
   }
 
   /** Hold the ledger's SQLite writer lock from selecting unsent rows through delivery and marking.
-   * A failed delivery rolls back and releases the lock; the next sender can retry.
+   * A delivery that fails before anything was sent rolls back and releases the lock; the next
+   * sender can retry. A delivery that fails after some messages already went out commits what
+   * the 대표 actually received (sends + telegram_sends) so a retry never re-sends them.
    */
-  withSendLock<T>(slot: string, work: (page: { markdown: string; ids: number[] }, markSent: (ids: readonly number[], slot: BriefSendSlot) => number) => T): T {
+  withSendLock<T>(slot: string, work: (page: { markdown: string; ids: number[]; itemLines: ReadonlyMap<string, readonly number[]> }, markSent: (ids: readonly number[], slot: BriefSendSlot, telegram?: { botId: string; chatId: number; messageId: number } | ReadonlyArray<{ botId: string; chatId: number; messageId: number; itemId: number }>) => number) => T): T {
     if (slot !== 'realtime' && !(BRIEF_SLOTS as readonly string[]).includes(slot)) throw new BriefItemsInputError('invalid slot');
     return this.using(db => {
       db.exec('BEGIN IMMEDIATE');
+      let marked = false;
       try {
         const page = this.pageFromDb(db, slot as BriefSendSlot);
-        const result = work(page, (ids, sentSlot) => {
-          if (sentSlot !== slot || ids.length !== page.ids.length || ids.some((id, index) => id !== page.ids[index])) {
+        const itemIds = new Set(page.ids);
+        const itemLines = new Map<string, number[]>();
+        for (const item of this.itemsFromDb(db).filter(item => itemIds.has(item.id))) {
+          const line = itemLine(item);
+          itemLines.set(line, [...(itemLines.get(line) ?? []), item.id]);
+        }
+        const result = work({ ...page, itemLines }, (ids, sentSlot, telegram) => {
+          const pageIdSet = new Set(page.ids);
+          if (sentSlot !== slot || ids.length === 0 || new Set(ids).size !== ids.length
+            || ids.some(id => !pageIdSet.has(id))) {
             throw new BriefItemsInputError('marked ids must match composed page');
           }
-          return this.markSentInDb(db, ids, sentSlot);
+          const coordinates = telegram === undefined ? [] : Array.isArray(telegram)
+            ? telegram : ids.map(itemId => ({ ...telegram, itemId }));
+          if (telegram && (coordinates.some(row => !row.botId || !Number.isSafeInteger(row.chatId)
+            || !Number.isSafeInteger(row.messageId) || row.messageId < 1 || !ids.includes(row.itemId))
+            || new Set(coordinates.map(row => row.itemId)).size !== ids.length)) {
+            throw new BriefItemsInputError('invalid telegram send');
+          }
+          db.exec('SAVEPOINT brief_mark');
+          try {
+            const count = this.markSentInDb(db, ids, sentSlot);
+            if (telegram) {
+              const insert = db.query('INSERT OR IGNORE INTO telegram_sends (bot_id, chat_id, message_id, item_id) VALUES (?, ?, ?, ?)');
+              for (const row of coordinates) insert.run(row.botId, row.chatId, row.messageId, row.itemId);
+            }
+            db.exec('RELEASE brief_mark');
+            marked = true;
+            return count;
+          } catch (cause) {
+            db.exec('ROLLBACK TO brief_mark');
+            db.exec('RELEASE brief_mark');
+            throw cause;
+          }
         });
         db.exec('COMMIT');
         return result;
       } catch (cause) {
-        db.exec('ROLLBACK');
+        // The only writes inside this lock are the marks; committing on failure preserves what
+        // the 대표 already received, so a retry sends only the unsent remainder.
+        try { db.exec(marked ? 'COMMIT' : 'ROLLBACK'); } catch { /* the connection closes next */ }
         throw cause;
       }
     });

package/src/budget/llm-cost.ts

@@ -24,7 +24,11 @@ export interface LlmPricingUsd {
   longContext?: { thresholdTokens: number; inputPerM: number; outputPerM: number; cacheReadPerM?: number; cacheWritePerM?: number };
 }
 
-/** AWS Bedrock Global Standard prices, USD per million tokens (AWS pricing API, ap-northeast-2). */
+/** AWS Bedrock Global Standard prices, USD per million tokens (AWS pricing API, ap-northeast-2).
+ *  ⛔ BEDROCK-COST-LEDGER(0.2.26) — mantle-openai 비-Anthropic Bedrock id(`openai.gpt-6-sol`·`zai.glm-5` 등
+ *  `src/llm/bedrock.ts` BEDROCK_MODELS 의 `route:'mantle-openai'` 행)는 여기에 행이 «없다»: 단가 수치 근거가
+ *  하나도 확보되지 않았다. 근거 없는 id는 `isBedrockPricingModel` 게이트(`claude-` 시작)를 지나지 않아
+ *  `unknownCost()` 로 `kind:'unknown'` 에 머문다 — 0원으로 꾸미지 않는다. */
 export const BEDROCK_PRICING_USD: Readonly<Record<string, LlmPricingUsd>> = {
   'claude-haiku-5-5': { inputPerM: 0.1, outputPerM: 0.5, cacheWritePerM: 0.125, cacheReadPerM: 0.01 },
   'claude-sonnet-5-5': { inputPerM: 2, outputPerM: 10, cacheWritePerM: 2.5, cacheReadPerM: 0.1 },
@@ -299,7 +303,19 @@ export function estimateLlmCost(
 
 /** Discriminated cost fields to spread onto an `llm.usage` observation. */
 /** 과금 경로(BACKLOG C6 · hermes `resolve_billing_route`). 구독(OAuth)·local 은 «토큰당 청구가 없다». */
-export type BillingRoute = 'subscription' | 'local' | 'api' | 'unknown';
+export type BillingRoute = 'subscription' | 'local' | 'credit' | 'api' | 'unknown';
+
+/** Credit is known only when the quota window is exhausted and credits are present. */
+export function creditRouteFromQuotaSignal(signal: {
+  usedPercent?: number | null;
+  rateLimitReached?: boolean | null;
+  hasCredits?: boolean | null;
+} | null): 'credit' | null {
+  if (!signal || signal.hasCredits !== true) return null;
+  const exhausted = signal.rateLimitReached === true
+    || (typeof signal.usedPercent === 'number' && Number.isFinite(signal.usedPercent) && signal.usedPercent >= 100);
+  return exhausted ? 'credit' : null;
+}
 
 /** 구독·local 호출의 비용 — 청구 0 이지만 «API 로 샀다면」 값은 따로 남긴다(환산가 · 모르면 칸이 없다). */
 /** provider 가 보고한 실제 청구액(OpenRouter `usage.cost`) — 카탈로그 추정과 다르면 이것이 맞다. */
@@ -319,14 +335,25 @@ export interface IncludedLlmCost {
   apiEquivalentUsd?: number;
 }
 
+export interface CreditLlmCost {
+  kind: 'credit';
+  model: string;
+  usd: null;
+  apiEquivalentUsd?: number;
+}
+
 export function llmUsageCostFields(
   model: string,
   usage: Omit<LlmCostUsage, 'model'>,
   opts?: EstimateLlmCostOptions,
   billing?: BillingRoute,
-): { cost: LlmCostEstimate | IncludedLlmCost | ActualLlmCost | ByokActualCost | ByokPartialCost } {
+): { cost: LlmCostEstimate | IncludedLlmCost | CreditLlmCost | ActualLlmCost | ByokActualCost | ByokPartialCost } {
   const resolved = opts ?? { configPricing: readLlmConfigPricing() };
   const estimate = estimateLlmCost({ model, ...usage }, resolved);
+  // An explicit credit route owns this cost row; API/BYOK amounts belong to other routes.
+  if (billing === 'credit') {
+    return { cost: { kind: 'credit', model, usd: null, ...(estimate.kind === 'known' || estimate.kind === 'partial' ? { apiEquivalentUsd: estimate.usd } : {}) } };
+  }
   // ⛔⭐ 구독을 API 단가로 «known» 이라 적지 않는다 — 09-25 벤치에서 codex 구독 팔이 `$7.81 known` 으로 보였다.
   // ⭐ BACKLOG C7 — provider 가 실어 보낸 «실제 청구액»이 있으면 그것이 비용이다(추정은 곁에 남긴다).
   // OR-BYOK-COST — BYOK 면 «OR 청구 + 상류 청구»가 비용이다(상류를 모르면 partial · 0 으로 가정하지 않는다).

package/src/budget/usage-outcomes.ts

@@ -33,6 +33,14 @@ export interface UsageOutcomesReport {
   readonly unreadableLedgers: number;
 }
 
+export interface AutoLandRatioRow {
+  readonly selfLanded: number;
+  readonly handMerges: number | null;
+  readonly totalMerges: number | null;
+  readonly autoLandRatio: number | null;
+  readonly blockReasons: Readonly<Record<string, number>>;
+}
+
 export interface UsageOutcomesDeps {
   readonly dir?: string;
   readonly nowMs?: number;
@@ -139,6 +147,30 @@ export function aggregateUsageOutcomes(
   return { sinceDays, sinceMs, rows, unreadableLedgers };
 }
 
+/** Join the existing run-ledger aggregate with an externally measured hand-merge count. */
+export function measureAutoLandRatio(report: UsageOutcomesReport, handMerges: number | null): AutoLandRatioRow {
+  const selfLanded = report.rows.reduce((sum, row) => sum + row.landed, 0);
+  const hand = handMerges !== null && Number.isSafeInteger(handMerges) && handMerges >= 0 ? handMerges : null;
+  const sum = hand === null ? null : selfLanded + hand;
+  // An empty report also represents a missing ledger directory; do not turn that into 0%.
+  const totalMerges = report.rows.length === 0 || report.unreadableLedgers > 0 || sum === null || !Number.isSafeInteger(sum) ? null : sum;
+  const autoLandRatio = totalMerges === null || totalMerges === 0 ? null : selfLanded / totalMerges;
+  const reasons = new Map<string, number>();
+  for (const row of report.rows) {
+    for (const [reason, count] of Object.entries(row.blockReasons)) {
+      reasons.set(reason, (reasons.get(reason) ?? 0) + count);
+    }
+  }
+  const blockReasons = Object.fromEntries([...reasons].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))) as Record<string, number>;
+  return { selfLanded, handMerges: hand, totalMerges, autoLandRatio, blockReasons };
+}
+
+export function formatAutoLandRatio(row: AutoLandRatioRow): string {
+  const ratio = row.autoLandRatio === null ? '-' : `${Math.round(row.autoLandRatio * 1000) / 10}%`;
+  const reasons = Object.entries(row.blockReasons).map(([reason, count]) => `${reason}=${count}`).join(',') || '-';
+  return `자율 착지 ${row.selfLanded} / 전체 ${row.totalMerges ?? '-'} (${ratio}) · 손 착지 ${row.handMerges ?? '-'} · 멈춤 사유 ${reasons}`;
+}
+
 export function queryUsageOutcomes(sinceDays: number, deps: UsageOutcomesDeps = {}): UsageOutcomesReport {
   const days = Number.isFinite(sinceDays) && sinceDays > 0 ? sinceDays : 2;
   const nowMs = deps.nowMs ?? Date.now();

package/src/claims/claims-ledger.ts

@@ -3,6 +3,7 @@ import { chmodSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { debug } from '../debug/log.js';
+import type { PatentCandidate, PatentLedger } from '../patents/ledger.js';
 
 export type ClaimStatus = 'draft' | 'verified' | 'public' | 'stale' | 'retracted';
 
@@ -41,6 +42,19 @@ function iso(value: string, field: string): string {
   return date.toISOString();
 }
 
+function patentClaimRow(candidate: PatentCandidate, owner: string, audience: string): ClaimRow {
+  return {
+    id: candidate.id,
+    claim: candidate.title,
+    audience,
+    status: 'public',
+    owner,
+    contrast: null,
+    created_at: candidate.created_at,
+    updated_at: candidate.updated_at,
+  };
+}
+
 export class ClaimsLedger {
   readonly path: string;
   private readonly now: () => Date;
@@ -229,4 +243,13 @@ export class ClaimsLedger {
       };
     }));
   }
+
+  /** 특허 원장의 공개 허용 상태 후보만 읽어 공개 주장 행으로 내온다 — 조사·명세·출원 상태 후보는 공개 주장으로 나오지 않는다. */
+  patentClaims(patents: PatentLedger, options: { owner: string; audience: string }): ClaimRow[] {
+    const owner = required(options.owner, 'owner');
+    const audience = required(options.audience, 'audience');
+    const rows = patents.listPublicCandidates().map(candidate => patentClaimRow(candidate, owner, audience));
+    debug.log('claims.ledger', 'patent-claims', { count: rows.length });
+    return rows;
+  }
 }

package/src/claims/claims-render.ts

@@ -6,6 +6,7 @@ import { BRAND_RULES_UNMEASURED, checkBrand } from '../../scripts/brand/check.js
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import type { ClaimsLedger, ClaimEvidence } from './claims-ledger.js';
+import type { PatentLedger } from '../patents/ledger.js';
 
 export type ClaimSurface = 'deck' | 'site' | 'notice';
 export interface RenderedClaims {
@@ -49,12 +50,14 @@ export function representativeNumber(value: string): string | undefined {
   return matches[0];
 }
 
-export function renderClaims(ledger: ClaimsLedger, options: { surface: ClaimSurface; audience?: string; rulesPath?: string }): RenderedClaims {
+export function renderClaims(ledger: ClaimsLedger, options: { surface: ClaimSurface; audience?: string; rulesPath?: string; patents?: { ledger: PatentLedger; owner: string; audience: string } }): RenderedClaims {
   const { surface, audience } = options;
   if (!(surface in headings)) throw new Error(`invalid claims surface: ${surface}`);
   const excluded: RenderedClaims['excluded'] = [];
   const candidates: Array<{ id: string; line: string }> = [];
-  for (const row of ledger.list()) {
+  const rows = ledger.list();
+  const known = new Set(rows.map(row => row.id));
+  for (const row of rows) {
     if (audience && !row.audience.split(',').includes(audience)) continue;
     if (row.status !== 'public') {
       excluded.push({ id: row.id, reason: row.status === 'stale' ? 'stale' : row.status === 'retracted' ? 'retracted' : 'not-public' });
@@ -83,6 +86,23 @@ export function renderClaims(ledger: ClaimsLedger, options: { surface: ClaimSurf
     candidates.push({ id: row.id, line: `- ${claim} — ${number} <!-- claim:${row.id} measured:${evidence.measured_at} cmd:${commentValue(evidence.command)}${evidence.source ? ` source:${commentValue(evidence.source)}` : ''} --> <!-- src:${commentValue(evidence.source ?? evidence.command)} -->` });
   }
 
+  // 공개 허용 상태는 렌더 시점에 특허 원장에서 읽는다. 임의의 ClaimRow 배열은 받지 않는다.
+  // 저장된 주장과 같은 식별자를 가진 유도 행은 원장 행이 이긴다.
+  for (const row of options.patents ? ledger.patentClaims(options.patents.ledger, options.patents) : []) {
+    if (known.has(row.id)) continue;
+    if (audience && !row.audience.split(',').includes(audience)) continue;
+    if (row.status !== 'public') {
+      excluded.push({ id: row.id, reason: 'not-public' });
+      continue;
+    }
+    const patentClaim = firstSentence(row.claim);
+    if (!patentClaim) {
+      excluded.push({ id: row.id, reason: 'brand' });
+      continue;
+    }
+    candidates.push({ id: row.id, line: `- ${patentClaim} <!-- claim:${row.id} patent --> <!-- src:patents -->` });
+  }
+
   const rulesMissing = checkBrand(scopes[surface], [], options.rulesPath).missing;
   if (rulesMissing) {
     excluded.push(...candidates.map(({ id }) => ({ id, reason: 'rules-missing' as const })));