elanous 0.2.27 → 0.2.29

package/src/agent-substrate/pr-reviewer.ts

@@ -652,6 +652,9 @@ export function buildReviewPrompt(
  *  `none of the tests …`. 표지 낱말로 시작하는 실제 블로커를 지우면 PASS/WARN 리뷰에서 블로커가 사라진다. */
 const NONE_WORD = String.raw`(?:없음|해당\s*없음|n\/a|none|nothing)`;
 const BARE_SENTINEL = new RegExp(String.raw`^${NONE_WORD}\s*[.。]?$`, 'i');
+const DASH_ONLY_SENTINEL = /^[([（【]\s*[-—–]\s*[)\]）】]$/;
+// 목록 항목의 바깥 `- `와 별개로, 리뷰어가 괄호 안에도 장식 대시를 둘 수 있다: `- (- 없음 -)`.
+const DASH_WRAPPED_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*(?:[-—–]+\s*)?${NONE_WORD}\s*(?:[-—–]+\s*)?[)\]）】]$`, 'i');
 const BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*${NONE_WORD}(?:\s*[—–\-:.,;·]\s*([^)\]）】]*))?\s*[)\]）】]$`, 'i');
 // ⭐ 설명 «전체»가 「지적 없음」 한 문장일 때만 — 일부만 맞아도 접으면 `(none: no blockers are checked because …)` 같은 지적이 사라진다.
 const NO_FINDING_REMARK = new RegExp([
@@ -662,41 +665,38 @@ const NO_FINDING_REMARK = new RegExp([
   String.raw`^수용\s*기준(?:을|이)?\s*(?:(?:모두|전부)\s*)?충족(?:함|됨|했다|합니다)?[.。]?$`,
   String.raw`^(?:all\s+)?acceptance\s+criteria\s+(?:are\s+)?(?:all\s+)?met\.?$`,
 ].join('|'), 'i');
-// REVIEW-MUSTFIX-NONE-SENTINEL 후속 — GLM 이 괄호 안에 «무소견 머리 + 긴 근거»를 쓴다(10-11 TC `pr land` 가 `review-must-fix-1` 로 거부):
-//   `(없음 — 수용기준 충족: 머리말에 … 반영됨 …)` · `(없음 — 수용기준 3항 모두 충족: … (\`'failed'\` 반환) · …)`(근거 안에 괄호가 또 있다).
-//   ⭐ 길이 무관 0 은 «머리»가 무소견 서술이고 바로 구분자가 올 때만 — 머리가 결함 서술이면(`(없음 — 하지만 X 가 깨진다)`) 지적으로 남긴다.
-//   ⛔ 근거에 역접·미충족(`하지만`·`다만`·`미충족`·`but`·`except`·`not met` …)이 있으면 보수적으로 지적으로 남긴다.
-const LONG_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*${NONE_WORD}\s*[—–\-:·]\s*([\s\S]+?)\s*[)\]）】]$`, 'i');
-const NO_FINDING_HEAD = new RegExp('^(?:' + [
-  String.raw`수용\s*기준(?:\s*\d+\s*(?:항|개|건)(?:목)?)?(?:을|이)?\s*(?:(?:모두|전부)\s*)?충족(?:함|됨|했다|합니다)?`,
-  String.raw`(?:all\s+)?acceptance\s+criteria\s+(?:are\s+)?(?:all\s+)?met`,
-  String.raw`must-?fix\s*(?:항목)?(?:은|는|이|가)?\s*(?:없(?:음|다|습니다)|0\s*건)`,
-  String.raw`(?:no|zero)\s+(?:blocking\s+)?(?:blockers?|must-?fix(?:es)?)(?:\s+found)?`,
-  String.raw`(?:(?:블로커|차단)\s*)?(?:수준의?\s*)?(?:결함|블로커)(?:은|는|이|가)?\s*(?:발견되지\s*않(?:음|았(?:다|습니다)?)|없(?:음|다|습니다))`,
-].join('|') + String.raw`)\s*(?:[:：—–\-·,;.。(]|$)`, 'i');
-const LONG_REMARK_DISSENT = /하지만|그러나|다만|(?<![가-힣])단(?:,|\s)|미\s*충족|불\s*충족|충족하지|충족되지|\bbut\b|\bhowever\b|\bexcept\b|\balthough\b|\bnot\s+(?:yet\s+)?met\b|\bunmet\b/i;
-/** 괄호 안이 «없음 + 구분자 + 무소견 머리 …» 인가 — 길이 무관(근거 안 괄호도 허용). `isNoneSentinelFinding` 의 갈래. */
+// OP #3173 — 설명은 의미 추정하지 않는다. 실측으로 무소견임을 확인한 문장만 등록한다.
+// 문법 밖 `없음 — 설명`은 실제 결함일 수 있으므로 mustFix에 남긴다.
+const LONG_BRACKETED_SENTINEL = new RegExp(String.raw`^[([（【]\s*(?:[-—–]+\s*)?${NONE_WORD}\s*[—–\-:·]\s*([\s\S]+?)\s*[)\]）】]$`, 'i');
+const KNOWN_NO_FINDING_REMARKS = new Set([
+  // #27349 저장 JSON의 실제 무소견 문구.
+  '문서 전용 변경이고 의도된 산출물이 실제로 존재하며 배선 누락·죽은 코드·Goodhart 해당 없음',
+]);
+/** 괄호 안 `없음` 뒤 설명이 닫힌 무소견 문법에 정확히 들어가는가. */
 function isLongNoFindingBracket(text: string): boolean {
   const m = LONG_BRACKETED_SENTINEL.exec(text.trim());
   if (!m) return false;
   const remark = m[1]!.trim();
-  return NO_FINDING_HEAD.test(remark) && !LONG_REMARK_DISSENT.test(remark);
+  const bareRemark = remark.replace(/\s*[-—–]+\s*$/, '').trim();
+  return NO_FINDING_REMARK.test(bareRemark) || KNOWN_NO_FINDING_REMARKS.has(bareRemark);
 }
 /** must-fix 항목이 «지적 없음» 표지인가 — must-fix 를 세는 자리는 전부 `parseReviewResult` 를 거친다
  *  (`self review --json` 의 `mustFix` → TA `parseReviewResultOutput` → `pr land --overlap-evidence` 의 `review-must-fix-N`).
  *  ⭐ export — `parseReviewResultOutput` 가 «같은» 판정으로 저장된 결과의 표지 줄을 다시 접는다(PR-LAND-MUSTFIX-NONE · 복제 금지). */
 export function isNoneSentinelFinding(finding: string): boolean {
   const text = finding.trim();
-  if (BARE_SENTINEL.test(text)) return true;
-  const bracketed = BRACKETED_SENTINEL.exec(text);
+  if (/^[-—–]+$/.test(text)) return true;
+  const markerText = text.replace(/^[—–-]+\s*|\s*[—–-]+$/g, '').trim();
+  if (markerText && (BARE_SENTINEL.test(markerText) || DASH_ONLY_SENTINEL.test(markerText) || DASH_WRAPPED_BRACKETED_SENTINEL.test(markerText))) return true;
+  const bracketed = BRACKETED_SENTINEL.exec(markerText);
   if (bracketed) {
     const remark = bracketed[1]?.trim();
     if (!remark || NO_FINDING_REMARK.test(remark)) return true;
   }
-  return isLongNoFindingBracket(text);
+  return isLongNoFindingBracket(markerText);
 }
 
-/** critic 응답 파싱 → ReviewResult. 순수함수. VERDICT + MUST-FIX/SHOULD-FIX/REQUIREMENTS 섹션 분해.
+/** critic 응답 파싱 → ReviewResult. VERDICT + MUST-FIX/SHOULD-FIX/REQUIREMENTS 섹션 분해.
  *  verdict=FAIL 인데 must-fix 미기재면 첫 finding 을 must 로 승격(블로커 근거 보존). */
 /** ⭐ `VERDICT: PASS|WARN|FAIL` 판정 줄 — `parseReviewResult` 와 `reviewedResultFromRaw` 가 «같은» 정규식을 쓴다(존재 판정이 갈리면 안 된다). */
 const VERDICT_LINE = /VERDICT:\s*(PASS|WARN|FAIL)/i;
@@ -709,6 +709,7 @@ export function parseReviewResult(text: string): ReviewResult {
   const shouldFix: string[] = [];
   const requirements: string[] = [];
   let fallbackFinding: string | undefined;
+  let droppedNonePlaceholders = 0;
   let section: 'must' | 'should' | 'requirements' | null = null;
   for (const l of lines) {
     if (/^MUST-?FIX/i.test(l)) { section = 'must'; continue; }
@@ -718,12 +719,19 @@ export function parseReviewResult(text: string): ReviewResult {
     if (l.startsWith('- ')) {
       const f = l.slice(2).trim();
       if (!f) continue;
-      if (section === 'must') { if (!isNoneSentinelFinding(f)) mustFix.push(f); }
-      else if (section === 'should') shouldFix.push(f);
+      if (section === 'must') {
+        if (isNoneSentinelFinding(f)) droppedNonePlaceholders++;
+        else mustFix.push(f);
+      } else if (section === 'should') shouldFix.push(f);
       else if (section === 'requirements') requirements.push(f);
       else fallbackFinding ??= f;
     }
   }
+  if (droppedNonePlaceholders > 0) {
+    try {
+      debug.log('review.parse', 'none-placeholder-dropped', { count: droppedNonePlaceholders });
+    } catch { /* observation must not change parsed review data */ }
+  }
   if (verdict === 'fail' && mustFix.length === 0) {
     const first = shouldFix.shift() ?? fallbackFinding;
     mustFix.push(first ?? 'PR 리뷰 FAIL — 재작업 필요(구체 지적 미파싱).');

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

package/src/budget/llm-cost.ts

@@ -303,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`) — 카탈로그 추정과 다르면 이것이 맞다. */
@@ -323,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/pty-usage-reemit.ts

