elanous 0.2.13 → 0.2.15

package/src/intake-plane/lens.ts

@@ -0,0 +1,177 @@
+// 흡수 렌즈 — outbox 항목마다 «우리에게 무엇인가»를 판정해 outbox/lens/<day>.jsonl 에만 남긴다.
+// 원 갈래(goals·manual·review·release)는 읽기만 한다. LLM 은 judge 한 번(id 당).
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { judge } from '../llm/judge-layer.js';
+import { intakeOutboxDir } from './route.js';
+
+export const LENS_VERDICTS = ['대체 후보', '보강', '경쟁 대조', '참고'] as const;
+export type LensVerdict = (typeof LENS_VERDICTS)[number];
+
+export const LENS_BRANCHES = ['goals', 'manual', 'review', 'release'] as const;
+export const LENS_DAILY_CAP = 20;
+export const LENS_FACT_CAP = 12;
+
+export interface LensRecord {
+  id: string;
+  at: string;
+  lensVerdict: LensVerdict;
+  why: string;
+  target: string;
+}
+
+export interface LensJudgeInput {
+  id: string;
+  facts: { fact: string; current: string }[];
+  url?: string;
+}
+
+export type LensJudge = (input: LensJudgeInput) => Promise<unknown>;
+
+export interface AnnotateIntakeLensDeps {
+  judge?: LensJudge;
+  now?: () => string;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export interface AnnotateIntakeLensResult {
+  judged: number;
+  skipped: number;
+  failed: number;
+  capped: boolean;
+}
+
+interface GroupedItem {
+  id: string;
+  facts: { fact: string; current: string }[];
+  url?: string;
+}
+
+function readJsonl(file: string): Record<string, unknown>[] {
+  if (!existsSync(file)) return [];
+  return readFileSync(file, 'utf8').split('\n').filter(Boolean).flatMap((line) => {
+    try { const row = JSON.parse(line) as unknown; return row && typeof row === 'object' && !Array.isArray(row) ? [row as Record<string, unknown>] : []; }
+    catch { return []; }
+  });
+}
+
+function isTestProcess(): boolean {
+  return process.env.NODE_ENV === 'test' || Boolean(process.env.ELANOUS_TEST_HOME);
+}
+
+function isLensVerdict(value: unknown): value is LensVerdict {
+  return typeof value === 'string' && (LENS_VERDICTS as readonly string[]).includes(value);
+}
+
+/** 스키마 밖이면 null — 기록하지 않는다. why 는 한 문장이다. */
+export function coerceLensVerdict(raw: unknown): Omit<LensRecord, 'id' | 'at'> | null {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  const row = raw as Record<string, unknown>;
+  const why = typeof row.why === 'string' ? row.why.trim() : '';
+  const target = typeof row.target === 'string' ? row.target.trim() : '';
+  if (!isLensVerdict(row.lensVerdict) || !why || !target) return null;
+  if (/[\r\n]/.test(why)) return null;
+  return { lensVerdict: row.lensVerdict, why, target };
+}
+
+function groupOutbox(root: string, day: string): GroupedItem[] {
+  const out = intakeOutboxDir(root);
+  const order: string[] = [];
+  const groups = new Map<string, GroupedItem>();
+  for (const branch of LENS_BRANCHES) {
+    for (const row of readJsonl(join(out, branch, `${day}.jsonl`))) {
+      const id = typeof row.id === 'string' ? row.id.trim() : '';
+      const fact = typeof row.fact === 'string' ? row.fact.trim() : '';
+      const current = typeof row.current === 'string' ? row.current.trim() : '';
+      if (!id || !fact) continue;
+      let group = groups.get(id);
+      if (!group) {
+        group = { id, facts: [] };
+        groups.set(id, group);
+        order.push(id);
+      }
+      if (!group.url && typeof row.url === 'string' && row.url.trim()) group.url = row.url.trim();
+      if (group.facts.length < LENS_FACT_CAP) group.facts.push({ fact, current });
+    }
+  }
+  return order.map((id) => groups.get(id)!);
+}
+
+function judgedIds(file: string): Set<string> {
+  return new Set(readJsonl(file).flatMap((row) => typeof row.id === 'string' && row.id ? [row.id] : []));
+}
+
+function lensPrompt(item: GroupedItem): string {
+  const lines = item.facts.map((row, i) => `${i + 1}. fact: ${row.fact}\n   current: ${row.current || '(없음)'}`);
+  return [
+    'SYSTEM:',
+    '흡수 항목이 우리에게 무엇인가를 한 번만 판정한다. 경로를 나열하지 말고, 왜 우리에게 그 판정인지를 한 문장으로 말한다.',
+    'lensVerdict 는 다음 넷 중 하나다: 대체 후보 · 보강 · 경쟁 대조 · 참고.',
+    'target 은 닿는 우리 쪽 이름 하나(기능·칸·파일)다.',
+    'JSON 만 답한다: {"lensVerdict":"...","why":"...","target":"..."}',
+    '',
+    `id: ${item.id}`,
+    ...(item.url ? [`url: ${item.url}`] : []),
+    ...lines,
+  ].join('\n');
+}
+
+async function defaultJudge(item: GroupedItem): Promise<unknown> {
+  const decision = await judge({
+    site: 'intake.lens',
+    prompt: lensPrompt(item),
+    schema: (value) => coerceLensVerdict(value),
+  });
+  if (!decision.ok) {
+    if (decision.reason === 'schema') return null;
+    throw decision.error instanceof Error ? decision.error : new Error(String(decision.error));
+  }
+  return decision.value;
+}
+
+/** 그날 outbox 를 id 로 묶어 아직 없는 판정만 남긴다. 원 갈래 파일은 쓰지 않는다. */
+export async function annotateIntakeLens(
+  root: string,
+  day: string,
+  deps: AnnotateIntakeLensDeps = {},
+): Promise<AnnotateIntakeLensResult> {
+  const log = deps.log ?? ((event, data) => { debug.log('intake.lens', event, data); });
+  const empty = { judged: 0, skipped: 0, failed: 0, capped: false };
+  if (!deps.judge && isTestProcess()) {
+    log('skipped-test', {});
+    return empty;
+  }
+  const items = groupOutbox(root, day);
+  const file = join(intakeOutboxDir(root), 'lens', `${day}.jsonl`);
+  const done = judgedIds(file);
+  const pending = items.filter((item) => !done.has(item.id));
+  const capped = pending.length > LENS_DAILY_CAP;
+  const batch = pending.slice(0, LENS_DAILY_CAP);
+  if (capped) log('capped', { day, total: pending.length, judged: batch.length });
+  const judgeOne = deps.judge ?? ((input: LensJudgeInput) => defaultJudge(input));
+  const now = deps.now ?? (() => new Date().toISOString());
+  let judged = 0;
+  let failed = 0;
+  for (const item of batch) {
+    let raw: unknown;
+    try {
+      raw = await judgeOne({ id: item.id, facts: item.facts, ...(item.url ? { url: item.url } : {}) });
+    } catch (error) {
+      failed++;
+      log('judge-failed', { id: item.id, reason: error instanceof Error ? error.message : String(error) });
+      continue;
+    }
+    const verdict = coerceLensVerdict(raw);
+    if (!verdict) {
+      failed++;
+      log('judge-failed', { id: item.id, reason: 'schema' });
+      continue;
+    }
+    mkdirSync(join(intakeOutboxDir(root), 'lens'), { recursive: true });
+    const record: LensRecord = { id: item.id, at: now(), ...verdict };
+    appendFileSync(file, `${JSON.stringify(record)}\n`);
+    judged++;
+  }
+  return { judged, skipped: items.length - pending.length, failed, capped };
+}

package/src/intake-plane/linear-wish.ts

@@ -6,24 +6,51 @@ import { createWishCard } from './wish-card.js';
 
 export const LINEAR_WISH_KEY_MISSING = 'Linear 키가 없습니다 — elanous connector linear 로 먼저 등록하세요';
 
-export async function scanLinearWishes({ teamKey, label = 'wish', store, deps = {} }: {
-  teamKey: string;
-  label?: string;
-  store: CardStore;
-  deps?: {
-    getApiKey?: () => Promise<string | undefined>;
-    fetchIssues?: typeof fetchLinearIssues;
-  };
-}): Promise<{ added: number; duplicate: number; failed: number }> {
+type LinearWishDeps = {
+  getApiKey?: () => Promise<string | undefined>;
+  fetchIssues?: typeof fetchLinearIssues;
+};
+
+async function readLinearWishes(teamKey: string, options: { labelOrPrefix?: string; excludeLabel?: string }, deps: LinearWishDeps) {
   const apiKey = await (deps.getApiKey ?? (() => getSecretAsync('connector.linear.apiKey')))();
   if (!apiKey?.trim()) throw new Error(LINEAR_WISH_KEY_MISSING);
-  let issues: Awaited<ReturnType<typeof fetchLinearIssues>>;
   try {
-    issues = await (deps.fetchIssues ?? fetchLinearIssues)({ apiKey, teamKey, labelOrPrefix: label });
+    return await (deps.fetchIssues ?? fetchLinearIssues)({ apiKey, teamKey, ...options });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(message.replaceAll(apiKey, '[redacted]'));
   }
+}
+
+export interface LinearWishSuggestion { identifier: string; title: string; reason: string }
+
+const WISH_PHRASES = [
+  { pattern: /해\s*줘(?:요|라)?/, reason: '요청' },
+  { pattern: /만들어(?:\s*줘(?:요)?)?/, reason: '제작' },
+  { pattern: /원해(?:요)?/, reason: '희망' },
+  { pattern: /있으면\s*좋겠다/, reason: '희망' },
+];
+
+export async function suggestLinearWishes({ teamKey, deps = {} }: {
+  teamKey: string;
+  deps?: LinearWishDeps;
+}): Promise<LinearWishSuggestion[]> {
+  const issues = await readLinearWishes(teamKey, { excludeLabel: 'wish' }, deps);
+  return issues.flatMap(issue => {
+    const match = WISH_PHRASES.find(({ pattern }) => pattern.test(`${issue.title}\n${issue.body}`));
+    return match && issue.identifier
+      ? [{ identifier: issue.identifier, title: Array.from(issue.title).slice(0, 40).join(''), reason: match.reason }]
+      : [];
+  });
+}
+
+export async function scanLinearWishes({ teamKey, label = 'wish', store, deps = {} }: {
+  teamKey: string;
+  label?: string;
+  store: CardStore;
+  deps?: LinearWishDeps;
+}): Promise<{ added: number; duplicate: number; failed: number }> {
+  const issues = await readLinearWishes(teamKey, { labelOrPrefix: label }, deps);
   let added = 0;
   let duplicate = 0;
   let failed = 0;
@@ -32,6 +59,7 @@ export async function scanLinearWishes({ teamKey, label = 'wish', store, deps =
       const result = createWishCard({
         text: `${issue.title}\n\n${issue.body}\n\n${issue.url}`,
         source: 'linear', ref: issue.identifier ?? '',
+        replyTo: { surface: 'linear', issueId: issue.ref },
       }, store);
       if (result.created) added++;
       else duplicate++;

package/src/intake-plane/route.ts

@@ -3,9 +3,13 @@
 // ⛔ 원장의 `text`(개인 메모일 수 있다)는 큐에 싣지 않는다 — 대조가 낸 사실·근거와 노트 경로만.
 import { execFileSync } from 'node:child_process';
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { Database } from 'bun:sqlite';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
-import { intakeLedgerDir, loadIntakeLedger, markIntakeItem, type IntakeItem } from './items.js';
+import { getToxRuntimeDeps } from '../task-orchestrator/runtime-deps.js';
+import type { TaskStore } from '../task-orchestrator/store.js';
+import type { TaskStatus } from '../task-orchestrator/types.js';
+import { canonicalUrl, ingestIntakeItems, intakeItemId, intakeLedgerDir, loadIntakeLedger, markIntakeItem, type IntakeItem } from './items.js';
 
 /** `elanous intake check --json` 산출 중 갈래가 읽는 칸. */
 export interface IntakeCheckJson {
@@ -29,6 +33,146 @@ export const gitLastCommitOf: LastCommitOf = (tree, path) => {
 
 export function intakeOutboxDir(root: string): string { return join(intakeLedgerDir(root), 'outbox'); }
 
+export const INTAKE_EVENT_DEFERRED_REPLY = '일일 즉시 흡수 상한을 넘어 다음 일일 판으로 미뤘습니다.';
+export type IntakeEventResult = { status: 'scheduled' | 'deferred' | 'duplicate'; reason: string; url: string; reply?: string };
+
+// A lost claim must become eligible at the next daily pass; live tasks remain excluded.
+const INTAKE_EVENT_LEASE_MS = 23 * 3600_000;
+
+// A non-terminal task that has not been touched for this long is treated as a dead worker.
+const INTAKE_EVENT_TASK_STALE_MS = 2 * 3600_000;
+
+/** A probe may return the bare status, or the status with the task's last update (epoch ms). */
+export type IntakeEventTaskProbe = (id: string) => TaskStatus | { status: TaskStatus; updatedAt?: number } | undefined;
+
+function eventTaskStatus(taskId: string): { status: TaskStatus; updatedAt?: number } | undefined {
+  const deps = getToxRuntimeDeps();
+  const graphTask = deps.getGraph()?.getTask(taskId) ?? (deps.getStore?.() as TaskStore | null | undefined)?.getTask(taskId);
+  return graphTask ? { status: graphTask.status, updatedAt: graphTask.updatedAt } : undefined;
+}
+
+function probeStatus(probe: IntakeEventTaskProbe, id: string): { status?: TaskStatus; updatedAt?: number } {
+  const value = probe(id);
+  return typeof value === 'string' ? { status: value } : value ?? {};
+}
+
+type EventClaim = { status: string; task_id: string | null; claimed_at: string | null; day: string };
+
+function activeEventClaim(row: EventClaim, now: string, taskStatus: IntakeEventTaskProbe): boolean {
+  if (row.status !== 'scheduled' && row.status !== 'pending') return false;
+  const { status, updatedAt } = row.task_id ? probeStatus(taskStatus, row.task_id) : {};
+  if (status === 'done') return true;
+  if (status === 'failed' || status === 'cancelled' || status === 'superseded') return false;
+  const claimedAt = Date.parse(row.claimed_at ?? `${row.day}T00:00:00.000+09:00`);
+  const withinLease = Number.isFinite(claimedAt) && Date.parse(now) - claimedAt < INTAKE_EVENT_LEASE_MS;
+  if (!status) return withinLease;
+  // A status alone is not liveness: a crashed worker leaves «running» behind, so require a recent update.
+  if (updatedAt !== undefined && Number.isFinite(updatedAt)) return Date.parse(now) - updatedAt < INTAKE_EVENT_TASK_STALE_MS;
+  return withinLease;
+}
+
+/** Claim an event slot before posting. The unique URL and KST-day quota share one SQLite transaction. */
+export async function scheduleIntakeEvent(
+  root: string,
+  url: string,
+  opts: {
+    eventMax?: number;
+    now?: string;
+    post: (input: { url: string }) => Promise<{ taskId: string }>;
+  },
+): Promise<IntakeEventResult> {
+  const normalized = canonicalUrl(url);
+  if (!normalized) throw new Error('intake event requires an HTTP(S) URL');
+  const now = opts.now ?? new Date().toISOString();
+  const day = kstDay(now);
+  const id = intakeItemId('telegram-bot', { url: normalized });
+  const max = opts.eventMax ?? 10;
+  if (!Number.isSafeInteger(max) || max < 0) throw new RangeError('intake.eventMax must be a non-negative integer');
+  const existing = loadIntakeLedger(root).items.get(id);
+  if (existing && ['queued', 'absorbed', 'checked', 'routed', 'discarded'].includes(existing.status)) {
+    return { status: 'duplicate', url: normalized, reason: 'already-in-ledger' };
+  }
+  mkdirSync(intakeLedgerDir(root), { recursive: true });
+  const db = new Database(join(intakeLedgerDir(root), 'events.sqlite'), { create: true });
+  db.exec('PRAGMA busy_timeout = 5000');
+  try {
+    db.exec(`CREATE TABLE IF NOT EXISTS intake_events (
+      url TEXT PRIMARY KEY, day TEXT NOT NULL, status TEXT NOT NULL, task_id TEXT, claimed_at TEXT
+    )`);
+    const columns = db.query('PRAGMA table_info(intake_events)').all() as { name: string }[];
+    if (!columns.some((column) => column.name === 'claimed_at')) db.exec('ALTER TABLE intake_events ADD COLUMN claimed_at TEXT');
+    // One row per claim that reached the task queue — the KST-day quota counts these, not current statuses.
+    db.exec('CREATE TABLE IF NOT EXISTS intake_event_claims (url TEXT NOT NULL, day TEXT NOT NULL, claimed_at TEXT NOT NULL, PRIMARY KEY (url, claimed_at))');
+    const claim = db.transaction((): 'scheduled' | 'deferred' | 'duplicate' => {
+      const previous = db.query('SELECT status, task_id, claimed_at, day FROM intake_events WHERE url = ?').get(normalized) as EventClaim | null;
+      if (previous && activeEventClaim(previous, now, eventTaskStatus)) {
+        if (previous.task_id && eventTaskStatus(previous.task_id)?.status === 'done') {
+          db.query("UPDATE intake_events SET status = 'completed' WHERE url = ?").run(normalized);
+        }
+        return 'duplicate';
+      }
+      if (previous && previous.status !== 'failed' && previous.status !== 'expired'
+        && previous.status !== 'pending' && previous.status !== 'scheduled') {
+        return previous.status === 'deferred' ? 'deferred' : 'duplicate';
+      }
+      const count = db.query('SELECT count(*) AS n FROM intake_event_claims WHERE day = ?').get(day) as { n: number };
+      const status = count.n >= max ? 'deferred' : 'pending';
+      db.query(`INSERT INTO intake_events (url, day, status, claimed_at) VALUES (?, ?, ?, ?)
+        ON CONFLICT(url) DO UPDATE SET day = excluded.day, status = excluded.status, claimed_at = excluded.claimed_at, task_id = NULL`)
+        .run(normalized, day, status, now);
+      if (status === 'pending') db.query('INSERT OR IGNORE INTO intake_event_claims (url, day, claimed_at) VALUES (?, ?, ?)').run(normalized, day, now);
+      return status === 'pending' ? 'scheduled' : 'deferred';
+    })();
+    if (claim === 'duplicate') return { status: 'duplicate', url: normalized, reason: 'already-claimed' };
+    if (claim === 'deferred') {
+      ingestIntakeItems(root, 'telegram-bot', [{ url: normalized }], now);
+      debug.log('intake.event', 'deferred', { url: normalized, reason: 'event-max' });
+      return { status: 'deferred', url: normalized, reason: 'event-max', reply: INTAKE_EVENT_DEFERRED_REPLY };
+    }
+    let posted: { taskId: string };
+    try {
+      ingestIntakeItems(root, 'telegram-bot', [{ url: normalized }], now);
+      posted = await opts.post({ url: normalized });
+      if (!posted.taskId) throw new Error('intake event post returned no taskId');
+    } catch (error) {
+      db.query('DELETE FROM intake_events WHERE url = ? AND status = ? AND claimed_at = ?').run(normalized, 'pending', now);
+      db.query('DELETE FROM intake_event_claims WHERE url = ? AND claimed_at = ?').run(normalized, now);
+      throw error;
+    }
+    db.query("UPDATE intake_events SET status = 'scheduled', task_id = ? WHERE url = ? AND status = 'pending' AND claimed_at = ?")
+      .run(posted.taskId, normalized, now);
+    debug.log('intake.event', 'scheduled', { url: normalized, reason: 'telegram-absorb' });
+    return { status: 'scheduled', url: normalized, reason: 'telegram-absorb' };
+  } finally {
+    db.close();
+  }
+}
+
+/** Only an active task or a fresh claim excludes a URL from the daily queue. */
+export function wasIntakeEventScheduled(root: string, url: string, now = new Date().toISOString(), taskStatus: IntakeEventTaskProbe = eventTaskStatus): boolean {
+  const file = join(intakeLedgerDir(root), 'events.sqlite');
+  if (!existsSync(file)) return false;
+  const normalized = canonicalUrl(url);
+  if (!normalized) return false;
+  const db = new Database(file);
+  try {
+    const row = db.query('SELECT status, task_id, claimed_at, day FROM intake_events WHERE url = ?').get(normalized) as EventClaim | null;
+    if (!row || (row.status !== 'scheduled' && row.status !== 'pending')) return row?.status === 'completed';
+    if (activeEventClaim(row, now, taskStatus)) {
+      if (row.task_id && probeStatus(taskStatus, row.task_id).status === 'done') {
+        db.query("UPDATE intake_events SET status = 'completed' WHERE url = ?").run(normalized);
+      }
+      return true;
+    }
+    const status = row.task_id ? probeStatus(taskStatus, row.task_id).status : undefined;
+    db.query("UPDATE intake_events SET status = ? WHERE url = ? AND status IN ('pending', 'scheduled')")
+      .run(status === 'failed' || status === 'cancelled' || status === 'superseded' ? 'failed' : 'expired', normalized);
+    return false;
+  } finally {
+    db.close();
+  }
+}
+
 function appendJsonl(file: string, rows: unknown[]): void {
   if (!rows.length) return;
   mkdirSync(join(file, '..'), { recursive: true });

package/src/intake-plane/wish-benchmark-ledger.ts

@@ -0,0 +1,129 @@
+import { debug } from '../debug/log.js';
+import { constants, closeSync, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, writeSync } from 'node:fs';
+import { basename, dirname, join, parse, resolve } from 'node:path';
+import { dlopen, FFIType } from 'bun:ffi';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+
+/** Bench samples live in the instance's private state, never in a repository or card response. */
+export function wishBenchmarkLedgerPath(root: string = elanousStateRoot()): string {
+  // OP D 길 원장(채널 10-04 22:48)과 같은 파일·같은 줄 꼴 — OP 가 손으로 더하는 줄과 섞여 한 표본이 된다.
+  return join(root, 'bench', 'goal-bench-requirements.jsonl');
+}
+
+function privateDirectory(path: string, privateMode: boolean): void {
+  try { mkdirSync(path, { mode: 0o700 }); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error; }
+  const state = lstatSync(path);
+  if (state.isSymbolicLink() || !state.isDirectory()) throw new Error(`Unsafe wish benchmark directory: ${path}`);
+  const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    if (privateMode) fchmodSync(fd, 0o700);
+    const opened = fstatSync(fd);
+    if (opened.dev !== state.dev || opened.ino !== state.ino) {
+      throw new Error(`Wish benchmark directory changed while opening: ${path}`);
+    }
+  } finally { closeSync(fd); }
+}
+
+function realExistingPrefix(path: string): string {
+  let head = path; const tail: string[] = [];
+  for (;;) {
+    try { return join(realpathSync(head), ...tail.reverse()); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      const parent = dirname(head); if (parent === head) return path;
+      tail.push(basename(head)); head = parent;
+    }
+  }
+}
+
+function preparePrivateDirectory(root: string): string {
+  // 맥에서 `/var` 는 `/private/var` 링크다 — 이미 있는 상위 경로는 실제 경로로 풀고, 새로 만들 아래 칸만 링크를 막는다.
+  const absolute = realExistingPrefix(resolve(root));
+  let current = parse(absolute).root;
+  const parts = absolute.slice(current.length).split(/[\\/]/).filter(Boolean);
+  for (const part of parts) {
+    current = join(current, part);
+    // A sample cannot be written inside a source checkout, even if the state root was overridden.
+    try {
+      lstatSync(join(current, '.git'));
+      throw new Error(`Wish benchmark state root is inside a repository: ${current}`);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+    privateDirectory(current, false);
+  }
+  for (const part of ['bench']) {
+    current = join(current, part);
+    privateDirectory(current, true);
+  }
+  return current;
+}
+
+// Advisory locks belong to the open descriptor, not the pathname: SIGKILL closes it automatically.
+// Keep the lock file itself in place so no competing writer can lock a different inode.
+const libc = dlopen(process.platform === 'darwin' ? '/usr/lib/libSystem.B.dylib' : 'libc.so.6', {
+  flock: { args: [FFIType.int, FFIType.int], returns: FFIType.int },
+});
+
+function withLedgerLock(dir: string, action: () => void): void {
+  const lock = join(dir, '.wish-cards.lock');
+  const fd = openSync(lock, constants.O_RDWR | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+  try {
+    const opened = fstatSync(fd);
+    if (!opened.isFile() || opened.nlink !== 1) throw new Error('Unsafe wish benchmark lock');
+    fchmodSync(fd, 0o600);
+    // LOCK_EX blocks rather than stealing a live writer's lock. Kernel releases it on crash.
+    if (libc.symbols.flock(fd, 2) !== 0) throw new Error('Wish benchmark ledger lock failed');
+    const current = lstatSync(lock);
+    if (opened.dev !== current.dev || opened.ino !== current.ino) throw new Error('Wish benchmark lock changed while waiting');
+    action();
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export function recordWishBenchmarkSample(
+  sample: { cardId: string; at: string; surface: string; text: string },
+): void {
+  const stateRoot = elanousStateRoot();
+  const dir = preparePrivateDirectory(stateRoot);
+  const expected = lstatSync(dir);
+  const path = wishBenchmarkLedgerPath(stateRoot);
+  withLedgerLock(dir, () => {
+    const current = lstatSync(dir);
+    if (!current.isDirectory() || current.dev !== expected.dev || current.ino !== expected.ino) {
+      throw new Error('Wish benchmark directory changed while waiting for lock');
+    }
+    // Re-check under the lock: another process may have recorded this card while we waited.
+    const fd = openSync(path, constants.O_RDWR | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+    try {
+      const state = fstatSync(fd);
+      if (!state.isFile() || state.nlink !== 1) throw new Error('Wish benchmark ledger is not a private regular file');
+      fchmodSync(fd, 0o600);
+      if (readFileSync(fd, 'utf8').split('\n').some(line => {
+        if (!line) return false;
+        const row = JSON.parse(line) as { id?: string; cardId?: string };
+        return (row.id ?? row.cardId) === sample.cardId;
+      })) return;
+      // 줄 꼴 = OP 원장과 같다: id · at · surface · text(원문 그대로) · chars · op_cells(참조 칸 — OP 가 채운다) · note.
+      const line = JSON.stringify({ id: sample.cardId, at: sample.at, surface: sample.surface, text: sample.text,
+        chars: Array.from(sample.text).length, op_cells: [], note: 'wish-card' }) + '\n';
+      writeSync(fd, line);
+    } finally {
+      closeSync(fd);
+    }
+  });
+}
+
+/** 카드 생성 경로용: 벤치 원장 쓰기가 실패해도(저장소 안 상태 루트 · 권한 · 링크) 소원 카드는 만들어져야 한다.
+ *  실패는 관측 한 줄로만 남긴다(원문은 싣지 않는다). */
+export function recordWishBenchmarkSampleSafely(sample: Parameters<typeof recordWishBenchmarkSample>[0]): boolean {
+  try {
+    recordWishBenchmarkSample(sample);
+    return true;
+  } catch (error) {
+    debug.log('intake.wish-bench', 'skipped', { cardId: sample.cardId, surface: sample.surface, reason: String((error as Error)?.message ?? error).split(':')[0] });
+    return false;
+  }
+}

package/src/intake-plane/wish-card.ts

@@ -1,13 +1,54 @@
 import { debug } from '../debug/log.js';
 import { CardStore } from '../task-cards/card-store.js';
+import { recordWishBenchmarkSampleSafely } from './wish-benchmark-ledger.js';
+
+export type WishReplyTarget =
+  | { surface: 'telegram'; chatId: string; threadId?: string; botId?: string }
+  | { surface: 'pwa'; sessionId: string }
+  | { surface: 'linear'; issueId: string }
+  | { surface: 'tui' };
+
+/** `intake:reply:0` 섹션 꼴 — surface ⊕ 표면 안 주소(텔레그램 대화 · PWA 세션 · Linear 이슈 · TUI 없음). */
+export function replySection(target: WishReplyTarget): { surface: WishReplyTarget['surface']; address: string | null } {
+  switch (target.surface) {
+    case 'telegram': return { surface: 'telegram', address: target.threadId ? `${target.chatId}:${target.threadId}` : target.chatId };
+    case 'pwa': return { surface: 'pwa', address: target.sessionId };
+    case 'linear': return { surface: 'linear', address: target.issueId };
+    case 'tui': return { surface: 'tui', address: null };
+  }
+}
+
+export type WishInput = {
+  text: string;
+  source: WishReplyTarget['surface'];
+  ref: string;
+  replyTo?: WishReplyTarget;
+};
+
+function replyTarget(input: WishInput): WishReplyTarget {
+  if (input.replyTo) {
+    if (input.replyTo.surface !== input.source) throw new Error('소원 출처와 회신 대상이 다릅니다');
+    return input.replyTo;
+  }
+  switch (input.source) {
+    case 'telegram': return { surface: 'telegram', chatId: input.ref.split(':', 1)[0]! };
+    case 'pwa':
+    case 'linear': throw new Error('소원 회신 대상을 명시하세요');
+    case 'tui': return { surface: 'tui' };
+  }
+}
 
 export function createWishCard(
-  { text, source, ref }: { text: string; source: 'telegram' | 'pwa' | 'tui' | 'linear'; ref: string },
+  { text, source, ref, replyTo }: WishInput,
   store: CardStore = new CardStore(),
 ): { cardId: string; title: string; created: boolean } {
   const title = text.trim().split(/\r?\n/, 1)[0]!.trim().slice(0, 80);
   if (!title) throw new Error('소원 글을 입력하세요');
   if (!ref?.trim()) throw new Error('소원 참조가 필요합니다');
+  const target = replyTarget({ text, source, ref, replyTo });
+  if (target.surface === 'telegram' && !/^-?\d+$/.test(target.chatId)
+    || target.surface === 'pwa' && !target.sessionId.trim()
+    || target.surface === 'linear' && !target.issueId.trim()) throw new Error('소원 회신 대상이 필요합니다');
   const goalId = `wish:${source}:${ref}`;
   const old = store.listCards().find(card => card.goalId === goalId);
   const card = old ?? store.createCard({ goalId, title });
@@ -22,12 +63,22 @@ export function createWishCard(
       key: 'intake:wish:0',
       owner: 'steward',
       content: JSON.stringify({
-        source, ref, title: card.title, text: sameRequest ? text : null, at: new Date().toISOString(),
+        source, ref, replyTo: target, title: card.title, text: sameRequest ? text : null, at: new Date().toISOString(),
         ...(old ? { recovered: true } : {}), ...(sameRequest ? {} : { mismatch: true }),
       }),
     });
     if (!sameRequest) debug.log('intake.wish', 'recovered-mismatch', { source, cardId: card.id });
   }
+  // FLOW1 원장 약속(TC 21:15): 회신 주소를 `intake:reply:0 {surface, address}` 로도(원장 섹션 허용 목록상 `intake` 아래) 남긴다 — FLOW1a 는 이 꼴을 읽고
+  // 보내기는 `sendCardReply(cardId, text)` 만 부른다(wish-reply.ts). 원천은 위 intake 섹션의 replyTo 그대로.
+  if (!card.sections.some(section => section.key === 'intake:reply:0')) {
+    store.appendSection(card.id, { key: 'intake:reply:0', owner: 'steward', content: JSON.stringify(replySection(target)) });
+  }
+  const originalIntake = store.getCard(card.id)?.sections.find(section => section.key === 'intake:wish:0');
+  if (originalIntake) {
+    const first = JSON.parse(originalIntake.content) as { source: WishInput['source']; text: string | null; at: string };
+    if (first.text !== null) recordWishBenchmarkSampleSafely({ cardId: card.id, at: first.at, surface: first.source, text: first.text });
+  }
   debug.log('intake.wish', created ? 'created' : 'duplicate', { source, cardId: card.id });
   return { cardId: card.id, title: card.title, created };
 }

package/src/intake-plane/wish-folder.ts

@@ -1,6 +1,7 @@
 import { readdirSync, readFileSync, statSync, type Dirent } from 'node:fs';
 import { basename, join, relative } from 'node:path';
 import { CardStore } from '../task-cards/card-store.js';
+import { recordWishBenchmarkSampleSafely } from './wish-benchmark-ledger.js';
 
 export interface WishScanResult {
   added: number;
@@ -52,9 +53,11 @@ export function scanWishFolder({ dir, store }: { dir: string; store: CardStore }
       result.skipped++;
       continue;
     }
-    const title = /^# (.+)$/m.exec(readFileSync(path, 'utf8'))?.[1]?.trim() || basename(path, '.md');
+    const text = readFileSync(path, 'utf8');
+    const title = /^# (.+)$/m.exec(text)?.[1]?.trim() || basename(path, '.md');
     const card = old ?? store.createCard({ goalId, title });
-    const intake = { source: 'wish', path: relPath, mtime, title };
+    if (intakeSections.length === 0) recordWishBenchmarkSampleSafely({ cardId: card.id, at: card.createdAt, surface: 'wish', text });
+    const intake = { source: 'wish', path: relPath, mtime, title, text };
     store.appendSection(card.id, {
       key: `intake:wish:${intakeSections.length}`,
       owner: 'steward',