elanous 0.2.9 → 0.2.11

package/src/intake-plane/author-goals.ts

@@ -2,7 +2,8 @@
  * intake check → 골 저작 연결. 판정 「없음」마다 기존 골 중복을 먼저 보고, 없으면 골 저작기로 골 문서를 쓰고 lint 한 뒤 멈춘다.
  * 하니스는 발사하지 않는다. 골: 내부 문서 `ASK-intake-check-authors-goals-for-gaps-2026-09-24`
  */
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { CardStore, taskCardsDir } from '../task-cards/card-store.js';
 import { join, relative } from 'node:path';
 import { debug } from '../debug/log.js';
 import { resolveGoalDocumentsDir } from '../self-implement/goal-documents-dir.js';
@@ -42,7 +43,22 @@ function defaultGoalDocs(root: string): { path: string; text: string }[] {
     .map((name) => ({ path: relative(root, join(dir, name)), text: readFileSync(join(dir, name), 'utf8') }));
 }
 
-function authorAsk(item: IntakeCheckItem): string {
+function prfaqSignals(sourceRef: string | undefined, root: string): { source: string; signals: string[] } | undefined {
+  if (!sourceRef?.startsWith('linear:') || !existsSync(taskCardsDir(root))) return undefined;
+  const store = new CardStore(root);
+  try {
+    const cards = store.listCards();
+    const matches = cards.filter(row => row.goalId === sourceRef);
+    const card = matches.length === 1 ? matches[0] : undefined;
+    const section = [...(card?.sections ?? [])].reverse().find(row => row.key.startsWith('prfaq:'));
+    if (!section) return undefined;
+    const criteria = section.content.split('⑧ 판정 기준')[1]?.split('⑨')[0] ?? '';
+    const signals = criteria.split('\n').map(line => line.trim().replace(/^-\s*/, '')).filter(line => /^판정 신호: 조건 = .+; 관측 = .+; 기대 = .+\.$/.test(line)).slice(0, 2);
+    return signals.length ? { source: `${card!.goalId} / ${section.key}`, signals } : undefined;
+  } finally { store.close(); }
+}
+
+function authorAsk(item: IntakeCheckItem, evidence?: { source: string; signals: string[] }): string {
   // The first line leads the ask and `제목:` is the title the author forwards (parseAskProseTitle), so both are the fact.
   return [
     item.fact,
@@ -52,9 +68,23 @@ function authorAsk(item: IntakeCheckItem): string {
     '백틱 이름은 대조에 쓴 검색 표지일 뿐이다 — 그 문자열이 저장소에 생기는 것을 판정 신호로 삼지 말고, 사실이 말하는 동작을 판정 신호로 쓴다.',
     `대조 결과: ${item.current}`,
     ...(item.quotes.length > 0 ? [`출처 인용: ${item.quotes.join(' / ')}`] : []),
+    ...(evidence ? [`아래 판정 신호를 골 문서 ## 판정 신호에 원문 그대로 인용하라. 출처: 카드 ${evidence.source}`, ...evidence.signals] : []),
   ].join('\n');
 }
 
+function appendPrfaqSignals(document: string, evidence: { source: string; signals: string[] }): string {
+  const section = /^## 판정 신호\s*$/m.exec(document);
+  if (!section) throw new Error('Authored goal has no ## 판정 신호 section');
+  const start = section.index + section[0].length;
+  const end = document.slice(start).search(/^## /m);
+  const boundary = end < 0 ? document.length : start + end;
+  const block = document.slice(start, boundary);
+  const missing = evidence.signals.filter(signal => !block.includes(signal));
+  const source = block.includes(`출처: 카드 ${evidence.source}`) ? '' : `출처: 카드 ${evidence.source}\n`;
+  if (!missing.length && !source) return document;
+  return document.slice(0, boundary) + `\n${source}${missing.map(signal => `- ${signal}`).join('\n')}\n` + document.slice(boundary);
+}
+
 export async function authorIntakeGoals(
   items: readonly IntakeCheckItem[],
   deps: IntakeAuthorDeps,
@@ -84,8 +114,11 @@ export async function authorIntakeGoals(
     }
     authored++;
     try {
-      const written = await deps.author(authorAsk(item), `intake check: ${opts.source}`);
-      const lintErrors = deps.lintErrors(written.document);
+      const evidence = prfaqSignals(item.sourceRef, deps.root);
+      const written = await deps.author(authorAsk(item, evidence), `intake check: ${opts.source}`);
+      const document = evidence ? appendPrfaqSignals(written.document, evidence) : written.document;
+      if (document !== written.document) writeFileSync(join(deps.root, written.path), document);
+      const lintErrors = deps.lintErrors(document);
       outcomes.push({ fact: item.fact, status: 'authored', goalPath: written.path, lintErrors });
     } catch (error) {
       outcomes.push({ fact: item.fact, status: 'author-failed', reason: error instanceof Error ? error.message : String(error) });

package/src/intake-plane/categorize.ts

@@ -25,6 +25,7 @@ import type {
 } from './enrich.js';
 import { summariseContext } from './enrich.js';
 import { buildResponseFormatHeader } from './prompt-format.js';
+import { judge } from '../llm/judge-layer.js';
 
 // ──────────────────── Closed sets ──────────────────────────────────────
 
@@ -69,7 +70,7 @@ export interface CategorizeResult {
 }
 
 export interface CategorizeCallable {
-  (args: { prompt: string; signal?: AbortSignal }): Promise<{
+  (args: { prompt: string; signal?: AbortSignal; provider?: string; model?: string }): Promise<{
     text: string;
     promptTokens?: number;
     completionTokens?: number;
@@ -219,26 +220,6 @@ export function buildCategorizePrompt(decomposition: EnrichedDecomposition): str
 
 // ──────────────────── Parse + coerce ──────────────────────────────────
 
-function extractJsonBlock(text: string): unknown | null {
-  const trimmed = text.trim();
-  const fence = trimmed.match(/```(?:json)?\n([\s\S]*?)```/);
-  const candidate = fence ? fence[1]! : trimmed;
-  try {
-    return JSON.parse(candidate);
-  } catch {
-    const open = candidate.indexOf('{');
-    const close = candidate.lastIndexOf('}');
-    if (open >= 0 && close > open) {
-      try {
-        return JSON.parse(candidate.slice(open, close + 1));
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-}
-
 function coerceConfidence(v: unknown): 'high' | 'medium' | 'low' {
   if (v === 'high' || v === 'medium' || v === 'low') return v;
   return 'medium';
@@ -306,27 +287,18 @@ export async function categorizeDecomposition(
 
   const prompt = buildCategorizePrompt(decomposition);
 
-  let raw;
-  try {
-    raw = await opts.callable({ prompt, signal: opts.signal });
-  } catch (err) {
-    if (opts.strict) {
-      throw new CategorizeError(
-        'LLM_CALL_FAILED',
-        err instanceof Error ? err.message : String(err),
-      );
-    }
-    return {
-      categorizations: Object.fromEntries(tasks.map((t) => [t.key, fallbackRow(t.key)])),
-      fallback: true,
-    };
-  }
-
-  const parsed = extractJsonBlock(raw.text);
-  const coerced = parsed ? coerceCategorizations(parsed, validKeys) : null;
-  if (coerced === null) {
+  const decision = await judge({
+    site: 'intake.categorize', prompt, signal: opts.signal,
+    call: ({ prompt, signal, provider, model }) => opts.callable({ prompt, signal, provider, model }),
+    schema: (parsed) => coerceCategorizations(parsed, validKeys),
+  });
+  if (!decision.ok) {
     if (opts.strict) {
-      throw new CategorizeError('PARSE_FAILED', 'no usable categorizations', raw.text);
+      if (decision.reason === 'call') {
+        throw new CategorizeError('LLM_CALL_FAILED',
+          decision.error instanceof Error ? decision.error.message : String(decision.error));
+      }
+      throw new CategorizeError('PARSE_FAILED', 'no usable categorizations', decision.rawText);
     }
     return {
       categorizations: Object.fromEntries(tasks.map((t) => [t.key, fallbackRow(t.key)])),
@@ -336,7 +308,7 @@ export async function categorizeDecomposition(
 
   // Backfill any missing tasks with the fallback shape so callers can
   // index by key without null checks.
-  const filled: Record<string, TaskCategorization> = { ...coerced };
+  const filled: Record<string, TaskCategorization> = { ...decision.value };
   for (const t of tasks) {
     if (!filled[t.key]) filled[t.key] = fallbackRow(t.key);
   }
@@ -344,10 +316,10 @@ export async function categorizeDecomposition(
     categorizations: filled,
     fallback: false,
     usage: {
-      promptTokens: raw.promptTokens,
-      completionTokens: raw.completionTokens,
-      costUsd: raw.costUsd,
-      modelId: raw.modelId,
+      promptTokens: decision.reply.promptTokens,
+      completionTokens: decision.reply.completionTokens,
+      costUsd: decision.reply.costUsd,
+      modelId: decision.reply.modelId,
     },
   };
 }

package/src/intake-plane/check.ts

@@ -63,6 +63,8 @@ export interface IntakeCheckEvidence {
 
 export interface IntakeCheckItem {
   readonly fact: string;
+  /** Source identity preserved from the supplied fact for card-backed goal evidence. */
+  readonly sourceRef?: string;
   readonly originalClaims?: readonly string[];
   readonly quotes: readonly string[];
   readonly verdict: IntakeCheckVerdict;
@@ -1415,6 +1417,7 @@ export function runIntakeCheck(
     const item: IntakeCheckItem = {
       ...judged,
       quotes: [quote],
+      ...(fact.sourceRef ? { sourceRef: fact.sourceRef } : {}),
       ...(fact.originalClaim ? { originalClaims: [fact.originalClaim] } : {}),
     };
     merged.set(key, item);

package/src/intake-plane/discord-seat-work.ts

@@ -1,4 +1,12 @@
+import { debug } from '../debug/log.js';
+import { discordDecisionOwner } from '../decisions/discord-decision-cards.js';
+import { canonicalSeatId } from '../msg/msg-store.js';
+import { dispatchCeoTask, type CeoCommandDeps } from '../seat-dispatch/ceo-commands.js';
+import { ceoTaskDeps, classifyCeoIntent } from '../seat-dispatch/ceo-intent.js';
+import { askSeat, parseSeatAsk, type SeatAskDeps } from '../seat-dispatch/seat-ask.js';
 import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
+import { answerAsSeat } from './seat-answer.js';
 import {
   submitIntakeWork,
   type SubmitIntakeWorkDeps,
@@ -7,21 +15,56 @@ import {
 export interface DiscordSeatWorkMessage {
   channelId: string;
   messageId: string;
+  userId?: string;
+  isDm?: boolean;
   threadId?: string;
 }
 
 export interface DiscordSeatWorkDeps extends SubmitIntakeWorkDeps {
   submit?: typeof submitIntakeWork;
+  config?: UserConfig;
+  answer?: typeof answerAsSeat;
+  dispatch?: typeof dispatchCeoTask;
+  commandDeps?: CeoCommandDeps;
+  askDeps?: SeatAskDeps;
 }
 
-/** Addressed Discord work goes through the graph intake door, not the chat turn. */
+/** Addressed work preserves graph intake except for one owner's private seat request. */
 export async function handleDiscordSeatWork(
   text: string,
   msg: DiscordSeatWorkMessage,
   deps: DiscordSeatWorkDeps = {},
 ): Promise<string | null> {
+  const owner = (): { cfg: UserConfig; id: string } | null => {
+    if (!msg.isDm || !msg.userId) return null;
+    const cfg = deps.config ?? getUserConfig();
+    const id = discordDecisionOwner(cfg);
+    return id && id === msg.userId ? { cfg, id } : null;
+  };
+  const sendTask = async (seat: string, body: string, cfg: UserConfig, id: string): Promise<string> => {
+    const result = await (deps.dispatch ?? dispatchCeoTask)(seat, body, deps.commandDeps ?? ceoTaskDeps(cfg, id), { via: 'discord' });
+    debug.log('seat.dispatch', 'intent', { seat, intent: 'task', via: 'discord', outcome: result.channel });
+    return result.reply;
+  };
+  if (parseSeatAsk(text)) {
+    const auth = owner();
+    if (!auth) return null;
+    if (!deps.askDeps) throw new Error('seat ask delivery unavailable');
+    return askSeat(text, { channel: 'discord', channelId: msg.channelId, messageId: msg.messageId,
+      ...(msg.threadId ? { threadId: msg.threadId } : {}) },
+    deps.commandDeps ?? ceoTaskDeps(auth.cfg, auth.id), deps.askDeps);
+  }
   const address = parseSeatAddress(text);
-  if (!address) return null;
+  if (!address) {
+    if (!text.trim() || /^\s*[/@＠]/.test(text)) return null;
+    const auth = owner();
+    const configured = (auth?.cfg.raw?.seatDispatch as { defaultSeat?: unknown } | undefined)?.defaultSeat;
+    if (typeof configured !== 'string' || classifyCeoIntent(text) !== 'task') return null;
+    const seat = resolveSeat(configured);
+    if (!seat) return null;
+    const id = canonicalSeatId(seat.id);
+    return ['OP', 'TC', 'MK', 'UX'].includes(id) ? sendTask(id, text, auth!.cfg, auth!.id) : null;
+  }
 
   const seats = address.seats.map((name) => ({ name, seat: resolveSeat(name) }));
   const unknown = seats.filter(({ seat }) => !seat).map(({ name }) => `@${name}`);
@@ -29,6 +72,18 @@ export async function handleDiscordSeatWork(
   const body = address.body.trim();
   if (!body) return '어떤 일을 맡길까요? 좌석 주소 뒤에 요청 내용을 적어 다시 보내 주세요.';
 
+  if (seats.length === 1 && seats[0]?.seat) {
+    const auth = owner();
+    const seatId = canonicalSeatId(seats[0].seat.id);
+    if (auth && ['OP', 'TC', 'MK', 'UX'].includes(seatId)) {
+      const intent = classifyCeoIntent(body);
+      if (intent === 'task') return sendTask(seatId, body, auth.cfg, auth.id);
+      const answer = await (deps.answer ?? answerAsSeat)(seats[0].name, body);
+      debug.log('seat.dispatch', 'intent', { seat: seatId, intent, via: 'discord', outcome: answer ? 'answered' : 'intake' });
+      if (answer) return answer.text;
+    }
+  }
+
   const reportTo = {
     channel: 'discord' as const,
     channelId: msg.channelId,

package/src/intake-plane/front-route-classifier.ts

@@ -1,7 +1,6 @@
 import { debug } from '../debug/log.js';
-import type { ModelRole } from '../user-config.js';
-import type { ResolveRoleProviderFn, StreamLlmFn, ProviderRegistry } from './runtime-callables.js';
-import { extractJsonBlock } from './decompose.js';
+import type { ResolveRoleProviderFn, StreamLlmFn } from './runtime-callables.js';
+import { judge } from '../llm/judge-layer.js';
 import {
   INTAKE_FRONT_ROUTE_TRACKS,
   type IntakeFrontRouteDecision,
@@ -14,17 +13,6 @@ interface ClassifierDeps {
   minConfidence?: number;
 }
 
-function loadRoleProvider(): ResolveRoleProviderFn {
-  const { resolveRoleLlm } = require('../user-config.js') as {
-    resolveRoleLlm: (role: ModelRole) => { provider: string; model: string };
-  };
-  const { PROVIDERS } = require('../llm.js') as { PROVIDERS: ProviderRegistry };
-  return (role) => {
-    const resolved = resolveRoleLlm(role);
-    return { provider: PROVIDERS[resolved.provider] ?? { name: resolved.provider }, model: resolved.model };
-  };
-}
-
 /** Classify only after the deterministic front-route rules return rule-unknown. */
 export async function classifyIntakeFrontRoute(
   text: string,
@@ -43,32 +31,38 @@ export async function classifyIntakeFrontRoute(
   const failed = (cause: string) => finish('ask-human', 0, `classifier-failed:${cause}`, 'failed');
 
   try {
-    const rolePick = (deps.resolveRoleProvider ?? loadRoleProvider())('classify');
-    provider = rolePick.provider.name;
-    const streamLLM = deps.streamLLM ?? (require('../llm.js') as { streamLLM: StreamLlmFn }).streamLLM;
-    const response = await streamLLM([
-      { role: 'system', content: [
-        'Classify the intake text into exactly one track:',
-        'absorb: read, save, or summarize external material.',
-        'tasks: a list of independent to-dos.',
-        'graph: an implementation or multi-step workflow request.',
-        'ask-human: ambiguous intent requiring human choice.',
-        'Return only one JSON object: {"track":"...","confidence":0.0,"reason":"..."}. Confidence must be between 0 and 1.',
-      ].join('\n') },
-      { role: 'user', content: text },
-    ], () => {}, { provider: rolePick.provider, ...(rolePick.model ? { model: rolePick.model } : {}), usageRole: 'classify' });
-
-    // 실제 모델은 JSON 을 ```json 펜스로 감싸거나 앞뒤에 말을 붙이곤 한다 — 같은 디렉토리의 다른 호출자와 같은 관대한 추출을 쓴다.
-    const parsed: unknown = extractJsonBlock(response);
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return failed('invalid-json');
-    const candidate = parsed as Record<string, unknown>;
-    if (typeof candidate.track !== 'string' ||
-      !(INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(candidate.track)) return failed('invalid-track');
-    if (typeof candidate.confidence !== 'number' || !Number.isFinite(candidate.confidence) ||
-      candidate.confidence < 0 || candidate.confidence > 1) return failed('invalid-confidence');
-    if (typeof candidate.reason !== 'string') return failed('invalid-reason');
+    const decision = await judge({
+      site: 'intake.front-route',
+      prompt: text,
+      messages: [
+        { role: 'system', content: [
+          'Classify the intake text into exactly one track:',
+          'absorb: read, save, or summarize external material.',
+          'tasks: a list of independent to-dos.',
+          'graph: an implementation or multi-step workflow request.',
+          'ask-human: ambiguous intent requiring human choice.',
+          'Return only one JSON object: {"track":"...","confidence":0.0,"reason":"..."}. Confidence must be between 0 and 1.',
+        ].join('\n') },
+        { role: 'user', content: text },
+      ],
+      streamLLM: deps.streamLLM,
+      resolveRoleProvider: deps.resolveRoleProvider,
+      schema: (parsed) => {
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+        const candidate = parsed as Record<string, unknown>;
+        if (typeof candidate.track !== 'string' ||
+          !(INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(candidate.track)) return null;
+        if (typeof candidate.confidence !== 'number' || !Number.isFinite(candidate.confidence) ||
+          candidate.confidence < 0 || candidate.confidence > 1) return null;
+        if (typeof candidate.reason !== 'string') return null;
+        return { track: candidate.track as IntakeFrontRouteTrack, confidence: candidate.confidence, reason: candidate.reason };
+      },
+    });
+    provider = decision.ok ? decision.provider : provider;
+    if (!decision.ok) return failed(decision.reason === 'schema' ? 'invalid-json' : 'llm-error');
+    const candidate = decision.value;
 
-    const track = candidate.track as IntakeFrontRouteTrack;
+    const track = candidate.track;
     const confidence = candidate.confidence;
     if (confidence < (deps.minConfidence ?? 0.6)) {
       return finish('ask-human', confidence, `classifier-low-confidence:${track}`, 'low-confidence');

package/src/intake-plane/persona-answer.ts

@@ -0,0 +1,30 @@
+import { debug } from '../debug/log.js';
+import { resolveMention, type PersonaSource } from '../persona/mention-parser.js';
+import type { PersonaProfile } from '../persona/types.js';
+
+export interface PersonaAnswerDeps {
+  complete?: (prompt: string) => Promise<string>;
+}
+
+/** Resolve the registry mention first, then an exact display name. */
+export function resolvePersonaAddress(name: string, source: PersonaSource): PersonaProfile | null {
+  const mention = resolveMention(name, source);
+  if (mention) return mention;
+  const needle = name.replace(/^@/, '').toLocaleLowerCase();
+  return source.list().find((persona) => persona.displayName.toLocaleLowerCase() === needle) ?? null;
+}
+
+async function defaultComplete(prompt: string): Promise<string> {
+  const { streamLLM } = await import('../llm.js');
+  const { tierModel } = await import('../llm/model-defaults.js');
+  return streamLLM([{ role: 'user', content: prompt }], () => {}, { model: tierModel('better') });
+}
+
+export async function answerAsPersona(persona: PersonaProfile, question: string, deps: PersonaAnswerDeps = {}): Promise<string> {
+  const prompt = `${persona.systemPrompt ?? `너는 ${persona.displayName} 이다`}\n\n## 질문\n${question}`;
+  const raw = await (deps.complete ?? defaultComplete)(prompt);
+  const answer = `@${persona.displayName}\n${raw.trim()}`;
+  const text = Array.from(answer).slice(0, 3_500).join('');
+  debug.log('persona.address', 'answered', { personaId: persona.personaId, chars: Array.from(text).length });
+  return text;
+}

package/src/intake-plane/runtime-callables.ts

@@ -305,7 +305,14 @@ export function buildRealIntakeCallables(
   };
 
   const decompose: DecomposeMemoCallable = (args) => promptCallable(args);
-  const categorize: CategorizeCallable = (args) => promptCallable(args);
+  const categorize: CategorizeCallable = async (args) => {
+    const text = await streamLLM([{ role: 'user', content: args.prompt }], () => {}, {
+      ...(args.provider ? { provider: providers[args.provider] } : {}),
+      ...(args.model ? { model: args.model } : {}),
+      ...(args.signal ? { signal: args.signal } : {}), usageRole: 'classify',
+    });
+    return { text, modelId: args.model };
+  };
   const align: AlignCallable = (args) => promptCallable(args);
 
   /** Synth callable — wraps R3 `synthWorkflowFromIntent`. Hands it a

package/src/intake-plane/seat-doc-route.ts

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { MissionOrigin } from '../autopilot/mission-origin.js';
 import { debug } from '../debug/log.js';
@@ -15,7 +15,7 @@ import { answerAsSeat, isNoGraphFailure } from './seat-answer.js';
 const POLL_MS = 5_000;
 const TIMEOUT_MS = 30 * 60_000;
 const DOC = /전략|한\s*장|원페이저|기획|보도자료|글|메모|초안|\b(?:one-pager|strategy|post|memo|draft)\b/i;
-const CODE = /구현|버그|고쳐|\b(?:fix|implement|PR)\b/i;
+const CODE = /구현|버그|고쳐|\b(?:fix|implement)\b|\bPR\b(?!\s*#?\d+\b)/i;
 const RESEARCH = /전략|시장|경쟁|\bstrategy\b/i;
 /** EV12a — a question or a request for status / a report is answered, never turned into a code goal. */
 const ASK = /상황|현황|진행|준비|어때|어떻게|알려|보고|정리|요약|공유|\?|？|\b(?:status|update|report|summary|summari[sz]e|how|what)\b/i;
@@ -30,6 +30,8 @@ export interface SeatDocDeps {
   submitExec?: (text: string) => Promise<{ id: string }>;
   getExec?: (id: string) => Promise<ExecSnapshot | null>;
   getFile?: (path: string) => Promise<string>;
+  /** Resolve only references explicitly supplied in the request; null means their claims cannot be verified. */
+  readSource?: (ref: string) => Promise<string | null>;
   publishFile?: (content: string, key: string) => string | null;
   sendOutbound?: typeof sendOutbound;
   sleep?: (ms: number) => Promise<void>;
@@ -97,6 +99,160 @@ async function execFile(path: string): Promise<string> {
   return (await execResponse(path.slice('/v1/exec-requests'.length))).text();
 }
 
+const SUPPLIED_REF = /https?:\/\/[^\s<>()[\]]+|\bPR\s*#?\d+\b|(?:\.?\.?\/|[\w.-]+\/)[\w./-]+\.(?:md|txt|csv|json|pdf)\b|\b[\w.-]+\.(?:md|txt|csv|json|pdf)\b/gi;
+// Keep units and grammatical particles with the figure; never backtrack from 42% to 42.
+const NUMBER = /(?<![\p{L}\p{N}_#.,])([+-]?\d+(?:[,.]\d+)*(?:(?:%|년|월|일|명|건|원|배)(?![\p{N}_%A-Za-z]|[.,]\d)|(?![\p{L}\p{N}_%]|[.,]\d)))(은|는|이|가|을|를|에|의|도|만|에서|으로|와|과)?/gu;
+
+function suppliedReferences(text: string): string[] {
+  return [...new Set([...text.matchAll(SUPPLIED_REF)].map(([ref]) => ref!.replace(/[.,;]+$/, '')))];
+}
+
+const SOURCE_TIMEOUT_MS = 5_000;
+const MAX_SOURCE_BYTES = 200_000;
+// The default resolver only reads repository-local files and these two public HTTPS hosts.
+const SOURCE_URL_HOSTS = new Set(['github.com', 'raw.githubusercontent.com']);
+
+function allowedSourceUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === 'https:' && SOURCE_URL_HOSTS.has(url.hostname)
+      && !url.username && !url.password && !url.port;
+  } catch { return false; }
+}
+
+async function readPublicSource(ref: string): Promise<string | null> {
+  let url = ref;
+  const signal = AbortSignal.timeout(SOURCE_TIMEOUT_MS);
+  for (let redirects = 0; redirects < 3; redirects++) {
+    if (!allowedSourceUrl(url)) return null;
+    const response = await fetch(url, { signal, redirect: 'manual' });
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get('location');
+      if (!location) return null;
+      url = new URL(location, url).href;
+      continue;
+    }
+    if (!response.ok || !/^(?:text\/|application\/(?:json|xml))/.test(response.headers.get('content-type') ?? '')) return null;
+    if (Number(response.headers.get('content-length') ?? 0) > MAX_SOURCE_BYTES) {
+      await response.body?.cancel();
+      return null;
+    }
+    if (!response.body) return null;
+    const reader = response.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let size = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        size += value.byteLength;
+        if (size > MAX_SOURCE_BYTES) return null;
+        chunks.push(value);
+      }
+      const bytes = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+      return new TextDecoder().decode(bytes);
+    } finally {
+      if (size > MAX_SOURCE_BYTES) await reader.cancel();
+      reader.releaseLock();
+    }
+  }
+  return null;
+}
+
+async function defaultReadSource(ref: string): Promise<string | null> {
+  try {
+    if (/^https?:\/\//i.test(ref)) return await readPublicSource(ref);
+    if (/^PR\s*#?\d+$/i.test(ref)) {
+      const number = ref.match(/\d+/)![0];
+      const child = Bun.spawn(['gh', 'pr', 'view', number, '--json', 'title,body'], { stdout: 'pipe', stderr: 'ignore' });
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const timeout = new Promise<null>(finish => {
+        timer = setTimeout(() => { child.kill(9); finish(null); }, SOURCE_TIMEOUT_MS);
+      });
+      try {
+        const result = await Promise.race([
+          Promise.all([new Response(child.stdout).text(), child.exited]).then(([out, code]) => ({ out, code })),
+          timeout,
+        ]);
+        if (!result || result.code !== 0 || result.out.length > MAX_SOURCE_BYTES) return null;
+        const pr = JSON.parse(result.out) as { title?: string; body?: string };
+        return `${pr.title ?? ''}\n${pr.body ?? ''}`;
+      } finally { clearTimeout(timer); }
+    }
+    const root = realpathSync(process.cwd());
+    const actual = realpathSync(resolve(root, ref));
+    const within = relative(root, actual);
+    if (isAbsolute(within) || within === '..' || within.startsWith('../')) return null;
+    const file = statSync(actual);
+    if (!file.isFile() || file.size > MAX_SOURCE_BYTES || /\.pdf$/i.test(actual)) return null;
+    return readFileSync(actual, 'utf8');
+  } catch { return null; }
+}
+
+function citationFor(ref: string): string {
+  return /^PR\s*#?(\d+)$/i.test(ref) ? `PR #${ref.match(/\d+/)![0]}` : ref;
+}
+
+function claimLabel(line: string, offset: number, length: number): string | null {
+  const before = line.slice(0, offset).split(/[,;:，；。.!?\n]/).at(-1) ?? '';
+  const after = (line.slice(offset + length).split(/[,;:，；。.!?\n]/)[0] ?? '').replace(/^\s*(?:\[출처: [^\]]+\]|«확인 필요»)/, '');
+  // Never borrow a label from another figure in the same clause.
+  if ([...before.matchAll(NUMBER), ...after.matchAll(NUMBER)].length) return null;
+  const left = before.trim().replace(/^(?:[#*>-]+\s*)+/, '');
+  const right = after.match(/^\s*([\p{L}]{2,}(?:\s+[\p{L}]{2,})*)/u)?.[1];
+  return /[\p{L}]{2,}/u.test(left) ? left : right ?? null;
+}
+
+const CLAIM_DIRECTION = /증가|상승|성장|확대|개선|감소|하락|축소|악화/g;
+const CLAIM_FORECAST = /예상|전망|예측|추정|계획|예정|기대|목표|가능성/;
+// Range and approximation words change what a figure claims («42%» ≠ «42% 미만»); both sides must carry the same set.
+const CLAIM_QUALIFIER = /미만|이하|이상|초과|이내|약|최대|최소|가량|정도|내외|안팎|넘게|넘는|남짓|까지|부터|대략|거의|이상의|under|over|about|up to|at least|at most|less than|more than|nearly|almost/giu;
+
+function claimDirection(segment: string): string | undefined {
+  const directions = [...segment.matchAll(CLAIM_DIRECTION)];
+  if (directions.length > 1) return undefined;
+  const direction = directions[0];
+  const after = direction ? segment.slice(direction.index + direction[0].length) : '';
+  const negated = direction && /^\s*(?:하지\s*(?:않|못)|않|못|안\s*(?:했|함)|없|아니)/u.test(after);
+  // Polarity outside the recognized predicate is ambiguous; do not use it to establish provenance.
+  if (/않|못|안\s|없|아니/u.test(segment) && !negated) return undefined;
+  const qualifiers = [...new Set([...segment.matchAll(CLAIM_QUALIFIER)].map(match => match[0].toLowerCase().replace(/^이상의$/, '이상')))].sort().join(',');
+  return `${direction?.[0] ?? ''}|${negated ? 'negated' : 'affirmed'}|${CLAIM_FORECAST.test(segment) ? 'forecast' : 'observed'}|${qualifiers}`;
+}
+
+function hasClaimPair(source: string, number: string, label: string, direction: string | undefined): boolean {
+  if (direction === undefined) return false;
+  return source.split(/\n|,(?=\s)|[;:，；。!?]|\.(?!\d)/).some(segment => {
+    const figures = [...segment.matchAll(NUMBER)];
+    if (figures.length !== 1 || figures[0]![1] !== number) return false;
+    return claimLabel(segment, figures[0]!.index, figures[0]![0].length) === label
+      && claimDirection(segment) === direction;
+  });
+}
+
+function citeDocumentNumbers(content: string, sources: Map<string, string | null>): string {
+  let fenced = false;
+  return content.split('\n').map(line => {
+    if (/^\s*```/.test(line)) { fenced = !fenced; return line; }
+    if (fenced || /^\s*(?:참고 자료|출처:)/.test(line)) return line;
+    const occupied = [...line.matchAll(/https?:\/\/\S+|\[출처: [^\]]+\]|(?:\.?\.?\/|[\w.-]+\/)[\w./-]+\.(?:md|txt|csv|json|pdf)|\b[\w.-]+\.(?:md|txt|csv|json|pdf)\b/g)]
+      .map(match => [match.index, match.index + match[0].length] as const);
+    const annotated = new RegExp(`${NUMBER.source}(?:\\s*(?:\\[출처: [^\\]]+\\]|«확인 필요»))?`, 'gu');
+    return line.replace(annotated, (claim, number: string, particle: string | undefined, offset: number) => {
+      if (occupied.some(([start, end]) => offset >= start && offset < end)) return claim;
+      const figure = `${number}${particle ?? ''}`;
+      const label = claimLabel(line, offset, claim.length);
+      const before = line.slice(0, offset).split(/[,;:，；。.!?]/).at(-1) ?? '';
+      const after = line.slice(offset + claim.length).split(/[,;:，；。.!?]/)[0] ?? '';
+      const direction = claimDirection(`${before} ${after}`);
+      const matches = label ? [...sources].filter(([, source]) => source && hasClaimPair(source, number, label, direction)) : [];
+      return matches.length === 1 ? `${figure} [출처: ${citationFor(matches[0]![0])}]` : `${figure} «확인 필요»`;
+    });
+  }).join('\n');
+}
+
 function chatPwaUrl(): string | undefined {
   const endpoint = resolveDaemonEndpoint({ purpose: 'write' });
   return endpoint?.pwaUrl;
@@ -115,14 +271,15 @@ function accessiblePwaUrl(value: string | undefined): string | undefined {
   } catch { return undefined; }
 }
 
-async function fileLinks(id: string, result: ExecSnapshot, deps: SeatDocDeps): Promise<Map<string, string>> {
+async function fileLinks(id: string, result: ExecSnapshot, deps: SeatDocDeps, sources: Map<string, string | null>): Promise<Map<string, string>> {
   const links = new Map<string, string>();
   for (const entry of result.results) {
     if (entry.kind !== 'report' && entry.kind !== 'text') continue;
     if (!entry.url.startsWith(`/v1/exec-requests/${encodeURIComponent(id)}/files/`)) continue;
     try {
       // The authenticated daemon route is the only source of bytes; a raw file path is never trusted.
-      const content = await (deps.getFile ?? execFile)(entry.url);
+      const raw = await (deps.getFile ?? execFile)(entry.url);
+      const content = sources.size ? citeDocumentNumbers(raw, sources) : raw;
       const ext = entry.kind === 'report' ? 'md' : 'txt';
       const digest = createHash('sha256').update(content).digest('hex');
       const key = `seat-doc/${encodeURIComponent(id)}/${digest}.${ext}`;
@@ -158,6 +315,13 @@ export async function submitSeatDocRequest({ text, reportTo, deps = {} }: {
   const body = parseSeatAddress(text)?.body.trim() ?? text.trim();
   let withoutResearch = false;
   let requestText = text;
+  const refs = suppliedReferences(body);
+  const sources = new Map<string, string | null>();
+  for (const ref of refs) {
+    try { sources.set(ref, await (deps.readSource ?? defaultReadSource)(ref)); }
+    catch { sources.set(ref, null); }
+  }
+  if (refs.length) requestText += '\n\n문서 수치 근거 규칙: 제공된 파일·URL·PR 번호의 실제 내용을 확인하고, 근거가 확인된 각 수치 바로 뒤에 [출처: <파일|PR|명령>] 형식으로 실물 참조를 붙이세요. 근거를 확인할 수 없는 수치는 삭제하거나 바꾸지 말고 «확인 필요»로 표시하세요. 서로 다른 출처에 같은 숫자가 있다는 이유만으로 출처를 추정하지 마세요.';
   if (RESEARCH.test(body)) {
     try {
       const sources = (await (deps.research ?? research)(body)).slice(0, 5);
@@ -196,7 +360,7 @@ export async function submitSeatDocRequest({ text, reportTo, deps = {} }: {
       if (now() < deadline) await sleep(Math.min(POLL_MS, Math.max(0, deadline - now())));
     }
     log('settled', { id, status: result?.status ?? (lookupAvailable ? 'timeout' : 'lookup-unavailable'), lastConfirmedStatus });
-    const links = result?.status === 'done' ? await fileLinks(id, result, deps) : new Map<string, string>();
+    const links = result?.status === 'done' ? await fileLinks(id, result, deps, sources) : new Map<string, string>();
     let reply = message(id, result, withoutResearch, lookupAvailable, accessiblePwaUrl((deps.pwaUrl ?? chatPwaUrl)()), links);
     if (isNoGraphFailure(result)) {
       // EV12d — a question with no fitting graph gets the seat's own answer, not «문서 요청 실패».