elanous 0.2.0 → 0.2.5

package/src/intake-plane/route.ts

@@ -0,0 +1,104 @@
+// 흡수 갈래(⑤) — 흡수가 끝난 항목의 대조 결과를 산출 큐(outbox)로 나눈다. RFC-regular-external-intake §4 (P4).
+// 결정론만: 판정 모델·LLM 을 부르지 않는다. 받는 쪽(🅢 입구 · 문서 소유 · 🅣 P10)이 큐를 읽는다.
+// ⛔ 원장의 `text`(개인 메모일 수 있다)는 큐에 싣지 않는다 — 대조가 낸 사실·근거와 노트 경로만.
+import { execFileSync } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { intakeLedgerDir, loadIntakeLedger, markIntakeItem, type IntakeItem } from './items.js';
+
+/** `elanous intake check --json` 산출 중 갈래가 읽는 칸. */
+export interface IntakeCheckJson {
+  commit?: string;
+  tree?: string;
+  items: { fact: string; current: string; verdict: string; evidence?: { axis?: string; summary?: string; path?: string; line?: number; repoKind?: string }[]; patterns?: string[] }[];
+  goalDraftPaths?: string[];
+}
+
+type RouteMeasurement = { unmeasured: number; measured: number };
+export interface RouteResult extends RouteMeasurement { id: string; goals: number; manual: number; review: number; grounding: number; release: number; dryRun: boolean; skipped?: string }
+
+/** 큐 파일의 날짜 — KST. 다이제스트가 KST 하루로 읽는다(07:00 KST 크론은 UTC 로 «전날»이다). */
+export const kstDay = (iso: string): string => new Date(Date.parse(iso) + 9 * 3600_000).toISOString().slice(0, 10);
+
+/** 근거 파일의 마지막 착지 커밋 — 🅣 릴리스 루프 컷오프가 «커밋 C 이전인가»를 가른다. 못 구하면 undefined. */
+export type LastCommitOf = (tree: string, path: string) => string | undefined;
+export const gitLastCommitOf: LastCommitOf = (tree, path) => {
+  try { return execFileSync('git', ['-C', tree, 'log', '-1', '--format=%H', '--', path], { encoding: 'utf8', timeout: 10_000 }).trim() || undefined; } catch { return undefined; }
+};
+
+export function intakeOutboxDir(root: string): string { return join(intakeLedgerDir(root), 'outbox'); }
+
+function appendJsonl(file: string, rows: unknown[]): void {
+  if (!rows.length) return;
+  mkdirSync(join(file, '..'), { recursive: true });
+  appendFileSync(file, rows.map((r) => JSON.stringify(r)).join('\n') + '\n');
+}
+
+function groundingHas(root: string, path: string): boolean {
+  const file = join(intakeOutboxDir(root), 'grounding.jsonl');
+  if (!existsSync(file)) return false;
+  return readFileSync(file, 'utf8').split('\n').some((l) => { try { return JSON.parse(l).path === path; } catch { return false; } });
+}
+
+/**
+ * 갈래 규칙:
+ *  - 「없음」 → goals (골 후보 · 저작은 받는 쪽이 `intake check --author` 로)
+ *  - 「판단 필요」이면서 근거가 문서·주석뿐 → manual (문서가 늙었거나 약속만 있는 자리)
+ *  - 그 밖의 「판단 필요」 → review (사람이 노트 🧭 절을 읽고 가른다 · 다이제스트에 수를 싣는다)
+ *  - 흡수 노트 → grounding 후보(한 번만) · 태그 `intake:<입력원>`
+ * 이미 routed 인 항목은 다시 나누지 않는다.
+ */
+export function routeIntakeItem(root: string, id: string, check: IntakeCheckJson, opts: { dryRun?: boolean; lastCommitOf?: LastCommitOf } = {}, now = new Date().toISOString()): RouteResult {
+  const item = loadIntakeLedger(root).items.get(id);
+  if (!item) return { id, goals: 0, manual: 0, review: 0, grounding: 0, release: 0, unmeasured: 0, measured: 0, dryRun: !!opts.dryRun, skipped: '원장에 없는 id' };
+  if (item.status === 'routed') return { id, goals: 0, manual: 0, review: 0, grounding: 0, release: 0, unmeasured: 0, measured: 0, dryRun: !!opts.dryRun, skipped: '이미 routed' };
+  const unmeasured = check.items.filter((c) => c.verdict === '못 쟀다').length;
+  const measured = check.items.length - unmeasured;
+  if (measured === 0 && unmeasured > 0) {
+    debug.log('intake.route', 'all-unmeasured', { id, unmeasured });
+    return { id, goals: 0, manual: 0, review: 0, grounding: 0, release: 0, unmeasured, measured, dryRun: !!opts.dryRun, skipped: '모든 주장을 못 쟀다 — 대조를 다시 돌려라' };
+  }
+  const day = kstDay(now);
+  const base = { id, at: now, source: item.source, ...(item.url ? { url: item.url } : {}), ...(check.commit ? { commit: check.commit } : {}) };
+  const goals = check.items.filter((c) => c.verdict === '없음').map((c) => ({
+    ...base, fact: c.fact, current: c.current, patterns: c.patterns ?? [], goalDraftPaths: check.goalDraftPaths ?? [],
+  }));
+  const docOnly = (c: IntakeCheckJson['items'][number]) => /문서|주석|약속/.test(c.current);
+  const manual = check.items.filter((c) => c.verdict === '판단 필요' && docOnly(c)).map((c) => ({
+    ...base, fact: c.fact, current: c.current, evidence: (c.evidence ?? []).slice(0, 3).map((e) => e.summary ?? '').filter(Boolean),
+  }));
+  const note = noteOf(item);
+  const review = check.items.filter((c) => c.verdict === '판단 필요' && !docOnly(c)).map((c) => ({
+    ...base, fact: c.fact, current: c.current, ...(note ? { note } : {}),
+  }));
+  // O4 — 「있음」이면서 실행 코드 근거가 있는 것 = 바깥 지식이 «이미 착지한 기능»에 닿는다 → 릴리스 노트 바깥 맥락(🅣 T-R 합의 줄 모양).
+  const lastCommitOf = opts.lastCommitOf ?? gitLastCommitOf;
+  const release = check.items.flatMap((c) => {
+    if (c.verdict !== '있음') return [];
+    const code = (c.evidence ?? []).filter((e) => e.axis === 'repo' && e.repoKind === 'behavior' && e.path);
+    if (!code.length) return [];
+    const landedSha = check.tree ? lastCommitOf(check.tree, code[0].path!.replace(/:\d+$/, '')) : undefined;
+    return [{
+      id, at: now, kind: 'docs' as const, title: c.fact, summary: c.current, sources: item.url ? [item.url] : [],
+      evidence: code.slice(0, 3).map((e) => `${e.path}${e.line ? `:${e.line}` : ''}`), suggestedSection: '바깥 맥락',
+      ...(landedSha ? { landedSha } : {}),
+    }];
+  });
+  const grounding = note && !groundingHas(root, note) ? [{ path: note, kind: 'local-docs', tag: `intake:${item.source}`, at: now, id }] : [];
+  if (!opts.dryRun) {
+    const out = intakeOutboxDir(root);
+    appendJsonl(join(out, 'goals', `${day}.jsonl`), goals);
+    appendJsonl(join(out, 'manual', `${day}.jsonl`), manual);
+    appendJsonl(join(out, 'review', `${day}.jsonl`), review);
+    appendJsonl(join(out, 'grounding.jsonl'), grounding);
+    appendJsonl(join(out, 'release', `${day}.jsonl`), release);
+    markIntakeItem(root, id, { status: 'routed' }, now);
+  }
+  debug.log('intake.route', 'item-routed', { id, goals: goals.length, manual: manual.length, review: review.length, grounding: grounding.length, release: release.length, unmeasured, measured, dryRun: !!opts.dryRun });
+  return { id, goals: goals.length, manual: manual.length, review: review.length, grounding: grounding.length, release: release.length, unmeasured, measured, dryRun: !!opts.dryRun };
+}
+
+function noteOf(item: IntakeItem): string | undefined {
+  return [...item.outputs].reverse().find((o) => o.kind === 'note')?.ref;
+}

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

