elanous 0.2.27 → 0.2.28

package/scripts/verify-kpack6-live.ts

@@ -0,0 +1,230 @@
+// KPACK6 — 선택 실행 운영 스모크 (읽기 전용)
+//
+// #25780 으로 두 공개 표본 팩의 서명 설치·CLI KnowledgeQuery·그래프 검색 인용은 착지했다.
+// 이 스크립트는 그 다음 칸이다: 설치된 두 팩에 대해 실제 CLI 채팅 LLM 답변이
+// 팩 출처(`slug@version#cardId`)를 인용하는지 확인한다.
+//
+//   팩 미설치 / LLM 호출 불가 / 스토어 오류  → 미측정 (실패 아님)
+//   답변은 왔으나 팩 출처 인용 없음          → 실패
+//   두 팩 모두 인용 답변 실물 확보 전까지    → green 금지
+//
+// 실행: KPACK6_LIVE=1 bun scripts/verify-kpack6-live.ts
+// CLI 명령은 KPACK6_AGENT_CMD 로 바꿀 수 있다(기본 `bun bin/elanous.mjs agent --new --json`).
+
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { listInstalledPacks, queryInstalledPack } from '../src/knowledge/query.js';
+
+export const KPACK6_TARGET_SLUGS = ['semiconductor-process-public', 'b2b-sales-public'] as const;
+
+export type Kpack6PackStatus =
+  | 'pack-not-installed'
+  | 'pack-unreadable'
+  | 'llm-unavailable'
+  | 'llm-timeout'
+  | 'cli-contract-error'
+  | 'citation-missing'
+  | 'cited';
+
+export type Kpack6PackResult = {
+  slug: string;
+  packId: string | null;
+  status: Kpack6PackStatus;
+  measured: boolean;
+  question?: string;
+  reply?: string;
+  ref?: string;
+  reason?: string;
+};
+
+export type Kpack6SmokeStatus = 'green' | 'fail' | 'not-measured' | 'skipped';
+
+export type Kpack6SmokeReport = {
+  status: Kpack6SmokeStatus;
+  reason?: string;
+  packs: Kpack6PackResult[];
+  generatedAt: string;
+};
+
+export type Kpack6Deps = {
+  installedPacks?: () => Array<{ id: string; title: string }>;
+  queryTopCard?: (packId: string) => { id: string; title: string; ref: string };
+  ask?: (question: string) => Promise<{ reply: string }>;
+  env?: Record<string, string | undefined>;
+};
+
+const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** 설치된 팩에서 조회한 바로 그 카드의 ref만 인용으로 인정한다. */
+export function packCitationIn(reply: string, expectedRef: string): string | null {
+  const exactRef = new RegExp(`(?<![\\w./@#-])${escapeRegExp(expectedRef)}(?=$|[^\\w./@#-])`);
+  return exactRef.test(reply) ? expectedRef : null;
+}
+
+function defaultQueryTopCard(packId: string): { id: string; title: string; ref: string } {
+  const hits = queryInstalledPack(packId, '');
+  if (hits.length === 0) throw new Error(`팩에 카드가 없다: ${packId}`);
+  return { id: hits[0].id, title: hits[0].title, ref: hits[0].ref };
+}
+
+export class Kpack6CliContractError extends Error {}
+export class Kpack6LlmTimeoutError extends Error {}
+
+function isProviderUnavailable(stderr: string): boolean {
+  return /No LLM provider available|usage_limit_reached|(?:^|\W)429(?:\W|$)/i.test(stderr);
+}
+
+export async function askViaCli(question: string, env: Record<string, string | undefined>): Promise<{ reply: string }> {
+  const argv = (env.KPACK6_AGENT_CMD ?? 'bun bin/elanous.mjs agent --new --json').split(/\s+/);
+  const timeoutMs = Number(env.KPACK6_TIMEOUT_MS ?? 180_000);
+  return await new Promise((resolve, reject) => {
+    const child = spawn(argv[0], [...argv.slice(1), question], {
+      cwd: REPO_ROOT, env: { ...process.env, ...env }, stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGKILL');
+    }, timeoutMs);
+    child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+    child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(new Kpack6CliContractError(`agent CLI 실행 실패 — ${err.message}`));
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        reject(new Kpack6LlmTimeoutError(`agent CLI LLM 응답 시간 초과 (${timeoutMs}ms)`));
+        return;
+      }
+      const jsonLine = stdout.split('\n').filter((line) => line.trim().startsWith('{')).pop();
+      if (code !== 0) {
+        const message = `agent CLI exit=${code} stderr=${stderr.slice(0, 300)}`;
+        reject(isProviderUnavailable(stderr) ? new Error(message) : new Kpack6CliContractError(message));
+        return;
+      }
+      if (!jsonLine) {
+        reject(new Kpack6CliContractError('agent CLI 성공 출력에 JSON 객체가 없다'));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(jsonLine) as { reply?: unknown };
+        if (typeof parsed.reply !== 'string' || parsed.reply.trim() === '') {
+          reject(new Kpack6CliContractError('agent CLI 응답에 reply 문자열이 없다'));
+          return;
+        }
+        resolve({ reply: parsed.reply });
+      } catch (err) {
+        reject(err instanceof Kpack6CliContractError
+          ? err : new Kpack6CliContractError(`agent CLI 출력 JSON 파싱 실패 — ${(err as Error).message}`));
+      }
+    });
+  });
+}
+
+export function kpack6ExitCode(report: Kpack6SmokeReport): number {
+  switch (report.status) {
+    case 'green': return 0;
+    case 'fail': return 1;
+    case 'skipped': return 3;
+    default: return 4;
+  }
+}
+
+export async function runKpack6LiveSmoke(deps: Kpack6Deps = {}): Promise<Kpack6SmokeReport> {
+  const env = deps.env ?? process.env;
+  const generatedAt = new Date().toISOString();
+
+  if (env.KPACK6_LIVE !== '1') {
+    return {
+      status: 'skipped',
+      reason: '선택 실행 스모크다: KPACK6_LIVE=1 없이는 돌지 않는다 (두 팩 인용 답변 실물 1회 전까지 green 금지)',
+      packs: [],
+      generatedAt,
+    };
+  }
+
+  const ask = deps.ask ?? ((question: string) => askViaCli(question, env));
+  let installed: Array<{ id: string; title: string }>;
+  try {
+    installed = deps.installedPacks?.() ?? listInstalledPacks();
+  } catch (err) {
+    return {
+      status: 'not-measured',
+      reason: `KGS 스토어 조회 불가 — ${(err as Error).message}`,
+      packs: KPACK6_TARGET_SLUGS.map((slug) => ({
+        slug, packId: null, status: 'pack-unreadable' as const, measured: false,
+        reason: `스토어 오류: ${(err as Error).message}`,
+      })),
+      generatedAt,
+    };
+  }
+
+  const packs: Kpack6PackResult[] = [];
+  for (const slug of KPACK6_TARGET_SLUGS) {
+    const match = installed.find((pack) => pack.id === slug || pack.id.startsWith(`${slug}@`));
+    if (!match) {
+      packs.push({
+        slug, packId: null, status: 'pack-not-installed', measured: false,
+        reason: 'KGS 스토어에 설치된 팩이 없다 (미측정)',
+      });
+      continue;
+    }
+    const packId = match.id;
+
+    let top: { id: string; title: string; ref: string };
+    try {
+      top = deps.queryTopCard?.(packId) ?? defaultQueryTopCard(packId);
+    } catch (err) {
+      packs.push({
+        slug, packId, status: 'pack-unreadable', measured: false,
+        reason: `설치됐으나 카드 조회 불가 — ${(err as Error).message}`,
+      });
+      continue;
+    }
+
+    const question = `설치된 ${packId} (${match.title}) 팩의 «${top.title}» 카드를 지식 조회 도구로 읽고 요약하라. 답변에 카드 제목을 쓰고, 도구가 반환한 출처를 그대로 인용해 붙여라. 출처를 추측하지 마라.`;
+    let reply: string;
+    try {
+      reply = (await ask(question)).reply;
+    } catch (err) {
+      const contractError = err instanceof Kpack6CliContractError;
+      const timeoutError = err instanceof Kpack6LlmTimeoutError;
+      packs.push({
+        slug, packId, status: contractError ? 'cli-contract-error' : timeoutError ? 'llm-timeout' : 'llm-unavailable',
+        measured: false, question,
+        reason: `${contractError ? 'CLI JSON 계약 오류' : timeoutError ? 'LLM 응답 시간 초과' : 'CLI 채팅 LLM 호출 불가'} — ${(err as Error).message}`,
+      });
+      continue;
+    }
+
+    const ref = packCitationIn(reply, top.ref);
+    if (ref && reply.includes(top.title)) {
+      packs.push({ slug, packId, status: 'cited', measured: true, question, reply, ref });
+    } else {
+      packs.push({
+        slug, packId, status: 'citation-missing', measured: true, question, reply,
+        reason: '답변은 왔으나 조회한 설치 카드의 제목과 정확한 출처 인용이 함께 없다 — 실패',
+      });
+    }
+  }
+
+  const failed = packs.some((pack) => pack.status === 'citation-missing' || pack.status === 'cli-contract-error');
+  const allCited = packs.length > 0 && packs.every((pack) => pack.status === 'cited');
+  const status: Kpack6SmokeStatus = failed ? 'fail' : allCited ? 'green' : 'not-measured';
+  return { status, packs, generatedAt };
+}
+
+if (import.meta.main) {
+  const report = await runKpack6LiveSmoke();
+  console.log(JSON.stringify(report, null, 2));
+  process.exit(kpack6ExitCode(report));
+}

