elanous 0.2.27 → 0.2.29

package/src/chat/turn-typeahead.ts

@@ -13,6 +13,55 @@ export interface TurnTypeaheadState {
   buffer: string;
   /** Enter 한 입력들. 턴 종료 뒤 입력 순서대로 자동 제출한다. */
   queuedSubmissions: string[];
+  /**
+   * `queuedSubmissions` 와 같은 순서의 짝 — 턴 «안» 주입 레지스트리(`session/pending-input`) 항목 id.
+   * `null`(또는 칸이 모자람) = 레지스트리에 안 넣은 항목. ⭐ 이 id 로 배수·되꺼내기·턴 종료 승격을
+   * «짝지어» 떨어낸다 — 위치·문자열로 짝지으면 같은 발화가 두 번 들어간다(10-14 중복 수리).
+   */
+  queuedPendingIds?: (string | null)[];
+}
+
+/** 큐 길이에 맞춘 id 짝(모자라면 null 로 채운다). 순수. */
+export function turnTypeaheadPendingIds(state: TurnTypeaheadState): (string | null)[] {
+  const ids = state.queuedPendingIds ?? [];
+  return state.queuedSubmissions.map((_, i) => ids[i] ?? null);
+}
+
+function presentIds(ids: readonly (string | null)[]): string[] {
+  return ids.filter((id): id is string => typeof id === 'string');
+}
+
+/** 짝이 하나도 없으면 칸을 아예 안 둔다(`undefined` 키도 없이) — 레지스트리를 안 쓰는 경로의 상태 모양을 옛 그대로 둔다. */
+function idsField(ids: readonly (string | null)[]): { queuedPendingIds?: (string | null)[] } {
+  return ids.some(id => id !== null) ? { queuedPendingIds: [...ids] } : {};
+}
+
+/** 상태에서 id 짝 칸을 뗀다 — `idsField` 와 함께 써서 옛 짝이 스프레드로 살아남지 않게 한다. */
+function withoutIds(state: TurnTypeaheadState): TurnTypeaheadState {
+  if (!('queuedPendingIds' in state)) return state;
+  const { queuedPendingIds: _ids, ...rest } = state;
+  return rest;
+}
+
+/** 큐 index 번째 항목에 레지스트리 id 를 단다. 순수. 범위 밖이면 그대로. */
+export function attachTurnTypeaheadPendingId(
+  state: TurnTypeaheadState,
+  index: number,
+  id: string,
+): TurnTypeaheadState {
+  if (index < 0 || index >= state.queuedSubmissions.length) return state;
+  const ids = turnTypeaheadPendingIds(state);
+  ids[index] = id;
+  return { ...withoutIds(state), ...idsField(ids) };
+}
+
+/**
+ * 턴 «안» 주입(steer) 대상인가. ⛔ 슬래시는 뺀다 — 명령은 턴이 끝난 뒤 FIFO 로만 실행한다
+ * (모델에 `/…` 문면이 발화로 들어가면 명령이 아니라 잡음이다 · Claude Code 도 같은 경계에서 뺀다).
+ */
+export function isTurnTypeaheadSteerable(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.length > 0 && !trimmed.startsWith('/');
 }
 
 export function createTurnTypeaheadState(): TurnTypeaheadState {
@@ -38,6 +87,8 @@ export type TurnTypeaheadKeyResult = {
   immediateSubmission?: string;
   /** 비어 있지 않은 Enter 입력의 제출 경로 분류. */
   submissionDisposition?: 'immediate' | 'fifo';
+  /** 큐에서 «다른 길»로 빠진 항목의 레지스트리 id — 호출측이 레지스트리에서도 떨어낸다(되꺼내기). */
+  releasedPendingIds?: string[];
 };
 
 /** 등록소 소유의 관측용 표시 조회. 이름·문법·실행 정책은 이 순수 판정기에 두지 않는다. */
@@ -82,7 +133,11 @@ export function applyTurnTypeaheadKey(
       // A registry lookup failure must preserve the typed input on the existing FIFO path.
     }
     return {
-      state: { buffer: '', queuedSubmissions: [...state.queuedSubmissions, state.buffer] },
+      state: {
+        buffer: '',
+        queuedSubmissions: [...state.queuedSubmissions, state.buffer],
+        ...idsField([...turnTypeaheadPendingIds(state), null]),
+      },
       consumed: true,
       changed: true,
       submissionDisposition: 'fifo',
@@ -94,10 +149,16 @@ export function applyTurnTypeaheadKey(
   if (key.name === 'up' && key.ctrl && !key.alt && !key.shift && !key.meta) {
     const recalled = state.queuedSubmissions.at(-1);
     if (recalled === undefined) return { state, consumed: false, changed: false };
+    const ids = turnTypeaheadPendingIds(state);
     return {
-      state: { buffer: state.buffer + recalled, queuedSubmissions: state.queuedSubmissions.slice(0, -1) },
+      state: {
+        buffer: state.buffer + recalled,
+        queuedSubmissions: state.queuedSubmissions.slice(0, -1),
+        ...idsField(ids.slice(0, -1)),
+      },
       consumed: true,
       changed: true,
+      ...(ids.at(-1) ? { releasedPendingIds: presentIds(ids.slice(-1)) } : {}),
     };
   }
 
@@ -114,13 +175,17 @@ export function restoreTurnTypeaheadSubmission(
   state: TurnTypeaheadState,
   text: string,
 ): TurnTypeaheadState {
-  return { ...state, queuedSubmissions: [...state.queuedSubmissions, text] };
+  return {
+    ...withoutIds(state),
+    queuedSubmissions: [...state.queuedSubmissions, text],
+    ...idsField([...turnTypeaheadPendingIds(state), null]),
+  };
 }
 
 export type TurnTypeaheadHandoff =
   | { kind: 'none' }
   | { kind: 'prefill'; text: string }
-  | { kind: 'submit'; text: string };
+  | { kind: 'submit'; text: string; pendingId?: string };
 
 /** 턴 종료 때 FIFO의 다음 항목 하나를 꺼낸다. 큐가 비면 미제출 buffer는 prefill한다. */
 export function dequeueTurnTypeaheadHandoff(
@@ -128,7 +193,11 @@ export function dequeueTurnTypeaheadHandoff(
 ): { handoff: TurnTypeaheadHandoff; state: TurnTypeaheadState } {
   const [next, ...queuedSubmissions] = state.queuedSubmissions;
   if (next !== undefined) {
-    return { handoff: { kind: 'submit', text: next }, state: { ...state, queuedSubmissions } };
+    const [pendingId, ...queuedPendingIds] = turnTypeaheadPendingIds(state);
+    return {
+      handoff: pendingId ? { kind: 'submit', text: next, pendingId } : { kind: 'submit', text: next },
+      state: { ...withoutIds(state), queuedSubmissions, ...idsField(queuedPendingIds) },
+    };
   }
   if (!state.buffer) return { handoff: { kind: 'none' }, state };
   return { handoff: { kind: 'prefill', text: state.buffer }, state: createTurnTypeaheadState() };
@@ -143,21 +212,35 @@ export function drainTurnTypeaheadOnce(
   state: TurnTypeaheadState,
   carriedInitial: string | null | undefined,
   opts?: { interrupted?: boolean },
-): { state: TurnTypeaheadState; nextInitial: string | undefined; injectEnter: boolean } {
+): {
+  state: TurnTypeaheadState;
+  nextInitial: string | undefined;
+  injectEnter: boolean;
+  /**
+   * ⭐ 이번 걸음에 큐를 «떠난» 항목의 레지스트리 id — 호출측이 레지스트리에서도 떨어낸다.
+   *   안 떨어내면 승격된 발화(새 프롬프트)가 다음 턴 둘째 바퀴에 «또» 들어가고(턴 종료),
+   *   composer 로 돌아간 글이 고치기 전 문면으로 모델에 들어간다(중단 복원).
+   */
+  releasedPendingIds: string[];
+} {
   if (opts?.interrupted && state.queuedSubmissions.length > 0) {
     const restored = [...state.queuedSubmissions, ...(state.buffer ? [state.buffer] : [])].join('\n');
     return {
       state: createTurnTypeaheadState(),
       nextInitial: carriedInitial ? `${carriedInitial}\n${restored}` : restored,
       injectEnter: false,
+      releasedPendingIds: presentIds(turnTypeaheadPendingIds(state)),
     };
   }
   const { handoff, state: remaining } = dequeueTurnTypeaheadHandoff(state);
-  if (handoff.kind === 'none') return { state: remaining, nextInitial: carriedInitial ?? undefined, injectEnter: false };
+  if (handoff.kind === 'none') {
+    return { state: remaining, nextInitial: carriedInitial ?? undefined, injectEnter: false, releasedPendingIds: [] };
+  }
   return {
     state: remaining,
     nextInitial: carriedInitial ? `${carriedInitial}${handoff.text}` : handoff.text,
     injectEnter: handoff.kind === 'submit',
+    releasedPendingIds: handoff.kind === 'submit' && handoff.pendingId ? [handoff.pendingId] : [],
   };
 }
 
@@ -177,7 +260,7 @@ export function drainTurnTypeaheadQueue(
 ): { state: TurnTypeaheadState; drained: string[] } {
   if (state.queuedSubmissions.length === 0) return { state, drained: [] };
   return {
-    state: { ...state, queuedSubmissions: [] },
+    state: { ...withoutIds(state), queuedSubmissions: [] },
     drained: [...state.queuedSubmissions],
   };
 }
@@ -185,8 +268,10 @@ export function drainTurnTypeaheadQueue(
 /**
  * ★ 라이브 턴 안으로 배수된 발화의 상태 전이 + 챗로그 문장. 순수.
  *
- * 대시보드 `enqueuePendingUserInput` onDrained 가 앞에서부터
- * `slice(drained.length)` 로 떨어내는 FIFO 와 같다.
+ * `items`(레지스트리 항목 · id 포함)를 주면 ***id 가 짝지어지는 항목만*** 떨어내고 문장도 그것만 적는다.
+ *   ⛔ 앞에서부터 `slice(drained.length)` 하면 같은 버킷의 남의 항목(goal-loop 제어 메모)이나
+ *   이미 되꺼낸 항목 때문에 엉뚱한 대기 발화가 떨어진다(10-14 중복 수리).
+ * `items` 가 없으면 옛 계약(앞에서부터 떨어내기)을 지킨다.
  * 버퍼는 건드리지 않는다. 배수된 것이 없으면 문장도 없다.
  *
  * 문면은 `renderTurnTypeaheadQueueRow` 와 나란히 읽힌다:
@@ -199,15 +284,37 @@ export function drainTurnTypeaheadQueue(
 export function drainedIntoTurn(
   state: TurnTypeaheadState,
   drained: readonly string[],
-): { state: TurnTypeaheadState; sentence: string | null } {
-  if (drained.length === 0) return { state, sentence: null };
-  const remaining = state.queuedSubmissions.slice(drained.length);
-  const count = drained.length;
+  items?: readonly { id: string; text: string }[],
+): { state: TurnTypeaheadState; sentence: string | null; matched: string[] } {
+  if (drained.length === 0) return { state, sentence: null, matched: [] };
+  let next: TurnTypeaheadState;
+  let matched: string[];
+  if (items) {
+    const drainedIds = new Set(items.map(item => item.id));
+    const ids = turnTypeaheadPendingIds(state);
+    const keep = ids.map(id => id === null || !drainedIds.has(id));
+    matched = state.queuedSubmissions.filter((_, i) => !keep[i]);
+    next = {
+      ...withoutIds(state),
+      queuedSubmissions: state.queuedSubmissions.filter((_, i) => keep[i]),
+      ...idsField(ids.filter((_, i) => keep[i])),
+    };
+  } else {
+    matched = [...drained];
+    next = {
+      ...withoutIds(state),
+      queuedSubmissions: state.queuedSubmissions.slice(drained.length),
+      ...idsField(turnTypeaheadPendingIds(state).slice(drained.length)),
+    };
+  }
+  if (matched.length === 0) return { state: next, sentence: null, matched };
+  const count = matched.length;
   const label = count === 1 ? '⏳ 턴 안 1건' : `⏳ 턴 안 ${count}건`;
-  const quoted = drained.map(text => `"${text}"`).join(' · ');
+  const quoted = matched.map(text => `"${text}"`).join(' · ');
   return {
-    state: { ...state, queuedSubmissions: remaining },
+    state: next,
     sentence: `${label} · ${quoted} · 라이브 턴으로 전송`,
+    matched,
   };
 }
 

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 })));

package/src/cli/brief-cli.ts

@@ -1,9 +1,97 @@
 import type { Command } from 'commander';
 import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_REACTIONS, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority, type BriefReaction, type BriefSendSlot } from '../briefing/brief-items.js';
 import { kindRouteTarget } from '../domains/telegram-kind-route.js';
-import { sendTelegramReturningId } from '../autopilot/mission-notify.js';
+import { sendTelegramButtonsTo, type TgButton } from '../autopilot/mission-notify.js';
 import { getUserConfig } from '../user-config.js';
 
+export function briefFeedbackButtons(ids: readonly number[]): TgButton[][] {
+  return ids.map(id => [
+    { text: `👀 ${id} 읽음`, data: `brief-item:${id}:read` },
+    { text: `✅ ${id} 움직임`, data: `brief-item:${id}:button` },
+    { text: `➖ ${id} 넘김`, data: `brief-item:${id}:ignore` },
+  ]);
+}
+
+export interface BriefTelegramUpdate {
+  botId: string;
+  chatId: number;
+  messageId: number;
+  updateId: string;
+  text?: string;
+  callbackData?: string;
+}
+
+export function recordBriefTelegramUpdate(ledger: BriefItemsLedger, update: BriefTelegramUpdate): boolean {
+  if (update.callbackData !== undefined) {
+    const match = /^brief-item:([1-9]\d*):(read|button|ignore)$/.exec(update.callbackData);
+    if (!match) return false;
+    return ledger.recordTelegramFeedback({ botId: update.botId, chatId: update.chatId,
+      messageId: update.messageId, updateId: update.updateId, itemId: Number(match[1]),
+      reaction: match[2] === 'read' ? '열람' : match[2] === 'ignore' ? '무시' : '버튼' });
+  }
+  if (!update.text?.trim()) return false;
+  const text = update.text.trim();
+  const itemId = /^(?:#|항목\s*)([1-9]\d*)(?=\s|[:：]|$)/.exec(text)?.[1];
+  return ledger.recordTelegramFeedback({ botId: update.botId, chatId: update.chatId,
+    messageId: update.messageId, updateId: update.updateId,
+    ...(itemId ? { itemId: Number(itemId) } : {}),
+    reaction: /그게 아니라|(?:^|\s)정정\s*[:：]/.test(text) ? '정정' : '답장' });
+}
+
+/** Prefix each item line with `#<id>` so the 대표 can name the reply target ("#12 답장", "#12 그게 아니라 …"). */
+function withItemNumbers(text: string, itemLines: ReadonlyMap<string, readonly number[]>): string {
+  const linePositions = new Map<string, number>();
+  return text.split('\n').map(line => {
+    const ids = itemLines.get(line);
+    if (!ids) return line;
+    const position = linePositions.get(line) ?? 0;
+    linePositions.set(line, position + 1);
+    const itemId = ids[position];
+    return itemId === undefined ? line : `#${itemId} ${line}`;
+  }).join('\n');
+}
+
+/** Split only feedback-enabled pages; each Telegram message gets its own real item coordinate.
+ * Item lines carry their `#<id>` so a plain text reply can name its target item.
+ */
+function briefDeliveryParts(markdown: string, itemLines: ReadonlyMap<string, readonly number[]>): Array<{ text: string; itemId: number }> {
+  const parts: Array<{ text: string; itemId: number }> = [];
+  const linePositions = new Map<string, number>();
+  let pending = '';
+  for (const line of markdown.trimEnd().split('\n')) {
+    const ids = itemLines.get(line);
+    const position = linePositions.get(line) ?? 0;
+    const itemId = ids?.[position];
+    if (itemId === undefined) {
+      pending += `${line}\n`;
+      continue;
+    }
+    linePositions.set(line, position + 1);
+    const numbered = `#${itemId} ${line}`;
+    // Leave room for the Telegram sender's newline and keep a button on every fragment.
+    while (pending.length >= 3800) {
+      parts.push({ text: pending.slice(0, 3800), itemId });
+      pending = pending.slice(3800);
+    }
+    let remainder = pending + numbered;
+    do {
+      parts.push({ text: remainder.slice(0, 3800), itemId });
+      remainder = remainder.slice(3800);
+    } while (remainder.length);
+    pending = '';
+  }
+  if (pending && parts.length) {
+    const last = parts[parts.length - 1]!;
+    if (last.text.length + pending.length <= 3800) last.text += pending;
+    else {
+      const room = 3800 - last.text.length;
+      last.text += pending.slice(0, room);
+      for (let i = room; i < pending.length; i += 3800) parts.push({ text: pending.slice(i, i + 3800), itemId: last.itemId });
+    }
+  }
+  return parts;
+}
+
 export interface BriefCliDeps {
   ledger?: BriefItemsLedger;
   stateDir?: string;
@@ -11,6 +99,10 @@ export interface BriefCliDeps {
   output?: (line: string) => void;
   error?: (line: string) => void;
   send?: (markdown: string) => number | null;
+  /** Test seam for the Telegram button sender (one actual message per invocation). */
+  sendWithButtons?: (text: string, buttons: TgButton[][]) => number | null;
+  /** Allows an injected sender to exercise the same Telegram attribution as the real sender. */
+  telegramTarget?: { botToken: string; chatId: number };
 }
 
 export function registerBriefCommands(program: Command, deps: BriefCliDeps = {}): void {
@@ -31,18 +123,47 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
         output(`이번 주 브리핑 중 대표가 움직인 것 ${acted}/${total}`);
       } catch (cause) { fail('', cause); }
     });
-  const deliver = (slot: BriefSendSlot): string => ledger().withSendLock(slot, ({ markdown, ids }, markSent) => {
+  const deliver = (slot: BriefSendSlot): string => ledger().withSendLock(slot, ({ markdown, ids, itemLines }, markSent) => {
     if (ids.length === 0) return '(보낼 항목 없음)';
-    const send = deps.send ?? ((text: string) => {
-      const target = kindRouteTarget(getUserConfig(), 'ops-report');
-      if (!target) return null;
-      return sendTelegramReturningId(target.botToken, target.chatId, text);
-    });
-    const messageId = send(markdown);
-    if (typeof messageId !== 'number' || !Number.isFinite(messageId) || messageId <= 0) {
+    const target = deps.telegramTarget ?? (deps.send ? null : kindRouteTarget(getUserConfig(), 'ops-report'));
+    const numberedMarkdown = withItemNumbers(markdown, itemLines);
+    const oneMessage = numberedMarkdown.length + numberedMarkdown.split('\n').length <= 3900 && ids.length <= 30;
+    const send = (text: string, itemIds: readonly number[]) => deps.sendWithButtons
+      ? deps.sendWithButtons(text, briefFeedbackButtons(itemIds))
+      : deps.send ? deps.send(text)
+      : target ? sendTelegramButtonsTo(target.botToken, target.chatId, text, briefFeedbackButtons(itemIds)) : null;
+    const botId = target ? target.botToken.split(':')[0]! : '';
+    if (target && !oneMessage) {
+      // A sent fragment is not a completed item. Persist only items whose every fragment
+      // succeeded; an incomplete item must remain available to the next send.
+      const parts = briefDeliveryParts(markdown, itemLines);
+      const remainingParts = new Map<number, number>();
+      for (const part of parts) remainingParts.set(part.itemId, (remainingParts.get(part.itemId) ?? 0) + 1);
+      const coordinates: Array<{ botId: string; chatId: number; messageId: number; itemId: number }> = [];
+      let sendThrew = false;
+      let sendCause: unknown;
+      for (const part of parts) {
+        let partMessageId: number | null;
+        try { partMessageId = send(part.text, [part.itemId]); }
+        catch (cause) { sendThrew = true; sendCause = cause; break; }
+        if (typeof partMessageId !== 'number' || !Number.isSafeInteger(partMessageId) || partMessageId <= 0) break;
+        coordinates.push({ botId, chatId: target.chatId, messageId: partMessageId, itemId: part.itemId });
+        remainingParts.set(part.itemId, remainingParts.get(part.itemId)! - 1);
+      }
+      const deliveredIds = [...new Set(coordinates.map(row => row.itemId))].filter(id => remainingParts.get(id) === 0);
+      if (deliveredIds.length > 0) markSent(deliveredIds, slot, coordinates.filter(row => deliveredIds.includes(row.itemId)));
+      if (coordinates.length < parts.length) {
+        if (sendThrew) throw sendCause;
+        throw new Error(`발송 실패: ${deliveredIds.length}/${ids.length} 항목 전송 후 중단 — 나머지는 다음 발송에서 이어진다`);
+      }
+      const lastMessageId = coordinates[coordinates.length - 1]!.messageId;
+      return `sent ${lastMessageId} (${ids.length} items)`;
+    }
+    const messageId = target ? send(numberedMarkdown, ids) : send(markdown, ids);
+    if (typeof messageId !== 'number' || !Number.isSafeInteger(messageId) || messageId <= 0) {
       throw new Error('발송 실패: 양수 메시지 id 없음');
     }
-    markSent(ids, slot);
+    markSent(ids, slot, target ? { botId, chatId: target.chatId, messageId } : undefined);
     return `sent ${messageId} (${ids.length} items)`;
   });
 

package/src/cli/claims-cli.ts

@@ -1,6 +1,7 @@
 import type { Command } from 'commander';
 import { ClaimsInputError, ClaimsLedger, type ClaimsLedgerOptions, type ClaimRow, type ClaimDetail } from '../claims/claims-ledger.js';
 import { renderClaims, queueStaleRechecks, type ClaimSurface } from '../claims/claims-render.js';
+import { PatentLedger, PatentsInputError, type PatentStatus, type PatentTrack } from '../patents/ledger.js';
 
 function actor(explicit?: string): string {
   const by = explicit?.trim() || process.env.AI_AGENT?.trim();
@@ -19,7 +20,7 @@ function handle<Args extends unknown[]>(command: string, action: (...args: Args)
   return (...args) => {
     try { action(...args); }
     catch (error) {
-      if (!(error instanceof ClaimsInputError)) throw error;
+      if (!(error instanceof ClaimsInputError) && !(error instanceof PatentsInputError)) throw error;
       const message = error.message.replace(/\r/g, '\\r').replace(/\n/g, '\\n')
         .replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
       process.stderr.write(`claims ${command}: ${message}\n`);
@@ -41,7 +42,19 @@ function detail(row: ClaimDetail): string {
 export function registerClaimsCommands(program: Command, options: ClaimsLedgerOptions & { instanceRoot?: string } = {}, out: Pick<Console, 'log'> = console): void {
   const root = program.command('claims').description('소구점 · 실측 근거 원장');
   const ledger = () => new ClaimsLedger(options);
+  const patentLedger = () => new PatentLedger(options);
   const emit = (value: unknown, json: boolean | undefined, text: string) => out.log(json ? JSON.stringify(value) : text);
+  const patents = root.command('patents').description('비공개 특허 후보 원장');
+  patents.command('add <id>').requiredOption('--title <title>').requiredOption('--track <track>')
+    .option('--deadline <YYYY-MM-DD>').action(handle('patents add', (id: string, o: { title: string; track: PatentTrack; deadline?: string }) => {
+      const row = patentLedger().add({ id, title: o.title, track: o.track, ...(o.deadline ? { deadline: o.deadline } : {}) });
+      emit(row, false, `${row.id} · ${row.status}`);
+    }));
+  patents.command('status <id>').requiredOption('--status <status>')
+    .action(handle('patents status', (id: string, o: { status: PatentStatus }) => {
+      const row = patentLedger().setStatus(id, o.status);
+      emit(row, false, `${row.id} · ${row.status}`);
+    }));
   root.command('add <id>').requiredOption('--claim <text>').requiredOption('--audience <list>').requiredOption('--owner <seat>')
     .option('--contrast <text>').action(handle('add', (id: string, o: { claim: string; audience: string; owner: string; contrast?: string }) => {
       const row = ledger().add({ id, claim: o.claim, audience: o.audience, owner: o.owner, ...(o.contrast ? { contrast: o.contrast } : {}) });
@@ -79,9 +92,16 @@ export function registerClaimsCommands(program: Command, options: ClaimsLedgerOp
     emit(row, o.json, detail(row));
   }));
   root.command('render').requiredOption('--surface <surface>', 'deck | site | notice')
-    .option('--audience <audience>').option('--json')
-    .action(handle('render', (o: { surface: ClaimSurface; audience?: string; json?: boolean }) => {
-      const result = renderClaims(ledger(), { surface: o.surface, ...(o.audience ? { audience: o.audience } : {}) });
+    .option('--audience <audience>').option('--include-patents', '명시적으로 공개 허용 특허 후보를 포함')
+    .option('--patent-owner <owner>', '특허 후보의 확인된 담당').option('--json')
+    .action(handle('render', (o: { surface: ClaimSurface; audience?: string; includePatents?: boolean; patentOwner?: string; json?: boolean }) => {
+      if (o.includePatents && (!o.patentOwner?.trim() || !o.audience?.trim())) {
+        throw new ClaimsInputError('--include-patents requires --patent-owner and --audience');
+      }
+      if (!o.includePatents && o.patentOwner) throw new ClaimsInputError('--patent-owner requires --include-patents');
+      const patents = o.includePatents
+        ? { ledger: patentLedger(), owner: o.patentOwner!, audience: o.audience! } : undefined;
+      const result = renderClaims(ledger(), { surface: o.surface, ...(o.audience ? { audience: o.audience } : {}), ...(patents ? { patents } : {}) });
       // Review follow-up: rendering is where stale claims surface — queue their re-measurement in the same act.
       const rechecks = result.excluded.some(item => item.reason === 'stale')
         ? queueStaleRechecks(ledger(), { root: options.instanceRoot, now: options.now?.() }) : 0;

package/src/cli/dashboard-name-flag.ts

@@ -0,0 +1,48 @@
+// `elanous --name <name>` — 맨 `elanous`(대시보드 TUI)가 자기 PTY manifest 행(`tui:<pid>`)에
+// 별명을 달고 뜬다. 그러면 `elanous pty list` 에 그 이름이 보이고 `pty snapshot <name>` ·
+// `pty text <name> …` 가 별명으로 해석된다(ref 해석은 이미 nickname 을 받는다).
+//
+// ⭐ 루트 «실행» 플래그다 — `--resume`·`--debug` 와 같은 규칙으로 Commander «전»에 걷어낸다.
+// ⛔ 하위 명령 «뒤»의 `--name`(`elanous pty list --name x` · `elanous --debug session new --name x`)은 건드리지 않는다 — 그 명령이 `--name` 을
+//    자기 옵션으로 가질 수 있다(가로채면 조용히 그 옵션을 먹는다).
+
+import { ROOT_FLAGS_TAKING_VALUE } from './remote-resolve.js';
+
+export interface DashboardNameFlag {
+  /** 걷어낸 뒤의 인자 — Commander·대시보드 필터로 넘긴다. */
+  readonly args: string[];
+  /** 준 이름(앞뒤 공백 제거). 플래그가 없으면 undefined. */
+  readonly name?: string;
+  /** 값이 없거나 빈 이름이면 사람에게 낼 오류 문면. */
+  readonly error?: string;
+}
+
+/** 루트 «선행 플래그 구간»에서 값을 받는 플래그 — 그 값 토큰은 하위 명령이 아니다. */
+const LEADING_VALUE_FLAGS = new Set([...ROOT_FLAGS_TAKING_VALUE, '--resume']);
+
+/** 루트 선행 플래그 구간 안의 `--name` 위치. 하위 명령(맨 위치 인자)이나 `--` 를 만나면 멈춘다 —
+ *  `elanous --debug session new --name x` 의 `--name` 은 그 하위 명령의 것이다(리뷰 must-fix). */
+function leadingNameIndex(rawArgs: readonly string[]): number {
+  for (let i = 0; i < rawArgs.length; i += 1) {
+    const arg = rawArgs[i]!;
+    if (arg === '--' || !arg.startsWith('-')) return -1;
+    if (arg === '--name' || arg.startsWith('--name=')) return i;
+    if (LEADING_VALUE_FLAGS.has(arg)) i += 1;
+  }
+  return -1;
+}
+
+export function readDashboardNameFlag(rawArgs: readonly string[]): DashboardNameFlag {
+  const idx = leadingNameIndex(rawArgs);
+  if (idx < 0) return { args: [...rawArgs] };
+  const flag = rawArgs[idx]!;
+  const inline = flag.startsWith('--name=');
+  const value = inline ? flag.slice('--name='.length) : rawArgs[idx + 1];
+  const args = rawArgs.filter((_, i) => i !== idx && (inline || i !== idx + 1));
+  if (value === undefined || (!inline && value.startsWith('-'))) {
+    return { args: rawArgs.filter((_, i) => i !== idx), error: 'elanous: --name needs a value (e.g. elanous --name op)' };
+  }
+  const name = value.trim();
+  if (!name) return { args, error: 'elanous: --name must not be empty' };
+  return { args, name };
+}