@@ -60,6 +60,7 @@ export interface StreamLlmFn {
       model?: string;
       provider?: { name: string } & Record<string, unknown>;
       signal?: AbortSignal;
+      usageRole?: ModelRole;
     },
   ): Promise<string>;
 }
@@ -188,7 +189,8 @@ export function buildIntakeDocumentStageCallables(
     const lines = document.split('\n');
     let inCheck = false;
     const external = lines.filter((line) => {
-      if (/^##\s+🧭\s+elanous 점검\s*$/.test(line.trim())) {
+      // 개명(2026-09-26) 전에 쓴 노트는 옛 제목을 그대로 갖고 있다 — 둘 다 빼야 자기 점검을 다시 읽지 않는다.
+      if (/^##\s+🧭\s+(?:elanous|monad) 점검\s*$/.test(line.trim())) {
         inCheck = true;
         return false;
       }

package/src/intake-plane/sketch-ledger.ts

@@ -0,0 +1,34 @@
+import { canonicalUrl, ingestIntakeItems, intakeItemId, type IntakeSource, type RawIntakeItem } from './items.js';
+import { extractLinks } from './normalize.js';
+import type { RawIntakeRecord } from './types.js';
+
+const SKETCH_LEDGER_SOURCES: Record<RawIntakeRecord['source'], IntakeSource> = {
+  'tui-scratch': 'memo',
+  'web-scratch': 'pwa',
+  'mobile-scratch': 'pwa',
+  voice: 'memo',
+  telegram: 'telegram-bot',
+  discord: 'memo',
+  api: 'memo',
+  document: 'memo',
+  url: 'memo',
+};
+
+export function ledgerSourceForSketch(source: RawIntakeRecord['source']): IntakeSource {
+  return SKETCH_LEDGER_SOURCES[source];
+}
+
+/** Record one captured sketch in the external intake ledger; empty sketches have no ledger item. */
+export function recordSketchInLedger(instanceRoot: string, raw: RawIntakeRecord): string | undefined {
+  const source = ledgerSourceForSketch(raw.source);
+  const url = extractLinks(raw.rawText).find((link) => canonicalUrl(link) !== undefined);
+  const text = raw.rawText.trim().slice(0, 2_000);
+  if (!url && !text) return undefined;
+  const item: RawIntakeItem = {
+    ...(url ? { url } : {}),
+    ...(text ? { text } : {}),
+    observedAt: raw.receivedAt,
+  };
+  ingestIntakeItems(instanceRoot, source, [item], raw.receivedAt);
+  return intakeItemId(source, item);
+}

package/src/intake-plane/slash.ts

@@ -1,5 +1,9 @@
 import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { isAbsolute } from 'node:path';
 import { debug } from '../debug/log.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
+import { resolveDaemonHarnessTarget } from './harness-target.js';
 import {
   applyClarifyAnswerToDraft,
 } from './clarify.js';
@@ -49,6 +53,8 @@ export interface IntakeSlashDeps {
   runPipeline?: (input: { rawText: string; intakeId: string }, callables: PipelinePhaseCallables) => Promise<PipelineRunResult>;
   pipelineCallables?: PipelinePhaseCallables;
   harnessContext?: DaemonToolDispatchCtx;
+  harnessConfig?: Pick<UserConfig, 'harness'>;
+  isGitRepo?: (path: string) => boolean;
   dispatchHarness?: (args: { objective: string }, context?: DaemonToolDispatchCtx) => Promise<{ output: string }>;
 }
 
@@ -470,6 +476,27 @@ export async function resolveIntakeSlash(
     if (!intakeId) return { output: '/intake implement: no intake sessions yet' };
     const session = store.getSession(intakeId);
     if (!session) return { output: `/intake implement: session '${intakeId}' not found` };
+    const cwd = deps.harnessContext?.cwd ?? process.cwd();
+    const configuredRepo = (deps.harnessConfig ?? getUserConfig()).harness?.defaultRepo;
+    const target = resolveDaemonHarnessTarget({
+      configured: typeof configuredRepo === 'string' && isAbsolute(configuredRepo) ? configuredRepo : undefined,
+      cwd,
+      isGitRepo: deps.isGitRepo ?? ((path) => {
+        try {
+          return execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
+            cwd: path, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+          }).trim() === 'true';
+        } catch {
+          return false;
+        }
+      }),
+    });
+    debug.log('intake-plane.slash', 'harness-target', {
+      ok: target.ok,
+      source: target.ok ? target.source : undefined,
+      reason: target.ok ? undefined : target.reason,
+    });
+    if (!target.ok) return { output: target.reason, action: 'noop', session };
     const runPipeline = deps.runPipeline ?? runIntakePipelinePhases;
     const pipelineCallables = deps.pipelineCallables ?? buildRealIntakeCallables();
     const pipeline = await runPipeline({ rawText: session.raw.rawText, intakeId }, pipelineCallables);
@@ -485,10 +512,11 @@ export async function resolveIntakeSlash(
     // inference would lose; mandatory clarify would unnecessarily block grounded
     // tasks. One task is therefore dispatched as one independent goal, in order.
     const dispatchHarness = deps.dispatchHarness ?? dispatchHarnessViaSelfImplement;
-    const harnessContext = deps.harnessContext ?? {
-      cwd: process.cwd(),
+    const harnessContext = {
       signal: new AbortController().signal,
       userText: `/intake implement ${intakeId}`,
+      ...deps.harnessContext,
+      cwd: target.repo,
     };
     const outcomes: Array<{ task: EnrichedTask; output: string; launched: boolean }> = [];
     for (const task of tasks) {

package/src/intake-plane/submit-intake-work.ts

@@ -0,0 +1,160 @@
+/**
+ * X6 앞문 — `submitIntakeWork`: 앞문 판정의 갈래를 «이미 있는 문»으로 실행하고 추적 id 를 돌려준다.
+ * RFC `내부 문서 `RFC-external-tasks-plugins-and-the-task-loop-2026-09-27`` A6 · `내부 문서 `RFC-pwa-intake-front-door-2026-09-26``.
+ *
+ * - absorb → 흡수 원장(`ingestIntakeItems`) — URL 이 있으면 URL 마다, 없으면 글 한 덩이(PWA `absorbItemsFromText` 와 같은 규칙).
+ * - tasks  → TOX(`dispatchTaskCreate`) — 외부 출처(텔레그램 등)는 `external` 로 실어 M1(backlog ⊕ 승인 대기)을 탄다.
+ * - graph  → 하니스 ask(`handleHarnessAskPost` 를 요청 하나로 부른다 — 흐름을 복제하지 않는다).
+ * - ask-human → 실행하지 않는다. 고를 갈래를 돌려준다.
+ *
+ * 로그엔 원문이 아니라 길이만 남긴다(앞문 RFC · `user-private`).
+ */
+import { debug } from '../debug/log.js';
+import type { MissionOrigin } from '../autopilot/mission-origin.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import type { ExternalTaskSource } from '../task-orchestrator/types.js';
+import { TASK_DEFAULTS } from '../task-orchestrator/types.js';
+import { decideIntakeFrontRoute, type IntakeFrontRouteDecision } from './front-route-rules.js';
+import { ingestIntakeItems, intakeItemId, type IntakeSource, type RawIntakeItem } from './items.js';
+
+export type IntakeWorkTrack = 'absorb' | 'tasks' | 'graph';
+
+/** 누가 보냈나. `owner` = PWA 칸(사람 본인) · `external` = 텔레그램·공급자 등(승인 대기로 들어간다). */
+export type IntakeWorkOrigin =
+  | { kind: 'owner'; ledgerSource: IntakeSource }
+  | { kind: 'external'; ledgerSource: IntakeSource; provider: ExternalTaskSource['provider']; ref: string; url?: string; reportTo?: MissionOrigin };
+
+export type SubmitIntakeWorkResult =
+  | { ok: true; track: 'absorb'; ids: string[]; added: number; merged: number }
+  | { ok: true; track: 'tasks'; taskId: string; deduplicated: boolean }
+  | { ok: true; track: 'graph'; acceptanceId: string }
+  | { ok: false; track: IntakeWorkTrack; reason: string };
+
+export type RouteAndSubmitResult =
+  | { decision: IntakeFrontRouteDecision; submitted: SubmitIntakeWorkResult }
+  | { decision: IntakeFrontRouteDecision; askHuman: readonly IntakeWorkTrack[] };
+
+export interface SubmitIntakeWorkDeps {
+  root?: () => string;
+  now?: () => string;
+  ingest?: typeof ingestIntakeItems;
+  createTask?: (input: CreateTaskInput) => Promise<{ taskId?: string; deduplicated?: boolean; output: string }>;
+  askHarness?: (text: string, origin?: MissionOrigin) => Promise<{ acceptanceId?: string; error?: string }>;
+  handleHarnessAskPost?: typeof import('../nexus/api/harness-api.js').handleHarnessAskPost;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export interface CreateTaskInput {
+  title: string;
+  description?: string;
+  surface: { kind: 'llm-direct'; prompt: string };
+  external?: { provider: ExternalTaskSource['provider']; ref: string; url?: string };
+  externalSurfaceDefaulted?: boolean;
+}
+
+const URL_RE = /https?:\/\/\S+/gi;
+export const INTAKE_WORK_TRACKS: readonly IntakeWorkTrack[] = ['absorb', 'tasks', 'graph'];
+
+/** PWA `absorbItemsFromText` 와 같은 규칙 — URL 마다 한 항목, 없으면 글 한 덩이. */
+export function absorbItemsFromText(text: string): RawIntakeItem[] {
+  const urls = text.match(URL_RE) ?? [];
+  return urls.length === 0 ? [{ text }] : urls.map((url) => ({ url }));
+}
+
+/** 첫 줄 = 제목(80자 안) · 나머지 = 설명(4000자 안). 제목이 비면 글 앞부분. */
+export function taskFieldsFromText(text: string): { title: string; description?: string } {
+  const trimmed = text.trim();
+  const [first = '', ...rest] = trimmed.split(/\r?\n/);
+  const title = (first.trim() || trimmed).slice(0, TASK_DEFAULTS.titleMaxLen);
+  const description = rest.join('\n').trim().slice(0, TASK_DEFAULTS.descriptionMaxLen);
+  return description ? { title, description } : { title };
+}
+
+async function defaultCreateTask(input: CreateTaskInput) {
+  const { dispatchTaskCreate } = await import('../task-orchestrator/runtimes/create.js');
+  return dispatchTaskCreate(input as Parameters<typeof dispatchTaskCreate>[0]);
+}
+
+async function defaultAskHarness(text: string, origin?: MissionOrigin, handler?: NonNullable<SubmitIntakeWorkDeps['handleHarnessAskPost']>): Promise<{ acceptanceId?: string; error?: string }> {
+  const handleHarnessAskPost = handler ?? (await import('../nexus/api/harness-api.js')).handleHarnessAskPost;
+  const res = await handleHarnessAskPost(
+    new Request('http://intake.local/v1/harness/ask', { method: 'POST', body: JSON.stringify({ text, ...(origin ? { origin } : {}) }) }),
+    {} as Parameters<typeof handleHarnessAskPost>[1],
+  );
+  const body = await res.json().catch(() => ({})) as { acceptanceId?: unknown; error?: unknown };
+  if (res.ok && typeof body.acceptanceId === 'string') return { acceptanceId: body.acceptanceId };
+  return { error: typeof body.error === 'string' ? body.error : `harness ask HTTP ${res.status}` };
+}
+
+/** 갈래 하나를 실행한다. 판정은 하지 않는다(호출자가 이미 골랐다). */
+export async function submitIntakeWork(
+  input: { text: string; track: IntakeWorkTrack; origin: IntakeWorkOrigin },
+  deps: SubmitIntakeWorkDeps = {},
+): Promise<SubmitIntakeWorkResult> {
+  const log = deps.log ?? ((event, data) => debug.log('intake.submit', event, data));
+  const text = input.text.trim();
+  const base = { track: input.track, origin: input.origin.kind, textLength: text.length };
+  if (!text) {
+    log('rejected', { ...base, reason: 'empty-text' });
+    return { ok: false, track: input.track, reason: 'empty-text' };
+  }
+  try {
+    if (input.track === 'absorb') {
+      const raws = absorbItemsFromText(text);
+      const res = (deps.ingest ?? ingestIntakeItems)(
+        (deps.root ?? effectiveInstanceRoot)(),
+        input.origin.ledgerSource,
+        raws,
+        deps.now?.() ?? new Date().toISOString(),
+      );
+      // HTTP 입구(`intake-ledger-api.ts`)와 같은 id 규칙 — 추적은 이 id 로 `GET /v1/intake-ledger/items/:id`.
+      const ids = raws.map((raw) => intakeItemId(input.origin.ledgerSource, raw));
+      log('submitted', { ...base, ids: ids.length, added: res.added, merged: res.merged });
+      return { ok: true, track: 'absorb', ids, added: res.added, merged: res.merged };
+    }
+    if (input.track === 'tasks') {
+      const fields = taskFieldsFromText(text);
+      const external = input.origin.kind === 'external'
+        ? { provider: input.origin.provider, ref: input.origin.ref, ...(input.origin.url ? { url: input.origin.url } : {}) }
+        : undefined;
+      const res = await (deps.createTask ?? defaultCreateTask)({
+        ...fields,
+        surface: { kind: 'llm-direct', prompt: fields.description ? `${fields.title}\n${fields.description}` : fields.title },
+        ...(external ? { external, externalSurfaceDefaulted: true } : {}),
+      });
+      if (!res.taskId) {
+        log('failed', { ...base, reason: res.output.slice(0, 200) });
+        return { ok: false, track: 'tasks', reason: res.output };
+      }
+      log('submitted', { ...base, taskId: res.taskId, deduplicated: res.deduplicated ?? false });
+      return { ok: true, track: 'tasks', taskId: res.taskId, deduplicated: res.deduplicated ?? false };
+    }
+    const reportTo = input.origin.kind === 'external' ? input.origin.reportTo : undefined;
+    const res = await (deps.askHarness ? deps.askHarness(text, reportTo) : defaultAskHarness(text, reportTo, deps.handleHarnessAskPost));
+    if (!res.acceptanceId) {
+      log('failed', { ...base, reason: res.error ?? 'no-acceptance-id' });
+      return { ok: false, track: 'graph', reason: res.error ?? 'no-acceptance-id' };
+    }
+    log('submitted', { ...base, acceptanceId: res.acceptanceId });
+    return { ok: true, track: 'graph', acceptanceId: res.acceptanceId };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    log('failed', { ...base, reason: reason.slice(0, 200) });
+    return { ok: false, track: input.track, reason };
+  }
+}
+
+/** 판정 ⊕ 실행 한 번 — 텔레그램 입구가 부른다. 규칙이 갈래를 못 고르면 실행하지 않고 고를 갈래를 돌려준다.
+ *  (분류기는 여기서 부르지 않는다 — 앞문 RFC: 사용자가 누를 때만.) */
+export async function routeAndSubmitIntakeWork(
+  input: { text: string; origin: IntakeWorkOrigin; hint?: string },
+  deps: SubmitIntakeWorkDeps = {},
+): Promise<RouteAndSubmitResult> {
+  const decision = decideIntakeFrontRoute({
+    text: input.text,
+    consent: 'route',
+    ...(input.hint ? { hint: input.hint } : {}),
+  });
+  if (decision.track === 'ask-human') return { decision, askHuman: INTAKE_WORK_TRACKS };
+  return { decision, submitted: await submitIntakeWork({ text: input.text, track: decision.track, origin: input.origin }, deps) };
+}

package/src/intake-plane/telegram-work.ts

@@ -0,0 +1,56 @@
+// 텔레그램 `/work <글>` — 봇 메시지를 앞문 판정(흡수·태스크·하니스)으로 넣고 결과를 그 대화로 답한다.
+// RFC-external-tasks-plugins-and-the-task-loop X6(🅢 입구) · 🅕 `routeAndSubmitIntakeWork`(#21003).
+// 외부 출처(telegram · ref = `<chat>:<message>`)라 태스크는 승인 대기로 들어간다(TOX 판정).
+import {
+  INTAKE_WORK_TRACKS,
+  routeAndSubmitIntakeWork,
+  submitIntakeWork,
+  type IntakeWorkOrigin,
+  type IntakeWorkTrack,
+  type SubmitIntakeWorkDeps,
+  type SubmitIntakeWorkResult,
+} from './submit-intake-work.js';
+
+export interface TelegramWorkMessage {
+  chatId: number;
+  messageId: number;
+  botId?: string;
+  threadId?: number;
+}
+
+export interface TelegramWorkDeps extends SubmitIntakeWorkDeps {
+  route?: typeof routeAndSubmitIntakeWork;
+  submit?: typeof submitIntakeWork;
+}
+
+export const TELEGRAM_WORK_USAGE = 'Usage: /work <글> — 알맞은 곳(흡수·태스크·하니스)에 넣습니다 · 갈래를 정하려면 `/work absorb|tasks|graph <글>`';
+
+const TRACK_LABEL: Record<IntakeWorkTrack, string> = { absorb: '흡수', tasks: '태스크', graph: '하니스' };
+
+function origin(msg: TelegramWorkMessage): IntakeWorkOrigin {
+  return {
+    kind: 'external', ledgerSource: 'telegram-bot', provider: 'telegram', ref: `${msg.chatId}:${msg.messageId}`,
+    reportTo: { channel: 'telegram', chatId: msg.chatId, ...(msg.botId ? { botId: msg.botId } : {}), ...(msg.threadId ? { threadId: msg.threadId } : {}) },
+  };
+}
+
+export function formatSubmitted(result: SubmitIntakeWorkResult): string {
+  if (!result.ok) return `❌ ${TRACK_LABEL[result.track]}에 넣지 못했습니다 — ${result.reason.split('\n')[0]!.slice(0, 200)}`;
+  if (result.track === 'absorb') return `📥 흡수 대기열에 넣었습니다 — 새 ${result.added} · 합침 ${result.merged} (${result.ids.slice(0, 3).join(', ')})`;
+  if (result.track === 'tasks') return `🗂 태스크 ${result.taskId}${result.deduplicated ? '(이미 있던 것과 합침)' : ''} — 외부 출처라 승인 대기로 들어갔습니다`;
+  return `🛠 하니스 접수 ${result.acceptanceId}`;
+}
+
+/** `/work` 한 번 — 첫 낱말이 갈래(absorb·tasks·graph)면 판정 없이 그 갈래로, 아니면 앞문 판정. */
+export async function handleTelegramWork(args: readonly string[], msg: TelegramWorkMessage, deps: TelegramWorkDeps = {}): Promise<string> {
+  const first = args[0]?.toLowerCase();
+  const explicit = first && (INTAKE_WORK_TRACKS as readonly string[]).includes(first) ? first as IntakeWorkTrack : undefined;
+  const text = (explicit ? args.slice(1) : args).join(' ').trim();
+  if (!text) return TELEGRAM_WORK_USAGE;
+  if (explicit) return formatSubmitted(await (deps.submit ?? submitIntakeWork)({ text, track: explicit, origin: origin(msg) }, deps));
+  const routed = await (deps.route ?? routeAndSubmitIntakeWork)({ text, origin: origin(msg) }, deps);
+  if ('askHuman' in routed) {
+    return `어디에 넣을까요? 갈래를 붙여 다시 보내 주세요 — ${routed.askHuman.map((t) => `\`/work ${t} …\`(${TRACK_LABEL[t]})`).join(' · ')}`;
+  }
+  return formatSubmitted(routed.submitted);
+}

package/src/iul/sidebar-shell.ts

@@ -1,18 +1,7 @@
-import { stripAnsi } from '../tui.js';
 import { debug } from '../debug/log.js';
-import { Printer } from '../ui/printer.js';
 import { SidebarTabSurface } from '../ui/widgets/sidebar-tab-surface.js';
 import { resolveIulSidebarShellPresentation } from '../ui/chrome/sidebar-shell-presentation.js';
 import { buildIulSidebarItems, IUL_SIDEBAR_TAB_IDS } from './sidebar-shell-catalog.js';
-import { mintPaneId } from '../virtual-windows/addressing.js';
-import type {
-  PaneBroadcast,
-  PaneContent,
-  PaneRenderCtx,
-  PaneUnsubscribe,
-} from '../virtual-windows/pane-content.js';
-import type { Action, KeyEvent, DisplayMouseEvent } from '../display/types.js';
-import { toWidgetMouseEventType, type MouseEvent } from '../ui/mouse-events.js';
 
 export interface IulSidebarShellViewOptions {
   title?: string;
@@ -25,11 +14,6 @@ export interface IulSidebarShellViewOptions {
   };
 }
 
-export interface IulSidebarShellPaneContentSpec {
-  kind: 'iul-shell';
-  title?: string;
-}
-
 export function createIulSidebarShellView(
   opts: IulSidebarShellViewOptions = {},
 ): SidebarTabSurface {
@@ -54,152 +38,3 @@ export function createIulSidebarShellView(
     }),
   });
 }
-
-export function createIulSidebarShellPaneContent(
-  spec: IulSidebarShellPaneContentSpec,
-  deps: {
-    iulThemePreviewControl?: IulSidebarShellViewOptions['themePreviewControl'];
-  } = {},
-): PaneContent {
-  const view = createIulSidebarShellView({
-    title: spec.title ?? 'IUL UX Lab',
-    themePreviewControl: deps.iulThemePreviewControl,
-  });
-  const obs = createObserver();
-  let alive = true;
-  let lastCtx: PaneRenderCtx = { cols: 40, rows: 12, focused: true };
-
-  const renderLines = (ctx: PaneRenderCtx): string[] => {
-    view.layout({ width: Math.max(1, ctx.cols), height: Math.max(1, ctx.rows) });
-    const printer = Printer.create({
-      width: Math.max(1, ctx.cols),
-      height: Math.max(1, ctx.rows),
-      focused: ctx.focused,
-    });
-    view.draw(printer);
-    return printer.lines();
-  };
-
-  return {
-    id: mintPaneId(),
-    kind: spec.kind,
-    title: spec.title ?? 'IUL UX Lab',
-    focusPolicy: 'interactive',
-    hostChromeProfile: 'dock-only',
-    start() {
-      if (debug.enabled) {
-        debug.log('iul.shell', 'pane-start', { title: spec.title ?? 'IUL UX Lab' });
-      }
-    },
-    stop() {
-      alive = false;
-      if (debug.enabled) debug.log('iul.shell', 'pane-stop', { title: spec.title ?? 'IUL UX Lab' });
-    },
-    render(ctx) {
-      lastCtx = ctx;
-      return renderLines(ctx).join('\n');
-    },
-    onKey(ev: KeyEvent): Action {
-      const result = view.onEvent(ev);
-      if (result.kind === 'consumed') {
-        if (debug.enabled) {
-          debug.log('iul.shell', 'pane-key-consumed', {
-            key: ev.name,
-            activeId: view.activeItem?.id ?? null,
-            activeIndex: view.activeIndex,
-          });
-        }
-        obs.emit();
-        return { type: 'refresh' };
-      }
-      return { type: 'none' };
-    },
-    onMouse(ev: DisplayMouseEvent) {
-      if (ev.type === 'release') {
-        if (debug.enabled) {
-          debug.log('iul.shell', 'pane-mouse-ignored', {
-            type: ev.type,
-            row: ev.row,
-            col: ev.col,
-            reason: 'raw-release-outside-capture',
-            activeId: view.activeItem?.id ?? null,
-            activeIndex: view.activeIndex,
-          });
-        }
-        return { type: 'none' };
-      }
-      const localX = Math.max(0, ev.col - 1);
-      const localY = Math.max(0, ev.row - 1);
-      const widgetEvent: MouseEvent = {
-        type: toWidgetMouseEventType(ev.type),
-        x: localX,
-        y: localY,
-        absX: localX,
-        absY: localY,
-        shift: ev.shift,
-        ctrl: ev.ctrl,
-        alt: ev.alt,
-      };
-      if (debug.enabled && ev.type !== 'motion') {
-        debug.log('iul.shell', 'pane-mouse-forward', {
-          type: ev.type,
-          row: ev.row,
-          col: ev.col,
-          localX,
-          localY,
-          activeId: view.activeItem?.id ?? null,
-          activeIndex: view.activeIndex,
-        });
-      }
-      const result = view.onMouse(widgetEvent);
-      if (debug.enabled && ev.type !== 'motion') {
-        debug.log('iul.shell', 'pane-mouse-result', {
-          type: ev.type,
-          row: ev.row,
-          col: ev.col,
-          localX,
-          localY,
-          activeId: view.activeItem?.id ?? null,
-          activeIndex: view.activeIndex,
-          result: result.kind,
-        });
-      }
-      if (result.kind === 'consumed') {
-        obs.emit();
-        return { type: 'refresh' };
-      }
-      return { type: 'none' };
-    },
-    write(_bytes) {},
-    acceptBroadcast(_input: PaneBroadcast) {},
-    capture() {
-      return renderLines({ ...lastCtx, focused: false }).map(stripAnsi).join('\n');
-    },
-    get isAlive() { return alive; },
-    on: obs.on,
-    dispose() {
-      alive = false;
-      if (debug.enabled) debug.log('iul.shell', 'pane-dispose', { title: spec.title ?? 'IUL UX Lab' });
-    },
-  };
-}
-
-function createObserver(): {
-  emit: () => void;
-  on: (event: 'update' | 'output' | 'exit', cb: () => void) => PaneUnsubscribe;
-} {
-  const subs = new Map<'update' | 'output' | 'exit', Set<() => void>>();
-  return {
-    emit() {
-      for (const cb of subs.get('update') ?? []) {
-        try { cb(); } catch { /* ignore */ }
-      }
-    },
-    on(event, cb) {
-      const set = subs.get(event) ?? new Set<() => void>();
-      set.add(cb);
-      subs.set(event, set);
-      return () => { set.delete(cb); };
-    },
-  };
-}