package/src/acp/codex-plugins.ts

@@ -43,6 +43,23 @@ export interface FetchCodexPluginsOpts {
   noCache?: boolean;
 }
 
+/** Read the full inventory for an explicit package import. Unlike the chip projector, this keeps
+ *  the package location and never substitutes a stale cached inventory after an RPC failure. */
+export async function readCodexPluginList(
+  spawn: typeof spawnCodexAppServer = spawnCodexAppServer,
+): Promise<unknown> {
+  const server = spawn({ requestTimeoutMs: 5000 });
+  try {
+    await server.client.request('initialize', {
+      clientInfo: { name: 'elanous', version: '0.x' }, capabilities: { experimentalApi: true },
+    });
+    return await server.client.request<Record<string, never>, unknown>('plugin/list', {});
+  } finally {
+    try { await server.client.close(); }
+    finally { server.child.kill(); }
+  }
+}
+
 /** Uncached inventory probe: distinguish no session / RPC failure from an empty installed list. */
 export async function readCodexPluginsObservation(client: CodexAppServerClient | null | undefined): Promise<
   { status: 'ok'; plugins: ReadonlyArray<CodexPlugin> } | { status: 'unknown'; plugins: readonly [] }

package/src/agent/task-notification.ts

@@ -223,7 +223,8 @@ function escapeXml(s: string): string {
   return s
     .replace(/&/g, '&')
     .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
 }
 
 function formatDuration(ms: number): string {

package/src/agent-mission/in-agent-plugin.ts

@@ -2,7 +2,8 @@ import type { PtyHandle } from '../pty-shell/registry.js';
 import { classifierFrameLines } from '../capture/frame-state-detect.js';
 import { emitDecision, type DecisionEvent } from '../live/detail-switch.js';
 import { debug } from '../debug/log.js';
-import { streamLLM, type LLMMessage } from '../llm.js';
+import * as llm from '../llm.js';
+import { resolveRoleLlm } from '../user-config.js';
 
 export interface PluginRequest { agent: 'codex' | 'claude'; plugin: string; marketplace: string }
 export type PluginResult = { outcome: 'installed' } | { outcome: 'escalate'; reason: 'plugins-disabled' | 'unknown-menu' | 'timeout' | 'wrong-target' | 'credentials' };
@@ -103,11 +104,15 @@ export async function installPluginInsideAgent(request: PluginRequest, pty: Pick
       ? ['[credential screen]']
       : lines(screen).slice(-10).map(line => line.slice(0, 160));
   const brain = deps.brain ?? (async (screen: string, target: string) => {
-    const messages: LLMMessage[] = [
+    const messages: llm.LLMMessage[] = [
       { role: 'system', content: 'You navigate a plugin menu using only up/down/tab/enter/wait/unknown. Return exactly one of those words. Do not choose enter unless the requested plugin@marketplace is visibly selected. Never enter credentials.' },
       { role: 'user', content: `Target: ${target}\nScreen:\n${screen.slice(-3500)}` },
     ];
-    const answer = (await streamLLM(messages, () => {}, { maxTokens: 20 })).trim().toLowerCase();
+    const resolved = resolveRoleLlm('classify');
+    const provider = llm.PROVIDERS[resolved.provider];
+    if (!provider) throw new Error(`Unknown classify provider: ${resolved.provider}`);
+    debug.log('llm.role-pin', 'resolved', { site: 'in-agent-plugin', role: 'classify', model: resolved.model, provider: resolved.provider, source: resolved.source });
+    const answer = (await llm.streamLLM(messages, () => {}, { model: resolved.model, provider, usageRole: 'classify', maxTokens: 20 })).trim().toLowerCase();
     return /^(up|down|tab|enter|wait)$/.test(answer) ? answer as 'up' | 'down' | 'tab' | 'enter' | 'wait' : 'unknown';
   });
   const target = `${request.plugin}@${request.marketplace}`;

package/src/agent-substrate/self-review-cli.ts

@@ -14,9 +14,10 @@
 //
 // index.ts 의 액션은 옵션 파싱과 실제 의존 배선만 남는다(얇은 껍데기).
 
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { tierModel } from '../llm/model-defaults.js';
 import { buildReviewObservation, safeLogText } from './review-observation.js';
 import { DEFAULT_REVIEW_BACKEND } from './acp-reviewer.js';
@@ -46,6 +47,8 @@ export interface SelfReviewCliOpts {
   contextText?: string[] | undefined;
   contextOrder?: Array<{ kind: 'file' | 'text'; value: string }> | undefined;
   json?: boolean | undefined;
+  /** Save completed reviews under the task-agent state's review-results directory. */
+  save?: string | undefined;
 }
 
 /** 셸/네트워크/로그 경계 — 테스트는 전부 대역으로 채운다. */
@@ -1276,6 +1279,11 @@ async function runSelfReviewCliCommandPinned(
     return { results: [], failed: 0 };
   }
 
+  if (opts.save !== undefined && !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(opts.save)) {
+    deps.error('--save 이름은 영문자·숫자로 시작하고 영문자·숫자·점·밑줄·하이픈만 포함해야 합니다.');
+    return { results: [], failed: 1 };
+  }
+
   const useAcp = opts.acp === true;
   const acpModel = opts.acpModel?.trim() || undefined;
   const acpBackendResolution = opts.acpBackend
@@ -1431,8 +1439,8 @@ async function runSelfReviewCliCommandPinned(
         { pr: safeLogText(pr), exit: diff.status, error: safeLogText(diff.stderr || err, 160) },
         { level: 'warn' });
       const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
-      if (opts.json) results.push({ pr, error: err, ...contextOutput, ...comparisonData, ...(mismatchWarning ?? {}) });
-      else deps.error(`PR ${pr}: ${err}\n${reviewerContextStatus}`);
+      if (opts.json || opts.save !== undefined) results.push({ pr, error: err, ...contextOutput, ...comparisonData, ...(mismatchWarning ?? {}) });
+      if (!opts.json) deps.error(`PR ${pr}: ${err}\n${reviewerContextStatus}`);
       failed += 1;
       continue;
     }
@@ -1492,8 +1500,8 @@ async function runSelfReviewCliCommandPinned(
         pr, model: primaryModel, verdict: null, mustFix: [], shouldFix: [], reviewed: false,
         refusal: 'stale-head', ...provenance, ...reviewerSourceObservation(), ...contextOutput,
       };
-      if (opts.json) results.push(refused);
-      else deps.print(`\n━━ PR ${pr} (${primaryModel}) ━━\n${renderStaleRefusal(diffRead)}\n${reviewerContextStatus}`);
+      if (opts.json || opts.save !== undefined) results.push(refused);
+      if (!opts.json) deps.print(`\n━━ PR ${pr} (${primaryModel}) ━━\n${renderStaleRefusal(diffRead)}\n${reviewerContextStatus}`);
       continue;
     }
     // ⭐ 머지된 PR 만 머지 커밋 detached worktree 에서 리뷰한다 — main 최신이 아니라 그 PR 이 머지된 시점의 코드를 본다.
@@ -1666,17 +1674,33 @@ async function runSelfReviewCliCommandPinned(
     if (useAcp && review.reviewed === false) {
       const err = 'ACP 리뷰 실행 실패(reviewed=false) — 관측: elanous logs --category acp-review';
       const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
-      if (opts.json) results.push({ pr, error: err, ...review, verdict: null, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...reviewCwdOutput, ...provenance, ...contextOutput });
-      else deps.error(`PR ${pr}: ${err}\n${renderProvenance(diffRead)}\n${reviewerContextStatus}`);
+      if (opts.json || opts.save !== undefined) results.push({ pr, error: err, ...review, verdict: null, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...reviewCwdOutput, ...provenance, ...contextOutput });
+      if (!opts.json) deps.error(`PR ${pr}: ${err}\n${renderProvenance(diffRead)}\n${reviewerContextStatus}`);
       failed += 1;
       continue;
     }
     const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
     const jsonReview = review.reviewed === true ? review : { ...review, verdict: null };
-    if (opts.json) results.push({ pr, model: selectedModel, ...jsonReview, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...reviewCwdOutput, ...provenance, ...contextOutput, evidence: evidence.evidence, prDiffFiles: evidence.prDiffFiles, ...(evidence.authoredFiles !== undefined ? { authoredFiles: evidence.authoredFiles } : {}) });
-    else deps.print(`\n━━ PR ${pr} (${selectedModel}) ━━\n${renderProvenance(diffRead)}\n${evidenceLine}\n${reviewerContextStatus}\n${deps.renderReview(review)}`);
+    if (opts.json || opts.save !== undefined) results.push({ pr, model: selectedModel, ...jsonReview, ...reviewProvenance, ...respondedOutput, ...reviewerSelection, ...reviewCwdOutput, ...provenance, ...contextOutput, evidence: evidence.evidence, prDiffFiles: evidence.prDiffFiles, ...(evidence.authoredFiles !== undefined ? { authoredFiles: evidence.authoredFiles } : {}) });
+    if (!opts.json) deps.print(`\n━━ PR ${pr} (${selectedModel}) ━━\n${renderProvenance(diffRead)}\n${evidenceLine}\n${reviewerContextStatus}\n${deps.renderReview(review)}`);
     // REVIEW-ERROR-RC — 기본(API)·role 경로가 1차·폴백 모두 실패해 reviewed≠true 로 끝나도 «못 리뷰한 PR» 이다(verdict:null).
     if (review.reviewed !== true) failed += 1;
+    if (opts.save !== undefined) {
+      if (review.reviewed !== true || diffRead.headCommitState !== 'known' || diffRead.currentHeadCommitState !== 'known' || diffRead.currentHeadCommit !== diffRead.headCommit || diffRead.headCommit.length !== 40) {
+        deps.error(`PR ${pr}: --save 불가 — 완료된 리뷰와 확인된 40자 PR head가 필요합니다.`);
+        if (review.reviewed === true) failed += 1;
+      } else {
+        const path = join(effectiveInstanceRoot(), 'review-results', `${opts.save}-${pr}-${diffRead.headCommit.slice(0, 12)}.json`);
+        const result = results.at(-1);
+        try {
+          mkdirSync(dirname(path), { recursive: true });
+          writeFileSync(path, selfReviewJsonLine([result]));
+        } catch (error) {
+          failed += 1;
+          deps.error(`PR ${pr}: --save 실패: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
   }
   return { results, failed };
 }

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