elanous 0.2.6 → 0.2.7

package/src/instance/leader.ts

@@ -2,7 +2,7 @@
 import { INSTALLED_PACKAGE_MARKERS, isInstalledPackagePath } from './installed-package.js';
 import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, resolve, basename } from 'node:path';
 
 export interface LeaderRefusalRecord {
   refusedAt: string;
@@ -53,10 +53,22 @@ export function normalizeTree(p: string): string {
   try { return realpathSync(abs); } catch { return abs; }
 }
 
+/** npm/Homebrew/nvm `<prefix>/lib/node_modules` · bun `…/install/global/node_modules` · pnpm `…/global/<n>/node_modules`. */
+export function isGlobalNodeModules(dir: string): boolean {
+  if (basename(dir) !== 'node_modules') return false;
+  const parent = basename(dirname(dir));
+  return parent === 'lib' || parent === 'global' || (/^\d+$/.test(parent) && basename(dirname(dirname(dir))) === 'global');
+}
+
 export function treeFromScriptPath(scriptPath: string): string | null {
   let dir = dirname(normalizeTree(scriptPath));
   for (let i = 0; i < 30; i++) {
     if (existsSync(join(dir, '.git'))) return dir;
+    // A GLOBAL install stops at its node_modules: a git repo around the install prefix (Homebrew's /opt/homebrew
+    // is one; so is a dotfiles-managed home) is not this code's source tree. Without this stop `npm i -g` under
+    // Homebrew ran as a «source tree» test universe writing config to /opt/homebrew/.elanous-test (OB3 · 10-01).
+    // A project-local <checkout>/node_modules/elanous still resolves to the checkout (the existing design).
+    if (isGlobalNodeModules(dir)) return null;
     const parent = dirname(dir);
     if (parent === dir) return null;
     dir = parent;

package/src/intake-plane/collect-github.ts

@@ -131,7 +131,7 @@ export function signalsFromSnapshot(stars: number, prev: StarSnapshot | undefine
   return { stars, starsDelta, starsPerDay: starsDelta / span };
 }
 
-function appendSnapshots(root: string, rows: StarSnapshot[]): void {
+export function appendGithubStarSnapshots(root: string, rows: StarSnapshot[]): void {
   if (!rows.length) return;
   mkdirSync(intakeLedgerDir(root), { recursive: true });
   appendFileSync(githubStarsFile(root), rows.map((r) => JSON.stringify(r)).join('\n') + '\n');
@@ -154,6 +154,8 @@ export interface CollectGithubOpts {
   /** 스냅숏·비교의 «오늘». 생략하면 UTC 날짜. */
   day?: string;
   now?: () => Date;
+  /** 등록 원천이 질의 하나만 수집할 때; 생략 시 기존 관심 질의 전부. */
+  queries?: readonly string[];
 }
 
 /**
@@ -173,7 +175,7 @@ export async function collectGithubStars(
   const found: GithubStarRepo[] = [];
   // «급상승»은 최근에 생긴 저장소 중 별 순이다 — 전체 기간 별 순이면 활발한 거대 저장소가 매일 같은 목록으로 나온다(2026-09-26 검토).
   const windowStart = new Date(Date.parse(`${day}T00:00:00.000Z`) - days * 86_400_000).toISOString().slice(0, 10);
-  for (const query of GITHUB_STAR_QUERIES) {
+  for (const query of opts.queries ?? GITHUB_STAR_QUERIES) {
     const rows = await search(`${query} created:>=${windowStart}`, perQuery);
     const recent = rows.filter((r) => isRecentRepo(r, day, days));
     queries.push({ query, received: recent.length });
@@ -208,7 +210,7 @@ export async function collectGithubStars(
     day, days, perQuery, dryRun: !!opts.dryRun, queries, repos, raws: raws.length,
   };
   if (!opts.dryRun) {
-    appendSnapshots(root, repos.map((row) => ({ day, repo: row.repo, stars: row.stars })));
+    appendGithubStarSnapshots(root, repos.map((row) => ({ day, repo: row.repo, stars: row.stars })));
     result.ingest = ingestIntakeItems(root, 'github', raws);
   }
   debug.log('intake.collect', 'github-stars', {

package/src/intake-plane/collect-telegram-saved.ts

@@ -60,14 +60,26 @@ export async function collectTelegramSaved(root: string, fetch: FetchSavedMessag
 }
 
 /** GramJS 사용자 세션으로 `me` 대화를 읽는 실제 구현. 자격이 없으면 이유를 담아 던진다(값은 싣지 않는다). */
-export async function gramjsFetchSaved(env: NodeJS.ProcessEnv = process.env): Promise<{ fetch: FetchSavedMessages; close: () => Promise<void> }> {
+type GramjsModules = { TelegramClient: typeof import('telegram').TelegramClient; StringSession: typeof import('telegram/sessions').StringSession };
+const loadGramjs = async (): Promise<GramjsModules> => ({
+  TelegramClient: (await import('telegram')).TelegramClient,
+  StringSession: (await import('telegram/sessions')).StringSession,
+});
+
+export async function gramjsFetchSaved(
+  env: NodeJS.ProcessEnv = process.env,
+  load: () => Promise<GramjsModules> = loadGramjs,
+): Promise<{ fetch: FetchSavedMessages; close: () => Promise<void> }> {
   const apiId = Number(env.TELEGRAM_API_ID ?? 0);
   const apiHash = env.TELEGRAM_API_HASH ?? '';
   const session = env.TELEGRAM_USER_SESSION ?? '';
   const missing = [!apiId && 'TELEGRAM_API_ID', !apiHash && 'TELEGRAM_API_HASH', !session && 'TELEGRAM_USER_SESSION'].filter(Boolean);
   if (missing.length) throw new Error(`텔레그램 사용자 세션 자격이 없다: ${missing.join(' · ')} (docs/manual/MANUAL-telegram-unmanned-test-2026-07-21.md §1~§3)`);
-  const { TelegramClient } = await import('telegram');
-  const { StringSession } = await import('telegram/sessions');
+  // `telegram` is an optional dependency: its native websocket helpers have no Linux ARM64 build, so npm may leave it out.
+  let modules: GramjsModules;
+  try { modules = await load(); }
+  catch { throw new Error('텔레그램 사용자 세션 모듈(telegram)이 이 설치에 없다 — 선택 의존이라 Linux ARM64 등에서는 빠진다(npm i -g telegram 으로 따로 깔 수 있다)'); }
+  const { TelegramClient, StringSession } = modules;
   const client = new TelegramClient(new StringSession(session), apiId, apiHash, { connectionRetries: 3 });
   client.setLogLevel('error' as never);   // 연결 로그가 표준출력을 채우지 않게
   await client.connect();

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

@@ -0,0 +1,56 @@
+import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
+import {
+  submitIntakeWork,
+  type SubmitIntakeWorkDeps,
+} from './submit-intake-work.js';
+
+export interface DiscordSeatWorkMessage {
+  channelId: string;
+  messageId: string;
+  threadId?: string;
+}
+
+export interface DiscordSeatWorkDeps extends SubmitIntakeWorkDeps {
+  submit?: typeof submitIntakeWork;
+}
+
+/** Addressed Discord work goes through the graph intake door, not the chat turn. */
+export async function handleDiscordSeatWork(
+  text: string,
+  msg: DiscordSeatWorkMessage,
+  deps: DiscordSeatWorkDeps = {},
+): Promise<string | null> {
+  const address = parseSeatAddress(text);
+  if (!address) return null;
+
+  const seats = address.seats.map((name) => ({ name, seat: resolveSeat(name) }));
+  const unknown = seats.filter(({ seat }) => !seat).map(({ name }) => `@${name}`);
+  if (unknown.length) return `어느 좌석을 말씀하시나요? ${unknown.join(', ')}은(는) 등록된 좌석이 아닙니다. 좌석을 확인해 다시 보내 주세요.`;
+  const body = address.body.trim();
+  if (!body) return '어떤 일을 맡길까요? 좌석 주소 뒤에 요청 내용을 적어 다시 보내 주세요.';
+
+  const reportTo = {
+    channel: 'discord' as const,
+    channelId: msg.channelId,
+    ...(msg.threadId ? { discordThreadId: msg.threadId } : {}),
+  };
+  const replies: string[] = [];
+  for (const { seat } of seats) {
+    if (!seat) continue;
+    const label = seat.title ?? seat.id;
+    const result = await (deps.submit ?? submitIntakeWork)({
+      text: `@${label} ${body}`,
+      track: 'graph',
+      origin: {
+        kind: 'external', ledgerSource: 'memo', provider: 'other',
+        ref: `discord:${msg.channelId}:${msg.messageId}`, reportTo,
+      },
+    }, deps);
+    if (result.ok && result.track === 'graph') {
+      replies.push(`@${label} 접수번호: ${result.acceptanceId}`);
+    } else {
+      replies.push(`@${label} 접수 실패 — ${result.ok ? '접수번호가 없습니다' : result.reason.split('\n')[0]!.slice(0, 200)}`);
+    }
+  }
+  return replies.join('\n');
+}

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

@@ -0,0 +1,202 @@
+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 { 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 interface RegisteredIntakeSource {
+  id: string;
+  seat: string;
+  kind: SourceKind;
+  spec: string;
+  every: string;
+  until?: string;
+  why?: string;
+  lastRunAt?: string;
+}
+
+export function canonicalSeat(value: string): string {
+  const seat = findTrack(value.trim());
+  if (!seat) throw new Error(`알 수 없는 자리: ${value}`);
+  return seat.id;
+}
+
+export function cadenceMs(every: string): number {
+  const match = /^([1-9]\d*)([hdw])$/.exec(every);
+  if (!match) throw new Error(`--every 는 Nh · Nd · Nw 형식이어야 한다: ${every}`);
+  const ms = Number(match[1]) * ({ h: 3600_000, d: 86_400_000, w: 604_800_000 }[match[2]!] ?? 0);
+  if (!Number.isSafeInteger(ms)) throw new Error(`--every 가 너무 크다: ${every}`);
+  return ms;
+}
+
+function untilMs(until: string): number {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(until) || !Number.isFinite(Date.parse(`${until}T00:00:00Z`))
+    || new Date(`${until}T00:00:00Z`).toISOString().slice(0, 10) !== until) throw new Error(`--until 날짜 형식 오류: ${until}`);
+  return Date.parse(`${until}T00:00:00Z`);
+}
+
+export function expiredSource(source: RegisteredIntakeSource, now: Date): boolean {
+  return source.until !== undefined && now.getTime() >= untilMs(source.until);
+}
+
+export function sourceIsDue(source: RegisteredIntakeSource, now: Date): boolean {
+  return !expiredSource(source, now) && (source.lastRunAt === undefined
+    || Date.parse(source.lastRunAt) + cadenceMs(source.every) <= now.getTime());
+}
+
+export function sourcesFile(stateDir: string): string { return join(stateDir, 'intake', 'sources.json'); }
+
+function readSources(stateDir: string): RegisteredIntakeSource[] {
+  const file = sourcesFile(stateDir);
+  if (!existsSync(file)) return [];
+  const parsed: unknown = JSON.parse(readFileSync(file, 'utf8'));
+  if (!Array.isArray(parsed)) throw new Error(`원천 등록부 모양 오류: ${file}`);
+  return parsed as RegisteredIntakeSource[];
+}
+
+function saveSources(stateDir: string, sources: RegisteredIntakeSource[]): void {
+  const file = sourcesFile(stateDir);
+  mkdirSync(join(stateDir, 'intake'), { recursive: true });
+  const temp = `${file}.${randomUUID()}.tmp`;
+  try {
+    const fd = openSync(temp, 'wx', 0o600);
+    try { writeFileSync(fd, JSON.stringify(sources, null, 2) + '\n'); } finally { closeSync(fd); }
+    chmodSync(temp, 0o600);
+    renameSync(temp, file);
+  } catch (error) {
+    if (existsSync(temp)) unlinkSync(temp);
+    throw error;
+  }
+}
+
+function commandArgv(spec: string): string[] {
+  // Shell syntax and interpreter wrappers are rejected; the allowed invocation uses execFileSync without a shell.
+  if (!spec.trim() || /["'\\`$;|&<>(){}\[\]*?\r\n]/.test(spec)) throw new Error('command spec 은 셸 구문 없이 실행 파일과 인자만 허용한다');
+  const argv = spec.trim().split(/\s+/);
+  // Allow-list, not deny-list (review R3): any other program (`nodejs scripts/x.ts`, a renamed wrapper) could emit
+  // private memos without a privacy mark. 1st edition: only the elanous CLI itself, whose intake commands mark privacy.
+  const executable = argv[0]!.split('/').pop()!.toLowerCase();
+  if (executable !== 'elanous' && executable !== 'eln') throw new Error('command 원천은 1판에서 elanous CLI(elanous·eln)만 받는다');
+  if (argv.some((arg) => /collect-telegram-saved/i.test(arg))) throw new Error('개인 메모(collect-telegram-saved)는 command 원천으로 등록할 수 없다');
+  return argv;
+}
+
+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}`);
+  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.kind === 'rss') {
+    let protocol = '';
+    try { protocol = new URL(input.spec).protocol; } catch { /* validation below */ }
+    if (protocol !== 'http:' && protocol !== 'https:') throw new Error('RSS spec 은 HTTP(S) URL 이어야 한다');
+  }
+  if (input.kind === 'command') commandArgv(input.spec);
+  const sources = readSources(stateDir);
+  if (sources.some((source) => source.id === input.id)) throw new Error(`이미 등록된 원천 id: ${input.id}`);
+  const source = { ...input, seat };
+  saveSources(stateDir, [...sources, source]);
+  return source;
+}
+
+export function listSources(filter: { seat?: string } = {}, stateDir = effectiveInstanceRoot()): RegisteredIntakeSource[] {
+  const seat = filter.seat === undefined ? undefined : canonicalSeat(filter.seat);
+  return readSources(stateDir).filter((source) => seat === undefined || source.seat === seat);
+}
+
+export function removeSource(id: string, stateDir = effectiveInstanceRoot()): boolean {
+  const sources = readSources(stateDir);
+  if (!sources.some((source) => source.id === id)) return false;
+  saveSources(stateDir, sources.filter((source) => source.id !== id));
+  return true;
+}
+
+export function dueSources(now: Date = new Date(), stateDir = effectiveInstanceRoot()): RegisteredIntakeSource[] {
+  return listSources({}, stateDir).filter((source) => sourceIsDue(source, now));
+}
+
+export interface RunDueDeps {
+  stateDir?: string;
+  searchGithub?: SearchGithubRepos;
+  fetchFeed?: (url: string) => Promise<string>;
+  runCommand?: (command: string) => Promise<string>;
+  ingest?: typeof ingestIntakeItems;
+}
+
+function xmlText(value: string): string {
+  return value.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1').replace(/<[^>]+>/g, '')
+    .replace(/&(?:amp|lt|gt|quot|apos|#(\d+)|#x([a-f\d]+));/gi, (entity, dec: string | undefined, hex: string | undefined) => {
+      if (dec || hex) return String.fromCodePoint(Number.parseInt(dec ?? hex!, dec ? 10 : 16));
+      return ({ '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'" } as Record<string, string>)[entity.toLowerCase()] ?? entity;
+    }).trim();
+}
+
+export function parseFeed(xml: string): RawIntakeItem[] {
+  // A login page or broken XML is a failure, not «0 items» — otherwise lastRunAt moves and the retry waits a whole cycle (review R3).
+  const head = xml.replace(/^\uFEFF/, '').replace(/<\?xml[^>]*\?>/i, '').replace(/<!--[\s\S]*?-->/g, '').trimStart();
+  if (!/^<(?:rss|feed|rdf:RDF)\b/i.test(head)) throw new Error('RSS/Atom 피드가 아니다(루트가 rss·feed·rdf:RDF 아님)');
+  const entries = xml.match(/<(?:item|entry)\b[^>]*>[\s\S]*?<\/(?:item|entry)>/gi) ?? [];
+  return entries.map((entry) => {
+    const field = (name: string): string => xmlText(entry.match(new RegExp(`<${name}\\b[^>]*>([\\s\\S]*?)<\\/${name}>`, 'i'))?.[1] ?? '');
+    const link = entry.match(/<link\b[^>]*\bhref=["']([^"']+)["'][^>]*\/?\s*>/i)?.[1] ?? field('link');
+    return { url: xmlText(link), title: field('title'), text: field('description') || field('summary') || field('content'), kind: 'rss' as const };
+  }).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 }> }> {
+  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)) {
+    try {
+      let raws: RawIntakeItem[];
+      let githubSnapshots: { day: string; repo: string; stars: number }[] | undefined;
+      let intakeSource: IntakeSource | RegisteredIntakeSourceKind;
+      if (source.kind === 'github-query') {
+        const collected = await collectGithubStars(stateDir, deps.searchGithub ?? ghApiSearchRepos, {
+          queries: [source.spec], day: now.toISOString().slice(0, 10), dryRun: true,
+        });
+        githubSnapshots = collected.repos.map((repo) => ({ day: collected.day, repo: repo.repo, stars: repo.stars }));
+        raws = collected.repos.map((repo) => ({ url: repo.url, title: repo.title, text: repo.text, kind: 'repo',
+          signals: { stars: repo.stars, ...(repo.starsDelta === undefined ? {} : { starsDelta: repo.starsDelta }),
+            ...(repo.starsPerDay === undefined ? {} : { starsPerDay: repo.starsPerDay }) } }));
+        intakeSource = 'github';
+      } else if (source.kind === 'rss') {
+        const feed = await (deps.fetchFeed ?? (async (url: string) => {
+          const response = await fetch(url, { signal: AbortSignal.timeout(30_000) });
+          if (!response.ok) throw new Error(`RSS HTTP ${response.status}`);
+          return response.text();
+        }))(source.spec);
+        raws = parseFeed(feed);
+        intakeSource = 'rss';
+      } 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);
+        const parsed = parseRawIntakeJsonl(stdout);
+        if (parsed.bad) throw new Error(`잘못된 JSONL ${parsed.bad}줄`);
+        if (parsed.raws.some((raw) => (raw as RawIntakeItem & { privacy?: string; source?: string }).privacy === 'user-private'
+          || ['memo', 'telegram-saved'].includes((raw as RawIntakeItem & { source?: string }).source ?? ''))) {
+          throw new Error('개인 메모(user-private)는 command 원천에서 받을 수 없다');
+        }
+        raws = parsed.raws;
+        intakeSource = 'command';
+      }
+      const items = (deps.ingest ?? ingestIntakeItems)(stateDir, intakeSource, raws.map((raw) => ({ ...raw, seat: source.seat })), now.toISOString()).shaped;
+      if (githubSnapshots) appendGithubStarSnapshots(stateDir, githubSnapshots);
+      // Re-read after each run so one failure cannot overwrite another source's successful timestamp.
+      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));
+      ran.push({ id: source.id, items });
+    } catch (error) {
+      ran.push({ id: source.id, items: 0, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { ran };
+}

package/src/intake-plane/items.ts

@@ -4,19 +4,22 @@ import { createHash } from 'node:crypto';
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
+import { findTrack } from '../autopilot/mission-phase-track.js';
 
 export const INTAKE_SOURCES = ['x', 'youtube', 'github', 'telegram-saved', 'telegram-bot', 'memo', 'pwa'] as const;
+export type RegisteredIntakeSourceKind = 'rss' | 'command';
 export type IntakeSource = typeof INTAKE_SOURCES[number];
-export type IntakeKind = 'video' | 'repo' | 'post' | 'article' | 'note';
+export type IntakeKind = 'video' | 'repo' | 'post' | 'article' | 'note' | 'rss';
 export type IntakePrivacy = 'public' | 'user-private';
 export const INTAKE_STATUSES = ['new', 'queued', 'absorbed', 'checked', 'routed', 'discarded', 'deferred'] as const;
 export type IntakeStatus = typeof INTAKE_STATUSES[number];
 
 export interface IntakeItem {
   id: string;
-  source: IntakeSource;
+  source: IntakeSource | RegisteredIntakeSourceKind;
   /** 같은 항목이 다른 입력원에서도 왔으면 여기 모인다 — «두 입력원에서 동시에 뜬 것»이 신호다. */
-  sources: IntakeSource[];
+  sources: (IntakeSource | RegisteredIntakeSourceKind)[];
+  seat?: string;
   url?: string;
   kind: IntakeKind;
   title?: string;
@@ -34,6 +37,7 @@ export interface IntakeItem {
 
 /** 수집기가 내는 한 줄 — 모양 맞추기 전. */
 export interface RawIntakeItem {
+  seat?: string;
   url?: string;
   title?: string;
   text?: string;
@@ -76,13 +80,23 @@ export function canonicalUrl(raw: string): string | undefined {
   return `https://${host}${path}${q}`;
 }
 
-export function intakeItemId(source: IntakeSource, raw: Pick<RawIntakeItem, 'url' | 'text'>): string {
+function normalizedSeat(seat: unknown): string | undefined {
+  if (seat === undefined) return undefined;
+  if (typeof seat !== 'string') throw new Error(`알 수 없는 자리: ${String(seat)}`);
+  const track = findTrack(seat.trim());
+  if (!track) throw new Error(`알 수 없는 자리: ${seat}`);
+  return track.id;
+}
+
+export function intakeItemId(source: IntakeSource | RegisteredIntakeSourceKind, raw: Pick<RawIntakeItem, 'url' | 'text'> & { 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)}`;
-  return createHash('sha256').update(basis).digest('hex').slice(0, 16);
+  // 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);
 }
 
-function kindFor(source: IntakeSource, url: string | undefined): IntakeKind {
+function kindFor(source: IntakeSource | RegisteredIntakeSourceKind, url: string | undefined): IntakeKind {
   if (url?.startsWith('https://www.youtube.com/')) return 'video';
   if (url?.startsWith('https://github.com/')) return 'repo';
   if (url?.startsWith('https://x.com/')) return 'post';
@@ -91,12 +105,13 @@ function kindFor(source: IntakeSource, url: string | undefined): IntakeKind {
 }
 
 /** 개인 메모 입력원은 user-private — 원문을 바깥 LLM 에 보내지 않는다(RFC §3.4). PWA 칸에 사람이 쓴 글도 같다(RFC-pwa-intake-front-door). */
-export function privacyFor(source: IntakeSource): IntakePrivacy {
+export function privacyFor(source: IntakeSource | RegisteredIntakeSourceKind): IntakePrivacy {
   return source === 'telegram-saved' || source === 'memo' || source === 'pwa' ? 'user-private' : 'public';
 }
 
 /** ① 모양 맞추기 — 수집기 한 줄 → IntakeItem. 비어 있으면(URL·본문 둘 다 없음) null. */
-export function shapeIntakeItem(source: IntakeSource, raw: RawIntakeItem, now: string): IntakeItem | null {
+export function shapeIntakeItem(source: IntakeSource | RegisteredIntakeSourceKind, raw: RawIntakeItem, now: string): IntakeItem | null {
+  const seat = normalizedSeat(raw.seat);
   const url = raw.url ? canonicalUrl(raw.url) : undefined;
   const text = raw.text?.trim() || undefined;
   if (!url && !text) return null;
@@ -104,9 +119,10 @@ export function shapeIntakeItem(source: IntakeSource, raw: RawIntakeItem, now: s
   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 }),
+    id: intakeItemId(source, { url, text, seat }),
     source,
     sources: [source],
+    ...(seat ? { seat } : {}),
     ...(url ? { url } : {}),
     kind: raw.kind ?? kindFor(source, url),
     ...(raw.title?.trim() ? { title: raw.title.trim().slice(0, 300) } : {}),
@@ -155,7 +171,7 @@ const SETTLED: ReadonlySet<IntakeStatus> = new Set(['absorbed', 'discarded', 'ro
  * ② 중복 없애기 — 같은 id 는 새 항목을 만들지 않고 신호·입력원을 합친다.
  * 이미 흡수·버림·갈래가 끝난 것은 «seen» 으로 세고 상태를 되돌리지 않는다(다시 올리지 않는다).
  */
-export function ingestIntakeItems(instanceRoot: string, source: IntakeSource, raws: RawIntakeItem[], now = new Date().toISOString(),
+export function ingestIntakeItems(instanceRoot: string, source: IntakeSource | RegisteredIntakeSourceKind, raws: RawIntakeItem[], now = new Date().toISOString(),
   log: (event: string, data: Record<string, unknown>) => void = (e, d) => { debug.log('intake.normalize', e, d); }): IngestResult {
   const { items: existing, badLines } = loadIntakeLedger(instanceRoot);
   const result: IngestResult = { shaped: 0, added: 0, merged: 0, seen: 0, skipped: 0, badLines };
@@ -203,9 +219,9 @@ export function markIntakeItem(instanceRoot: string, id: string, patch: { status
   return true;
 }
 
-export function listIntakeItems(instanceRoot: string, filter: { status?: IntakeStatus; source?: IntakeSource } = {}): IntakeItem[] {
+export function listIntakeItems(instanceRoot: string, filter: { status?: IntakeStatus; source?: IntakeSource; seat?: string } = {}): IntakeItem[] {
   return [...loadIntakeLedger(instanceRoot).items.values()]
-    .filter((i) => (!filter.status || i.status === filter.status) && (!filter.source || i.sources.includes(filter.source)))
+    .filter((i) => (!filter.status || i.status === filter.status) && (!filter.source || i.sources.includes(filter.source)) && (!filter.seat || i.seat === filter.seat))
     .sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
 }