elanous 0.2.42 → 0.2.43

package/src/intake-plane/actions.ts

@@ -1,4 +1,13 @@
+import { BriefItemsLedger } from '../briefing/brief-items.js';
+import { EventLedger } from '../connectors/event-ledger.js';
+import { commentLinearIssue, moveLinearIssueToStateType } from '../connectors/linear.js';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
 import { captureAndDraftIntakeRecord } from './capture.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { addSource, canonicalSeat, listSources, removeSource, runDue, type RunDueDeps, type RegisteredIntakeSource } from './intake-sources.js';
 import {
   applyClarifyAnswerToDraft,
   buildDecisionFromIntent,
@@ -10,6 +19,351 @@ import {
   proposeIntakeSessionToTox,
 } from './tox-adapter.js';
 import type { IntakeSession, RawIntakeRecord } from './types.js';
+import type { BriefItem } from '../briefing/brief-items.js';
+
+export interface TopicBriefingDeliveryDeps {
+  sendIssueCard: (input: { linearIssueId: string; text: string }) => Promise<void>;
+  commentIssue: (linearIssueId: string, text: string) => Promise<void>;
+  issueIsDone: (linearIssueId: string) => Promise<boolean>;
+  isDecisionImpacting: (items: readonly BriefItem[]) => Promise<boolean>;
+  reopenIssue: (linearIssueId: string) => Promise<void>;
+  sendMemoUpdateCard: (input: { linearIssueId: string; text: string }) => Promise<void>;
+}
+
+interface TopicBriefingDeliveryReceipt {
+  telegramSent: boolean;
+  linearCommented: boolean;
+  reopened: boolean;
+  memoSent: boolean;
+  updatedAt: string;
+}
+
+function topicBriefingReceiptsFile(stateDir: string): string { return join(stateDir, 'intake', 'topic-briefing-deliveries.json'); }
+
+function readTopicBriefingReceipts(stateDir: string): Record<string, TopicBriefingDeliveryReceipt> {
+  const file = topicBriefingReceiptsFile(stateDir);
+  if (!existsSync(file)) return {};
+  const parsed: unknown = JSON.parse(readFileSync(file, 'utf8'));
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error(`topic briefing receipt ledger shape invalid: ${file}`);
+  return parsed as Record<string, TopicBriefingDeliveryReceipt>;
+}
+
+function saveTopicBriefingReceipts(stateDir: string, receipts: Record<string, TopicBriefingDeliveryReceipt>): void {
+  const file = topicBriefingReceiptsFile(stateDir);
+  mkdirSync(join(stateDir, 'intake'), { recursive: true });
+  const temp = `${file}.${randomUUID()}.tmp`;
+  try {
+    const fd = openSync(temp, 'wx', 0o600);
+    try { writeFileSync(fd, JSON.stringify(receipts, null, 2) + '\n'); } finally { closeSync(fd); }
+    chmodSync(temp, 0o600);
+    renameSync(temp, file);
+  } catch (error) {
+    if (existsSync(temp)) unlinkSync(temp);
+    throw error;
+  }
+}
+
+/** Persist each external delivery stage so a later channel failure cannot resend a successful Telegram card/comment. */
+export async function deliverTopicBriefingWithReceipts(input: {
+  linearIssueId: string;
+  issueLabel?: string;
+  summary: string;
+  items: readonly BriefItem[];
+}, stateDir: string, deps: TopicBriefingDeliveryDeps, mode: 'live' | 'telegram-dry-run' = 'live'): Promise<{ related: number; reopened: boolean }> {
+  const receiptKey = createHash('sha256').update(`${mode}\n${input.linearIssueId.toLowerCase()}\n${input.items.map(item => item.id).sort((a, b) => a - b).join(',')}`).digest('hex');
+  const receipts = readTopicBriefingReceipts(stateDir);
+  const receipt = receipts[receiptKey] ?? { telegramSent: false, linearCommented: false, reopened: false, memoSent: false, updatedAt: '' };
+  const saveReceipt = (): void => {
+    receipt.updatedAt = new Date().toISOString();
+    receipts[receiptKey] = receipt;
+    const expiry = Date.now() - 90 * 86_400_000;
+    for (const [key, value] of Object.entries(receipts)) if (Date.parse(value.updatedAt) < expiry) delete receipts[key];
+    saveTopicBriefingReceipts(stateDir, receipts);
+  };
+  return deliverTopicBriefing(input, {
+    ...deps,
+    sendIssueCard: async card => { if (!receipt.telegramSent) { await deps.sendIssueCard(card); receipt.telegramSent = true; saveReceipt(); } },
+    commentIssue: async (issueId, text) => { if (!receipt.linearCommented) { await deps.commentIssue(issueId, text); receipt.linearCommented = true; saveReceipt(); } },
+    issueIsDone: async issueId => receipt.reopened || await deps.issueIsDone(issueId),
+    isDecisionImpacting: async items => receipt.reopened || await deps.isDecisionImpacting(items),
+    reopenIssue: async issueId => { if (!receipt.reopened) { await deps.reopenIssue(issueId); receipt.reopened = true; saveReceipt(); } },
+    sendMemoUpdateCard: async card => { if (!receipt.memoSent) { await deps.sendMemoUpdateCard(card); receipt.memoSent = true; saveReceipt(); } },
+  });
+}
+
+export function isDecisionImpactingTopicEvidence(items: readonly BriefItem[]): boolean {
+  const decisionTerms = /(?:파산|부도|법정관리|사업 철수|공장 폐쇄|생산 중단|공급 중단|제재|소송|(?:계약|주문|공급|생산|투자|가이던스|실적|매출|수익|전망)(?:이|가|을|를|은|는)?\s*(?:취소|파기|철회|중단|감산|급감|감소|축소|하향|하락|적자 전환|대폭 삭감)|\b(?:bankruptcy|default|plant closure|business exit|production halt|supply halt|sanction|lawsuit|withdrawn|terminated)\b|\b(?:contract|order|supply|production|investment|guidance|earnings|revenue|profit|outlook)\s+(?:cancelled?|terminated|withdrawn|suspended|cut|reduced|downgraded|loss|miss)\b)/iu;
+  return items.some(item => decisionTerms.test(item.text));
+}
+
+/** Project only issue-linked findings; scheduled callers may invoke this after every run, including after Done. */
+export async function deliverTopicBriefing(input: {
+  linearIssueId: string;
+  issueLabel?: string;
+  summary: string;
+  items: readonly BriefItem[];
+}, deps: TopicBriefingDeliveryDeps): Promise<{ related: number; reopened: boolean }> {
+  const related = input.items.filter(item => item.linearIssueId?.toLowerCase() === input.linearIssueId.toLowerCase());
+  if (related.length === 0) return { related: 0, reopened: false };
+  const sources = related.map(item => item.evidence).filter((url): url is string => !!url);
+  const text = `관련 이슈 · ${input.issueLabel?.trim() || input.linearIssueId}\n\n${input.summary.trim()}${sources.length ? `\n\n출처\n${sources.map(url => `- ${url}`).join('\n')}` : ''}`;
+  await deps.sendIssueCard({ linearIssueId: input.linearIssueId, text });
+  await deps.commentIssue(input.linearIssueId, text);
+  const reopened = await deps.issueIsDone(input.linearIssueId) && await deps.isDecisionImpacting(related);
+  if (reopened) {
+    await deps.reopenIssue(input.linearIssueId);
+    await deps.sendMemoUpdateCard({ linearIssueId: input.linearIssueId,
+      text: `관련 이슈 · ${input.issueLabel?.trim() || input.linearIssueId}\n메모 갱신?\n\n${input.summary.trim()}` });
+  }
+  return { related: related.length, reopened };
+}
+
+/** Production adapter used by both the immediate subscription run and each existing daemon schedule fire. */
+export function appendTopicBriefingTelegramDryRun(file: string, input: { linearIssueId: string; text: string; kind: 'issue' | 'memo' }): void {
+  appendFileSync(file, `${JSON.stringify({ recordedAt: new Date().toISOString(), ...input })}\n`, { encoding: 'utf8', mode: 0o600 });
+  chmodSync(file, 0o600);
+}
+
+export async function projectTopicBriefing(source: RegisteredIntakeSource, items: BriefItem[], stateDir = effectiveInstanceRoot(),
+  options: { telegramDryRunFile?: string } = {}): Promise<void> {
+  if (!source.linearIssueId || items.length === 0) return;
+  const [{ getSecretAsync }, { commentLinearIssue, fetchLinearIssueStateType, moveLinearIssueToStateType },
+    { kindRouteTarget }, { getUserConfig }, { sendTelegramTo }] = await Promise.all([
+    import('../nexus/config/secrets/index.js'), import('../connectors/linear.js'), import('../domains/telegram-kind-route.js'),
+    import('../user-config.js'), import('../autopilot/mission-notify.js'),
+  ]);
+  const target = options.telegramDryRunFile ? undefined : kindRouteTarget(getUserConfig(), 'ops-report');
+  if (!options.telegramDryRunFile && !target) throw new Error('관련 이슈 브리핑 Telegram ops-report 대상이 없습니다');
+  const send = async (text: string, kind: 'issue' | 'memo'): Promise<void> => {
+    if (options.telegramDryRunFile) {
+      appendTopicBriefingTelegramDryRun(options.telegramDryRunFile, { linearIssueId: source.linearIssueId!, text, kind });
+      return;
+    }
+    if (!target || !sendTelegramTo(target.botToken, target.chatId, text)) throw new Error('관련 이슈 브리핑 Telegram 발송 실패');
+  };
+  const apiKey = await getSecretAsync('connector.linear.apiKey');
+  if (!apiKey) throw new Error('Linear 키가 없습니다');
+  await deliverTopicBriefingWithReceipts({ linearIssueId: source.linearIssueId, issueLabel: source.spec,
+    summary: items.map(item => item.text).join('\n'), items }, stateDir, {
+    sendIssueCard: async ({ text }) => send(text, 'issue'),
+    commentIssue: async (issueId, body) => commentLinearIssue({ apiKey, issueId, body }),
+    issueIsDone: async issueId => await fetchLinearIssueStateType({ apiKey, issueId }) === 'completed',
+    isDecisionImpacting: async related => isDecisionImpactingTopicEvidence(related),
+    reopenIssue: async issueId => moveLinearIssueToStateType({ apiKey, issueId, type: 'started' }),
+    sendMemoUpdateCard: async ({ text }) => send(text, 'memo'),
+  }, options.telegramDryRunFile ? 'telegram-dry-run' : 'live');
+}
+
+export interface SubscribeTopicSearchInput {
+  seat: string;
+  topic: string;
+  /** Parent Linear issue.id UUID (`ExternalTaskEvent.ref` / task generatedBy.ref). */
+  linearIssueId: string;
+  every: string;
+  /** Per-subscription five-field cron, e.g. `0 8 * * 1` for Mondays at 08:00. */
+  scheduleCron: string;
+  /** Absolute path receiving Telegram message bodies instead of live sends. */
+  telegramDryRunFile?: string;
+}
+
+export interface SubscribeTopicSearchDeps {
+  stateDir?: string;
+  now?: Date;
+  runDue?: typeof runDue;
+  sourceAdd?: typeof addSource;
+  sourceList?: typeof listSources;
+  sourceRemove?: typeof removeSource;
+  scheduleDispatch?: (args: Record<string, unknown>) => Promise<unknown>;
+  runDeps?: RunDueDeps;
+}
+
+function scheduleError(result: unknown): string | null {
+  return result && typeof result === 'object' && 'error' in result ? String((result as { error: unknown }).error) : null;
+}
+
+/**
+ * Linear secretary handoff: register one issue-linked topic source, create and
+ * migrate exactly one existing schedule-registry job to the workflow daemon,
+ * then run that same source immediately through runDue.
+ */
+export async function subscribeTopicSearch(input: SubscribeTopicSearchInput, deps: SubscribeTopicSearchDeps = {}): Promise<{
+  source: RegisteredIntakeSource;
+  scheduleId: string;
+  immediate: Awaited<ReturnType<typeof runDue>>;
+}> {
+  const stateDir = deps.stateDir ?? effectiveInstanceRoot();
+  const normalizedTopic = input.topic.trim();
+  if (!normalizedTopic) throw new Error('topic-search topic이 비었다');
+  const seat = canonicalSeat(input.seat);
+  const sourceId = `topic-${createHash('sha256').update(`${seat}\n${input.linearIssueId.toLowerCase()}\n${normalizedTopic.toLowerCase()}`)
+    .digest('hex').slice(0, 20)}`;
+  const sources = deps.sourceList ?? listSources;
+  const add = deps.sourceAdd ?? addSource;
+  const remove = deps.sourceRemove ?? removeSource;
+  const existing = sources({}, stateDir).find((source) => source.id === sourceId);
+  let source: RegisteredIntakeSource;
+  let created = false;
+  let scheduleCreatedNow = false;
+  if (existing) {
+    if (existing.kind !== 'topic-search' || existing.linearIssueId?.toLowerCase() !== input.linearIssueId.toLowerCase()
+      || existing.spec.toLowerCase() !== normalizedTopic.toLowerCase() || existing.scheduleCron !== input.scheduleCron) {
+      throw new Error(`topic-search source identity collision: ${sourceId}`);
+    }
+    source = existing;
+  } else {
+    source = add({ id: sourceId, seat, kind: 'topic-search', spec: normalizedTopic,
+      every: input.every, scheduleCron: input.scheduleCron, linearIssueId: input.linearIssueId }, stateDir);
+    created = true;
+  }
+
+  const dispatch = deps.scheduleDispatch ?? (async (args: Record<string, unknown>) => {
+    const { dispatchScheduleManage } = await import('../domains/schedule-manage-tool.js');
+    return dispatchScheduleManage(args);
+  });
+  const dryRunArg = input.telegramDryRunFile
+    ? ` --telegram-dry-run-file '${input.telegramDryRunFile.replaceAll("'", "'\\''")}'` : '';
+  const command = `eln intake source run-due --source-id ${sourceId} --project-issue-briefing${dryRunArg}`;
+  let scheduleId: string | undefined;
+  const createSchedule = async (): Promise<void> => {
+      const creation = await dispatch({ action: 'create', cron: input.scheduleCron, command, category: 'ingest' });
+      const createError = scheduleError(creation);
+      if (createError) throw new Error(`topic-search 일정 등록 실패: ${createError}`);
+      scheduleCreatedNow = true;
+      // Crontab inventory derives category from the command, so the created
+      // job may appear under maintenance instead of the requested ingest
+      // category. Match by exact command + cron across the registry.
+      const listing = await dispatch({ action: 'list' }) as { schedules?: Array<{ id?: string; command?: string; cron?: string }> };
+      const listError = scheduleError(listing);
+      if (listError) throw new Error(`topic-search 일정 목록 확인 실패: ${listError}`);
+      const match = listing.schedules?.find((row) => row.command === command && row.cron === input.scheduleCron);
+      if (!match?.id) throw new Error('topic-search 일정이 schedule registry에 나타나지 않았다');
+      scheduleId = match.id;
+      const migrated = await dispatch({ action: 'migrate', id: scheduleId, yes: true });
+      const migrateError = scheduleError(migrated);
+      if (migrateError) throw new Error(`topic-search 일정을 데몬으로 이관하지 못했다: ${migrateError}`);
+      const noted = await dispatch({ action: 'note', id: scheduleId,
+        note: `topic-search · ${sourceId} · parent Linear UUID ${input.linearIssueId}` });
+      const noteError = scheduleError(noted);
+      if (noteError) throw new Error(`topic-search 일정 설명 저장 실패: ${noteError}`);
+  };
+  try {
+    if (!existing) await createSchedule();
+    else {
+      const listing = await dispatch({ action: 'list' }) as { schedules?: Array<{ id?: string; command?: string; cron?: string }> };
+      const listError = scheduleError(listing);
+      if (listError) throw new Error(`기존 topic-search 일정 목록 확인 실패: ${listError}`);
+      const sourceCommandPrefix = `eln intake source run-due --source-id ${sourceId} --project-issue-briefing`;
+      const conflicting = listing.schedules?.find((row) => row.cron === input.scheduleCron
+        && row.command?.startsWith(sourceCommandPrefix) && row.command !== command);
+      if (conflicting) throw new Error(`기존 topic-search 일정의 Telegram 실행 모드가 다르다; 중복 예약을 피하려면 기존 일정부터 제거해야 한다: ${conflicting.id ?? sourceId}`);
+      const match = listing.schedules?.find((row) => row.command === command && row.cron === input.scheduleCron);
+      if (match?.id) scheduleId = match.id;
+      else await createSchedule();
+    }
+  } catch (error) {
+    if (scheduleCreatedNow) {
+      let orphan = scheduleId;
+      if (!orphan) {
+        try {
+          const listing = await dispatch({ action: 'list' }) as { schedules?: Array<{ id?: string; command?: string; cron?: string }> };
+          orphan = listing.schedules?.find((row) => row.command === command && row.cron === input.scheduleCron)?.id;
+        } catch { /* source cleanup below remains primary */ }
+      }
+      if (orphan) try { await dispatch({ action: 'delete', id: orphan, yes: true }); } catch { /* preserve primary error */ }
+    }
+    if (created) {
+      remove(sourceId, stateDir);
+    }
+    throw error;
+  }
+
+  const immediate = await (deps.runDue ?? runDue)({ now: deps.now ?? new Date(), seat, sourceId,
+    deps: { ...deps.runDeps, stateDir, projectTopicBriefing: deps.runDeps?.projectTopicBriefing ?? (input.telegramDryRunFile
+      ? (registered, items, dir) => projectTopicBriefing(registered, items, dir, { telegramDryRunFile: input.telegramDryRunFile })
+      : projectTopicBriefing) } });
+  return { source, scheduleId: scheduleId!, immediate };
+}
+
+export interface IntakeIssueBriefingEvidence {
+  title: string;
+  url: string;
+  summary: string;
+  reopensIssue?: boolean;
+}
+
+export interface IntakeIssueBriefingInput {
+  issueRef: string;
+  topic: string;
+  state: 'open' | 'done';
+  evidence: readonly IntakeIssueBriefingEvidence[];
+  collected?: boolean;
+}
+
+export interface IntakeIssueBriefingDeps {
+  stateDir: string;
+  ledger?: BriefItemsLedger;
+  registerSource?: (source: RegisteredIntakeSource) => void;
+  runSources?: () => Promise<{ ran: Array<{ id: string; items: number; error?: string }> }>;
+  commentIssue?: (issueRef: string, body: string) => Promise<void>;
+  reopenIssue?: (issueRef: string) => Promise<void>;
+}
+
+function issueWatchId(issueRef: string): string {
+  return `watch-${issueRef.replace(/[^\w.-]+/g, '-')}`;
+}
+
+function issueBriefingComment(input: IntakeIssueBriefingInput, evidence: readonly IntakeIssueBriefingEvidence[]): string {
+  return [`## 흡수 브리핑 · ${input.issueRef}`, ...evidence.map(item => `- ${item.title}: ${item.summary} (${item.url})`)].join('\n');
+}
+
+async function defaultCommentIssue(stateDir: string, issueRef: string, body: string): Promise<void> {
+  const apiKey = await getSecretAsync('connector.linear.apiKey');
+  if (!apiKey?.trim()) return;
+  await commentLinearIssue({ apiKey, issueId: issueRef, body });
+  const hash = createHash('sha256').update(body).digest('hex');
+  new EventLedger(join(stateDir, 'connectors', 'events.jsonl')).record('linear', `outgoing:comment:brief:${issueRef}:${hash}`, {
+    ref: issueRef, occurredAt: new Date().toISOString(),
+  });
+}
+
+async function defaultReopenIssue(stateDir: string, issueRef: string): Promise<void> {
+  const apiKey = await getSecretAsync('connector.linear.apiKey');
+  if (!apiKey?.trim()) return;
+  await moveLinearIssueToStateType({ apiKey, issueId: issueRef, type: 'started' });
+  new EventLedger(join(stateDir, 'connectors', 'events.jsonl')).record('linear', `outgoing:reopen:brief:${issueRef}:${Date.now()}`, {
+    ref: issueRef, occurredAt: new Date().toISOString(),
+  });
+}
+
+/**
+ * The intake-daily bridge preserves the Linear secretary identifier from subscription through the briefing ledger.
+ * Open issues receive evidence cards and Linear comments; a material event on a done issue records a memo-update card and reopens it.
+ */
+export async function runIntakeIssueBriefing(input: IntakeIssueBriefingInput, deps: IntakeIssueBriefingDeps): Promise<void> {
+  if (!input.issueRef.trim() || !input.topic.trim()) throw new Error('issueRef and topic are required');
+  const source: RegisteredIntakeSource = {
+    id: issueWatchId(input.issueRef), seat: 'user', kind: 'github-query', spec: input.topic, every: '1d',
+    why: `linear-secretary:${input.issueRef}`, issueRef: input.issueRef,
+  };
+  if (deps.registerSource) deps.registerSource(source);
+  else if (!listSources({}, deps.stateDir).some(entry => entry.id === source.id)) addSource(source, deps.stateDir);
+  if (!input.collected) await (deps.runSources ?? (() => runDue({ deps: { stateDir: deps.stateDir } })))();
+
+  const relevant = input.state === 'open' ? input.evidence : input.evidence.filter(item => item.reopensIssue === true);
+  if (relevant.length === 0) return;
+  const ledger = deps.ledger ?? new BriefItemsLedger({ stateDir: deps.stateDir });
+  for (const item of relevant) {
+    ledger.add({
+      text: input.state === 'done' ? `메모 갱신? ${item.title}: ${item.summary}` : `${item.title}: ${item.summary}`,
+      domain: '흡수', priority: item.reopensIssue ? 'P0' : 'P1', source: 'intake-daily', evidence: item.url, issueRef: input.issueRef,
+    });
+  }
+  const body = issueBriefingComment(input, relevant);
+  await (deps.commentIssue ?? ((issueRef, comment) => defaultCommentIssue(deps.stateDir, issueRef, comment)))(input.issueRef, body);
+  if (input.state === 'done' && relevant.some(item => item.reopensIssue)) {
+    await (deps.reopenIssue ?? (issueRef => defaultReopenIssue(deps.stateDir, issueRef)))(input.issueRef);
+  }
+}
 
 export interface ReplayIntakeResult {
   sourceId: string;

package/src/intake-plane/adapters/telegram-ambient.ts

@@ -1,6 +1,8 @@
 import { maybeHandleAmbientTextIntake } from '../ambient.js';
 import type { IntakeAmbientCaptureMode } from '../../user-config.js';
 
+const LINEAR_SECRETARY_INTENT = /(?:리니어|linear)(?:로|에|에다)?\s*(?:등록해(?:줘요?|주세요)?|정리해(?:줘요?|주세요)|쪼개(?:줘요?|주세요)|맡겨(?:줘요?|주세요)|만들어(?:줘요?|주세요))(?!\s*(?:라고|하던데|했는데|하라던데|해달라고|하라며))/i;
+
 export interface TelegramAmbientMessageContext {
   text: string;
   chatId: number | string;
@@ -10,22 +12,36 @@ export interface TelegramAmbientMessageContext {
   ambientCapture?: IntakeAmbientCaptureMode;
 }
 
-export async function maybeHandleTelegramAmbientMessage(
-  ctx: TelegramAmbientMessageContext,
-): Promise<string | null> {
-  if (!ctx.text || ctx.text.startsWith('/')) return null;
-  return maybeHandleAmbientTextIntake({
-    surface: 'telegram',
-    source: 'telegram',
-    text: ctx.text,
-    actor: {
-      id: String(ctx.userId),
-      ...(ctx.userName ? { display: ctx.userName } : {}),
-    },
-    channelContext: {
-      chatId: String(ctx.chatId),
-      ...(ctx.threadId != null ? { threadId: String(ctx.threadId) } : {}),
-    },
-    mode: ctx.ambientCapture ?? 'off',
-  });
+export function createTelegramAmbientMessageHandler(deps: {
+  runSecretary?: (request: string) => Promise<{ replyCard: string }>;
+} = {}) {
+  return async function maybeHandleTelegramAmbientMessage(ctx: TelegramAmbientMessageContext): Promise<string | null> {
+    if (!ctx.text || ctx.text.startsWith('/')) return null;
+    if (LINEAR_SECRETARY_INTENT.test(ctx.text)) {
+      const runSecretary = deps.runSecretary ?? (async (request: string) =>
+        (await import('../linear-secretary-runtime.js')).runLinearSecretaryRequest(request));
+      try {
+        const result = await runSecretary(ctx.text);
+        return result.replyCard;
+      } catch {
+        return 'Linear 등록을 보류했습니다. 요청 날짜와 근거를 확인한 뒤 다시 시도해 주세요.';
+      }
+    }
+    return maybeHandleAmbientTextIntake({
+      surface: 'telegram',
+      source: 'telegram',
+      text: ctx.text,
+      actor: {
+        id: String(ctx.userId),
+        ...(ctx.userName ? { display: ctx.userName } : {}),
+      },
+      channelContext: {
+        chatId: String(ctx.chatId),
+        ...(ctx.threadId != null ? { threadId: String(ctx.threadId) } : {}),
+      },
+      mode: ctx.ambientCapture ?? 'off',
+    });
+  };
 }
+
+export const maybeHandleTelegramAmbientMessage = createTelegramAmbientMessageHandler();

package/src/intake-plane/intake-sources.ts

@@ -2,20 +2,27 @@ import { randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import cron from 'node-cron';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { findTrack } from '../autopilot/mission-phase-track.js';
 import { appendGithubStarSnapshots, collectGithubStars, ghApiSearchRepos, type SearchGithubRepos } from './collect-github.js';
 import { ingestIntakeItems, parseRawIntakeJsonl, type IntakeSource, type RegisteredIntakeSourceKind, type RawIntakeItem } from './items.js';
 
-export type SourceKind = 'github-query' | 'rss' | 'command';
+export type SourceKind = 'github-query' | 'rss' | 'command' | 'topic-search';
 export interface RegisteredIntakeSource {
   id: string;
   seat: string;
   kind: SourceKind;
   spec: string;
   every: string;
+  /** Per-topic recurring fire time, interpreted by the existing schedule registry/daemon path. */
+  scheduleCron?: string;
   until?: string;
   why?: string;
+  /** Existing Linear secretary issue identifier; absent for ordinary sources. */
+  issueRef?: string;
+  /** Parent Linear issue UUID; never replace with the display identifier. */
+  linearIssueId?: string;
   lastRunAt?: string;
 }
 
@@ -88,11 +95,19 @@ function commandArgv(spec: string): string[] {
 
 export function addSource(input: RegisteredIntakeSource, stateDir = effectiveInstanceRoot()): RegisteredIntakeSource {
   const seat = canonicalSeat(input.seat);
-  if (!['github-query', 'rss', 'command'].includes(input.kind)) throw new Error(`알 수 없는 원천 종류: ${input.kind}`);
+  if (!['github-query', 'rss', 'command', 'topic-search'].includes(input.kind)) throw new Error(`알 수 없는 원천 종류: ${input.kind}`);
   cadenceMs(input.every);
   if (input.until !== undefined) untilMs(input.until);
   if (!input.id?.trim() || !/^[\w.-]+$/.test(input.id)) throw new Error('원천 id 는 영문·숫자·_·-·. 만 허용한다');
   if (!input.spec?.trim()) throw new Error('원천 spec 이 비었다');
+  if (input.linearIssueId !== undefined && (input.kind !== 'topic-search'
+    || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(input.linearIssueId))) {
+    throw new Error('topic-search linearIssueId 는 부모 Linear issue UUID여야 한다');
+  }
+  if (input.kind === 'topic-search' && (!input.linearIssueId || !input.scheduleCron || !cron.validate(input.scheduleCron))) {
+    throw new Error('topic-search 는 부모 Linear UUID와 유효한 개별 schedule cron 이 필요하다');
+  }
+  if (input.kind !== 'topic-search' && input.scheduleCron !== undefined) throw new Error('scheduleCron 은 topic-search 원천만 가질 수 있다');
   if (input.kind === 'rss') {
     let protocol = '';
     try { protocol = new URL(input.spec).protocol; } catch { /* validation below */ }
@@ -118,8 +133,11 @@ export function removeSource(id: string, stateDir = effectiveInstanceRoot()): bo
   return true;
 }
 
-export function dueSources(now: Date = new Date(), stateDir = effectiveInstanceRoot()): RegisteredIntakeSource[] {
-  return listSources({}, stateDir).filter((source) => sourceIsDue(source, now));
+export function dueSources(now: Date = new Date(), stateDir = effectiveInstanceRoot(), sourceId?: string): RegisteredIntakeSource[] {
+  return listSources({}, stateDir).filter((source) => (sourceId === undefined || source.id === sourceId)
+    && (sourceId !== undefined && source.kind === 'topic-search'
+      ? !expiredSource(source, now)
+      : sourceIsDue(source, now)));
 }
 
 export interface RunDueDeps {
@@ -127,7 +145,39 @@ export interface RunDueDeps {
   searchGithub?: SearchGithubRepos;
   fetchFeed?: (url: string) => Promise<string>;
   runCommand?: (command: string) => Promise<string>;
+  searchTopic?: (topic: string) => Promise<RawIntakeItem[]>;
+  addBriefItem?: (input: import('../briefing/brief-items.js').AddBriefItem) => unknown;
+  projectTopicBriefing?: (source: RegisteredIntakeSource, items: import('../briefing/brief-items.js').BriefItem[], stateDir?: string) => Promise<void>;
   ingest?: typeof ingestIntakeItems;
+  onCollected?: (source: RegisteredIntakeSource, raws: RawIntakeItem[], now: Date) => Promise<void> | void;
+}
+
+async function searchTopicWithResearchBridge(topic: string): Promise<RawIntakeItem[]> {
+  const { invokeResearchAxes } = await import('../research-bridge/index.js');
+  const fanout = await invokeResearchAxes([{ id: 'intake-topic', prompt: topic, level: 3, searchTerms: [topic] }]);
+  const evidence = fanout.axes.find((axis) => axis.questionId === 'intake-topic')?.evidence ?? [];
+  return evidence.filter((entry) => entry.outcome !== 'failed' && /^https?:\/\//i.test(entry.source))
+    .map((entry) => {
+      const [title, ...summary] = entry.content.split(' — ');
+      return { url: entry.source, title, text: summary.join(' — ') || entry.content, kind: 'article' };
+    });
+}
+
+async function addTopicBriefItems(stateDir: string, source: RegisteredIntakeSource, items: readonly RawIntakeItem[], createdAt: string,
+  addBriefItem?: RunDueDeps['addBriefItem']): Promise<void> {
+  const ledger = addBriefItem ? null : new (await import('../briefing/brief-items.js')).BriefItemsLedger({ stateDir });
+  for (const item of items) {
+    if (!item.url) continue;
+    const text = `새 토픽 자료: ${(item.title ?? item.text ?? item.url).replace(/[\r\n]+/g, ' ').trim()}`;
+    const input = {
+      text, domain: '흡수' as const, priority: 'P1' as const, source: `intake.topic-search:${source.id}`,
+      evidence: item.url, createdAt,
+      ...(source.linearIssueId ? { linearIssueId: source.linearIssueId } : {}),
+      dedupeKey: `${source.linearIssueId ?? source.id}:${item.url}`, dedupeWithinMs: Math.max(86_400_000, cadenceMs(source.every)),
+    };
+    if (addBriefItem) addBriefItem(input);
+    else ledger!.add(input);
+  }
 }
 
 function xmlText(value: string): string {
@@ -150,11 +200,13 @@ export function parseFeed(xml: string): RawIntakeItem[] {
   }).filter((entry) => !!entry.url);
 }
 
-export async function runDue({ now = new Date(), seat, deps = {} }: { now?: Date; seat?: string; deps?: RunDueDeps } = {}): Promise<{ ran: Array<{ id: string; items: number; error?: string }> }> {
+export async function runDue({ now = new Date(), seat, sourceId, deps = {} }: { now?: Date; seat?: string; sourceId?: string; deps?: RunDueDeps } = {}): Promise<{ ran: Array<{ id: string; items: number; error?: string }> }> {
   const stateDir = deps.stateDir ?? effectiveInstanceRoot();
   const selectedSeat = seat === undefined ? undefined : canonicalSeat(seat);
   const ran: Array<{ id: string; items: number; error?: string }> = [];
-  for (const source of dueSources(now, stateDir).filter((source) => selectedSeat === undefined || source.seat === selectedSeat)) {
+  for (const source of dueSources(now, stateDir, sourceId).filter((source) =>
+    (selectedSeat === undefined || source.seat === selectedSeat)
+      && (source.kind !== 'topic-search' || !!deps.projectTopicBriefing))) {
     try {
       let raws: RawIntakeItem[];
       let githubSnapshots: { day: string; repo: string; stars: number }[] | undefined;
@@ -176,6 +228,9 @@ export async function runDue({ now = new Date(), seat, deps = {} }: { now?: Date
         }))(source.spec);
         raws = parseFeed(feed);
         intakeSource = 'rss';
+      } else if (source.kind === 'topic-search') {
+        raws = await (deps.searchTopic ?? searchTopicWithResearchBridge)(source.spec);
+        intakeSource = 'topic-search';
       } else {
         const argv = commandArgv(source.spec);
         const stdout = await (deps.runCommand ?? (async () => execFileSync(argv[0]!, argv.slice(1), { encoding: 'utf8', timeout: 600_000, maxBuffer: 16 * 1024 * 1024 })))(source.spec);
@@ -188,9 +243,24 @@ export async function runDue({ now = new Date(), seat, deps = {} }: { now?: Date
         raws = parsed.raws;
         intakeSource = 'command';
       }
-      const items = (deps.ingest ?? ingestIntakeItems)(stateDir, intakeSource, raws.map((raw) => ({ ...raw, seat: source.seat })), now.toISOString()).shaped;
+      raws = raws.map((raw) => ({ ...raw, seat: source.seat,
+        ...(source.kind === 'topic-search' && source.linearIssueId ? { linearIssueId: source.linearIssueId } : {}) }));
+      const items = (deps.ingest ?? ingestIntakeItems)(stateDir, intakeSource, raws, now.toISOString()).shaped;
+      if (source.kind === 'topic-search') await addTopicBriefItems(stateDir, source, raws, now.toISOString(), deps.addBriefItem);
+      await deps.onCollected?.(source, raws, now);
       if (githubSnapshots) appendGithubStarSnapshots(stateDir, githubSnapshots);
-      // Re-read after each run so one failure cannot overwrite another source's successful timestamp.
+      if (source.kind === 'topic-search' && source.linearIssueId && deps.projectTopicBriefing) {
+        const { BriefItemsLedger } = await import('../briefing/brief-items.js');
+        const ledger = new BriefItemsLedger({ stateDir });
+        const pending = ledger.list().filter(item => item.source === `intake.topic-search:${source.id}`
+          && item.linearIssueId?.toLowerCase() === source.linearIssueId!.toLowerCase() && item.sent_at === null);
+        if (pending.length) {
+          await deps.projectTopicBriefing(source, pending, stateDir);
+          // This dedicated issue card/comment is the delivery for these brief items.
+          ledger.markSent(pending.map(item => item.id), 'realtime');
+        }
+      }
+      // A projection failure must remain retryable; advance cadence only after delivery succeeds.
       const current = readSources(stateDir);
       const found = current.find((entry) => entry.id === source.id);
       if (found) saveSources(stateDir, current.map((entry) => entry.id === source.id ? { ...entry, lastRunAt: now.toISOString() } : entry));

package/src/intake-plane/items.ts

@@ -8,7 +8,7 @@ import { findTrack } from '../autopilot/mission-phase-track.js';
 import { wasIntakeEventScheduled } from './route.js';
 
 export const INTAKE_SOURCES = ['x', 'youtube', 'github', 'telegram-saved', 'telegram-bot', 'memo', 'pwa'] as const;
-export type RegisteredIntakeSourceKind = 'rss' | 'command';
+export type RegisteredIntakeSourceKind = 'rss' | 'command' | 'topic-search';
 export type IntakeSource = typeof INTAKE_SOURCES[number];
 export type IntakeKind = 'video' | 'repo' | 'post' | 'article' | 'note' | 'rss';
 export type IntakePrivacy = 'public' | 'user-private';
@@ -21,6 +21,8 @@ export interface IntakeItem {
   /** 같은 항목이 다른 입력원에서도 왔으면 여기 모인다 — «두 입력원에서 동시에 뜬 것»이 신호다. */
   sources: (IntakeSource | RegisteredIntakeSourceKind)[];
   seat?: string;
+  /** Parent Linear issue UUID, kept separate from its human-readable identifier. */
+  linearIssueId?: string;
   url?: string;
   kind: IntakeKind;
   title?: string;
@@ -39,6 +41,7 @@ export interface IntakeItem {
 /** 수집기가 내는 한 줄 — 모양 맞추기 전. */
 export interface RawIntakeItem {
   seat?: string;
+  linearIssueId?: string;
   url?: string;
   title?: string;
   text?: string;
@@ -90,10 +93,12 @@ function normalizedSeat(seat: unknown): string | undefined {
   return track.id;
 }
 
-export function intakeItemId(source: IntakeSource | RegisteredIntakeSourceKind, raw: Pick<RawIntakeItem, 'url' | 'text'> & { seat?: string }): string {
+export function intakeItemId(source: IntakeSource | RegisteredIntakeSourceKind,
+  raw: Pick<RawIntakeItem, 'url' | 'text' | 'linearIssueId'> & { seat?: string }): string {
   const seat = normalizedSeat(raw.seat);
   const url = raw.url ? canonicalUrl(raw.url) : undefined;
-  const basis = url ?? `${source}:${(raw.text ?? '').trim().slice(0, 200)}`;
+  const itemKey = url ?? `${source}:${(raw.text ?? '').trim().slice(0, 200)}`;
+  const basis = raw.linearIssueId ? JSON.stringify(['linear-issue', raw.linearIssueId.toLowerCase(), itemKey]) : itemKey;
   // Unassigned items retain their original IDs; assigned items have an independent lifecycle per seat.
   return createHash('sha256').update(seat ? JSON.stringify([seat, basis]) : basis).digest('hex').slice(0, 16);
 }
@@ -114,6 +119,9 @@ export function privacyFor(source: IntakeSource | RegisteredIntakeSourceKind): I
 /** ① 모양 맞추기 — 수집기 한 줄 → IntakeItem. 비어 있으면(URL·본문 둘 다 없음) null. */
 export function shapeIntakeItem(source: IntakeSource | RegisteredIntakeSourceKind, raw: RawIntakeItem, now: string): IntakeItem | null {
   const seat = normalizedSeat(raw.seat);
+  if (raw.linearIssueId !== undefined && !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(raw.linearIssueId)) {
+    throw new Error('invalid Linear issue UUID');
+  }
   const url = raw.url ? canonicalUrl(raw.url) : undefined;
   const text = raw.text?.trim() || undefined;
   if (!url && !text) return null;
@@ -121,10 +129,11 @@ export function shapeIntakeItem(source: IntakeSource | RegisteredIntakeSourceKin
   const signals: Record<string, number> = {};
   for (const [k, v] of Object.entries(raw.signals ?? {})) if (Number.isFinite(v)) signals[`${source}.${k}`] = v;
   return {
-    id: intakeItemId(source, { url, text, seat }),
+    id: intakeItemId(source, { url, text, seat, linearIssueId: raw.linearIssueId }),
     source,
     sources: [source],
     ...(seat ? { seat } : {}),
+    ...(raw.linearIssueId ? { linearIssueId: raw.linearIssueId } : {}),
     ...(url ? { url } : {}),
     kind: raw.kind ?? kindFor(source, url),
     ...(raw.title?.trim() ? { title: raw.title.trim().slice(0, 300) } : {}),
@@ -191,6 +200,7 @@ export function ingestIntakeItems(instanceRoot: string, source: IntakeSource | R
       signals: { ...prev.signals, ...shaped.signals },
       title: prev.title ?? shaped.title,
       text: prev.text ?? shaped.text,
+      linearIssueId: prev.linearIssueId ?? shaped.linearIssueId,
       axis: shaped.axis ?? prev.axis,
       judgement: shaped.judgement ?? prev.judgement,
       // 한 번이라도 개인 입력원에서 왔으면 개인으로 남긴다(공개로 풀지 않는다).