@@ -12,6 +12,10 @@ export interface PtyUsageReemitOpts {
   readonly workdir: string;
   /** Codex session UUID observed from this child PTY; empty when unavailable (emit nothing). */
   readonly sessionId: string;
+  /** Caller-observed metadata only. Never infer a Codex account from CODEX_HOME. */
+  readonly role?: string;
+  readonly stage?: string;
+  readonly account?: string;
   /** Child start time: do not attribute older sessions in a shared CODEX_HOME to this child. */
   readonly sinceMs?: number;
   /** Override the dedup ledger location in isolated tests. */
@@ -40,6 +44,9 @@ export function reemitPtyUsage(opts: PtyUsageReemitOpts): number {
       if (Number(insert.run(home, turn.turnId).changes) === 0) continue;
       debug.log('llm.usage', 'llm-usage', {
         runId: opts.runId,
+        ...(opts.role !== undefined ? { role: opts.role } : {}),
+        ...(opts.stage !== undefined ? { stage: opts.stage } : {}),
+        ...(opts.account !== undefined ? { account: opts.account } : {}),
         substrate: 'pty',
         site: 'pty-rollup:codex',
         turnId: turn.turnId,

package/src/budget/run-usage-rollup.ts

@@ -16,6 +16,15 @@ export interface RunUsageInput {
   cost?: { kind?: string; usd?: number; apiEquivalentUsd?: number } | null;
 }
 
+/** A returned Pod raw usage row is covered only by a measured rollup from the same Job. */
+export function excludeCoveredPodRawRows<T extends { origin?: unknown; podJob?: unknown; job?: unknown; site?: unknown; measured?: unknown }>(rows: readonly T[]): T[] {
+  const rolledUpJobs = new Set(rows.flatMap((row) =>
+    typeof row.job === 'string' && row.job.length > 0
+      && typeof row.site === 'string' && row.site.startsWith('pod-rollup:')
+      && row.site !== 'pod-rollup:missing' && row.measured !== false ? [row.job] : []));
+  return rows.filter((row) => row.origin !== 'pod' || typeof row.podJob !== 'string' || !rolledUpJobs.has(row.podJob));
+}
+
 export interface RunUsageRow {
   runId: string;
   role?: string;