elanous 0.2.6 → 0.2.7

package/src/maturity/feature-maturity.ts

@@ -0,0 +1,65 @@
+export type Maturity = 'stable' | 'beta' | 'tool' | 'ops' | 'broken' | 'system';
+export type Surface = 'pwa' | 'desktop' | 'ios' | 'android' | 'tui' | 'cli' | 'telegram' | 'discord' | 'acp';
+export type Role = 'owner' | 'contributor' | 'general';
+
+type SurfaceMaturity = { pwa: Maturity } & Partial<Record<Exclude<Surface, 'pwa'>, Maturity>>;
+
+/** App Router pages, including the generated 404 and the dynamic missions route. */
+export const FEATURE_MATURITY = {
+  pwaRoute: {
+    '/': { pwa: 'stable' },
+    '/404': { pwa: 'stable' },
+    '/setup': { pwa: 'stable' },
+    '/setup/done': { pwa: 'stable' },
+    '/consult': { pwa: 'stable' },
+    '/chat': { pwa: 'stable' },
+    '/term': { pwa: 'stable' },
+    '/live': { pwa: 'stable' },
+    '/market': { pwa: 'stable' },
+    '/sessions': { pwa: 'stable' },
+    '/settings': { pwa: 'beta' },
+    '/editor': { pwa: 'beta' },
+    '/intake': { pwa: 'beta' },
+    '/trace': { pwa: 'beta' },
+    '/board': { pwa: 'beta' },
+    '/autopilot': { pwa: 'beta' },
+    '/missions/[id]': { pwa: 'beta' },
+    '/tasks': { pwa: 'beta' },
+    '/workspace': { pwa: 'beta' },
+    '/reflection': { pwa: 'beta' },
+    '/vault': { pwa: 'beta' },
+    '/observatory': { pwa: 'beta' },
+    '/exec': { pwa: 'beta' },
+    '/field': { pwa: 'beta' },
+    '/showroom': { pwa: 'beta' },
+    '/workflows': { pwa: 'beta' },
+    '/approvals': { pwa: 'tool' },
+    '/worktrees': { pwa: 'tool' },
+    '/design-check': { pwa: 'tool' },
+    '/control': { pwa: 'tool' },
+    '/scheduler': { pwa: 'ops' },
+    '/dashboard': { pwa: 'ops' },
+    '/bots': { pwa: 'ops' },
+    '/botlab': { pwa: 'ops' },
+    '/morning': { pwa: 'broken' },
+    '/settings/devices': { pwa: 'broken' },
+    '/workflows/chat-ui': { pwa: 'broken' },
+    '/share': { pwa: 'system' },
+  },
+} as const satisfies { pwaRoute: Record<string, SurfaceMaturity> };
+
+/** Unregistered routes and surfaces are not implicitly mature. Desktop shares the PWA implementation. */
+export function maturityOn(route: string, surface: Surface): Maturity | undefined {
+  if (!Object.prototype.hasOwnProperty.call(FEATURE_MATURITY.pwaRoute, route)) return undefined;
+  const grades: SurfaceMaturity = FEATURE_MATURITY.pwaRoute[route as keyof typeof FEATURE_MATURITY.pwaRoute];
+  return grades[surface] ?? (surface === 'desktop' ? grades.pwa : undefined);
+}
+
+export function visibleOn(route: string, surface: Surface, role: Role): boolean {
+  const maturity = maturityOn(route, surface);
+  if (!maturity) return false;
+  if (role === 'owner') return true;
+  if (maturity === 'system') return false;
+  if (route === '/settings') return true;
+  return maturity === 'stable' || (role === 'contributor' && (maturity === 'beta' || maturity === 'tool'));
+}

package/src/model-tier/turn-tier.ts

@@ -0,0 +1,24 @@
+import type { UserConfig } from '../user-config.js';
+import { resolveLlmTier, type LlmTierSource } from './tier-resolver.js';
+import type { ModelTier } from './types.js';
+import type { ReasoningLevel } from '../user-config.js';
+
+export type TurnReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+const REASONING_EFFORT: Record<ReasoningLevel, TurnReasoningEffort> = { off: 'minimal', low: 'low', medium: 'medium', high: 'high', xhigh: 'xhigh' };
+
+/** Only a person's explicit LLM choice changes a chat turn's model. */
+export function explicitTurnTier(
+  cfg: UserConfig,
+  sessionId: string,
+): { model: string; tier: ModelTier; source: LlmTierSource; reasoningEffort?: TurnReasoningEffort } | undefined {
+  try {
+    const resolved = resolveLlmTier(cfg.modelTier, cfg.llm.provider, { sessionId });
+    if (resolved.source !== 'session-override' && resolved.source !== 'user-config-surface') return undefined;
+    // On codex the balanced·better·best tiers share one model and differ only in reasoning level (low·medium·high),
+    // so carrying the model alone left the slider a no-op there (10-01 live).
+    const reasoningEffort = resolved.reasoningLevel ? REASONING_EFFORT[resolved.reasoningLevel] : undefined;
+    return { model: resolved.model, tier: resolved.tier, source: resolved.source, ...(reasoningEffort ? { reasoningEffort } : {}) };
+  } catch {
+    return undefined;
+  }
+}

package/src/msg/msg-store.ts

@@ -0,0 +1,149 @@
+import { Database } from 'bun:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+
+export interface MessageEnvelope {
+  from: string;
+  to: string;
+  body: string;
+  kind?: string;
+}
+
+export interface Message extends MessageEnvelope {
+  id: number;
+  createdAt: string;
+}
+
+export interface UnreadRecipient {
+  recipient: string;
+  count: number;
+}
+
+const SEAT_ALIASES: Readonly<Record<string, string>> = {
+  S: 'OP', OP: 'OP', COO: 'OP',
+  T: 'MK', MK: 'MK', CMO: 'MK',
+  O: 'TC', TC: 'TC', CTO: 'TC',
+  F: 'UX', UX: 'UX', CXO: 'UX',
+};
+
+/** Normalize historic role names to the current seats; leave other valid seats usable. */
+export function canonicalSeatId(value: string): string {
+  if (typeof value !== 'string') throw new TypeError('seat must be a string');
+  const seat = value.trim().toUpperCase();
+  if (!/^[A-Z][A-Z0-9_-]{0,63}$/.test(seat)) throw new Error('invalid seat ID');
+  return Object.hasOwn(SEAT_ALIASES, seat) ? SEAT_ALIASES[seat]! : seat;
+}
+
+/** Check untrusted input before opening the DB or executing a write. */
+export function validateMessageEnvelope(input: unknown): MessageEnvelope {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('message must be an object');
+  const record = input as Record<string, unknown>;
+  const from = canonicalSeatId(record.from as string);
+  const to = canonicalSeatId(record.to as string);
+  if (typeof record.body !== 'string' || !record.body.trim()) throw new Error('message body must be nonempty');
+  if (record.kind !== undefined && (typeof record.kind !== 'string' || !/^[a-z][a-z0-9_-]{0,63}$/.test(record.kind))) {
+    throw new Error('invalid message kind');
+  }
+  if (Object.keys(record).some(key => !['from', 'to', 'body', 'kind'].includes(key))) throw new Error('unknown message field');
+  return record.kind === undefined ? { from, to, body: record.body } : { from, to, body: record.body, kind: record.kind as string };
+}
+
+function validCursor(cursor: number): number {
+  if (!Number.isSafeInteger(cursor) || cursor < 0) throw new Error('cursor must be a nonnegative safe integer');
+  return cursor;
+}
+
+interface MessageRow {
+  id: number;
+  sender: string;
+  recipient: string;
+  body: string;
+  kind: string | null;
+  created_at: string;
+}
+
+function fromRow(row: MessageRow): Message {
+  return { id: row.id, from: row.sender, to: row.recipient, body: row.body,
+    ...(row.kind === null ? {} : { kind: row.kind }), createdAt: row.created_at };
+}
+
+/** SQLite owns both append order and per-recipient acknowledgement progress. */
+export class MsgStore {
+  readonly db: Database;
+
+  constructor(path: string = defaultMsgStorePath()) {
+    if (path !== ':memory:') mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    this.db = new Database(path);
+    this.db.exec('PRAGMA busy_timeout = 5000');
+    this.db.exec(`CREATE TABLE IF NOT EXISTS msg_messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      sender TEXT NOT NULL,
+      recipient TEXT NOT NULL,
+      body TEXT NOT NULL,
+      kind TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_msg_messages_recipient_id ON msg_messages(recipient, id);
+    CREATE TABLE IF NOT EXISTS msg_cursors (
+      recipient TEXT PRIMARY KEY,
+      last_id INTEGER NOT NULL DEFAULT 0 CHECK(last_id >= 0)
+    );`);
+  }
+
+  append(input: MessageEnvelope): Message {
+    const msg = validateMessageEnvelope(input);
+    const createdAt = new Date().toISOString();
+    const result = this.db.query(`INSERT INTO msg_messages(sender, recipient, body, kind, created_at)
+      VALUES (?, ?, ?, ?, ?)`).run(msg.from, msg.to, msg.body, msg.kind ?? null, createdAt);
+    return { id: Number(result.lastInsertRowid), ...msg, createdAt };
+  }
+
+  post(input: MessageEnvelope): Message { return this.append(input); }
+
+  /** Messages strictly after the supplied cursor, ordered by durable insertion ID. */
+  listByRecipient(recipient: string, after: number = 0, limit: number = 100): Message[] {
+    const to = canonicalSeatId(recipient);
+    validCursor(after);
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000) throw new Error('limit must be between 1 and 1000');
+    return (this.db.query(`SELECT id, sender, recipient, body, kind, created_at FROM msg_messages
+      WHERE recipient = ? AND id > ? ORDER BY id ASC LIMIT ?`).all(to, after, limit) as MessageRow[]).map(fromRow);
+  }
+
+  list(recipient: string, after: number = 0, limit: number = 100): Message[] {
+    return this.listByRecipient(recipient, after, limit);
+  }
+
+  getCursor(recipient: string): number {
+    const to = canonicalSeatId(recipient);
+    return (this.db.query('SELECT last_id FROM msg_cursors WHERE recipient = ?').get(to) as { last_id: number } | null)?.last_id ?? 0;
+  }
+
+  /** Atomically reject future IDs and keep concurrent or stale acknowledgements from rewinding. */
+  advanceCursor(recipient: string, cursor: number): number {
+    const to = canonicalSeatId(recipient);
+    validCursor(cursor);
+    const result = this.db.query(`INSERT INTO msg_cursors(recipient, last_id)
+      SELECT ?, ? WHERE ? <= (SELECT COALESCE(MAX(id), 0) FROM msg_messages)
+      ON CONFLICT(recipient) DO UPDATE SET last_id = MAX(msg_cursors.last_id, excluded.last_id)`)
+      .run(to, cursor, cursor);
+    if (result.changes === 0) throw new Error('cursor exceeds the latest message ID');
+    return this.getCursor(to);
+  }
+
+  ack(recipient: string, cursor: number): number { return this.advanceCursor(recipient, cursor); }
+
+  unreadRecipients(): UnreadRecipient[] {
+    return this.db.query(`SELECT m.recipient AS recipient, COUNT(*) AS count
+      FROM msg_messages m LEFT JOIN msg_cursors c ON c.recipient = m.recipient
+      WHERE m.id > COALESCE(c.last_id, 0)
+      GROUP BY m.recipient ORDER BY m.recipient ASC`).all() as UnreadRecipient[];
+  }
+
+  unread(): UnreadRecipient[] { return this.unreadRecipients(); }
+
+  close(): void { this.db.close(); }
+}
+
+export function defaultMsgStorePath(): string { return join(elanousStateRoot(), 'msg', 'messages.db'); }
+export function openMsgStore(path?: string): MsgStore { return new MsgStore(path); }

package/src/native-tool-catalog.ts

@@ -10,6 +10,7 @@ import type { GuardianSpec } from './guardian/types.js';
 import { ptyAvailable } from './pty-shell/registry.js';
 import { krFlowAvailable } from './skills/tools/kr-flow.js';
 import { SELF_COGNITION_MCP_CATALOG_ENTRIES } from './tool-runtime/self-cognition-runtimes.js';
+import { SKILLS_LIST_DESCRIPTION } from './onboarding/entry-hints.js';
 
 export type { NativeToolHost } from './tool-surface.js';
 import type { NativeToolHost } from './tool-surface.js';
@@ -549,7 +550,7 @@ export const nativeToolCatalog: NativeToolCatalogEntry[] = [
     kind: 'other',
     aliases: ['ElanousSkillsList'],
     displayName: 'ElanousSkillsList',
-    description: 'Enumerate installed elanous skills (~/.elanous/skills/* + SKILL.md first line). Read-only.',
+    description: SKILLS_LIST_DESCRIPTION,
     promptSummary: '`elanous_skills_list` (list installed skill names before skill_exec when the exact name is unknown)',
     host: ['skill', 'tui', 'mcp'],
     safety: ['read-only'],

package/src/nexus/api/chat-fast-path-config.ts

@@ -0,0 +1,28 @@
+import { buildUserConfig, saveUserConfig, userConfigPath } from '../../user-config.js';
+
+function json(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+/** GET/PUT /v1/config/chat-fast-path. Authentication is enforced by the HTTP dispatcher. */
+export async function handleChatFastPathConfig(req: Request): Promise<Response> {
+  if (req.method === 'GET') {
+    return json({ enabled: buildUserConfig(userConfigPath()).chat.fastPath });
+  }
+  if (req.method !== 'PUT') return json({ error: 'method-not-allowed' }, 405);
+
+  let body: unknown;
+  try { body = await req.json(); }
+  catch { return json({ error: 'invalid-json' }, 400); }
+  if (!body || typeof body !== 'object' || Array.isArray(body)
+    || Object.keys(body).length !== 1 || typeof (body as { enabled?: unknown }).enabled !== 'boolean') {
+    return json({ error: 'invalid-shape' }, 400);
+  }
+  const path = userConfigPath();
+  const cfg = buildUserConfig(path);
+  saveUserConfig({ ...cfg, chat: { ...cfg.chat, fastPath: (body as { enabled: boolean }).enabled } }, path);
+  return json({ enabled: buildUserConfig(path).chat.fastPath });
+}

package/src/nexus/api/consult-requests.ts

@@ -0,0 +1,117 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { debug } from '../../debug/log.js';
+import { sendOutbound } from '../../domains/outbound-alert.js';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { jsonResponse } from './json-response.js';
+
+export const CONSULT_REQUESTS_PATH = '/v1/consult-requests';
+
+interface ConsultRequest {
+  receiptId: string;
+  name: string;
+  org: string | null;
+  kind: 'company' | 'personal';
+  interest: 'A' | 'B';
+  contact: string;
+  consent: true;
+  receivedAt: string;
+}
+
+export interface ConsultRequestsDeps {
+  root?: () => string;
+  now?: () => string;
+  send?: typeof sendOutbound;
+}
+
+function file(root: string): string {
+  return join(root, 'consult-requests', 'requests.jsonl');
+}
+
+function append(path: string, entry: ConsultRequest): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const previous = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  const temp = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temp, `${previous}${JSON.stringify(entry)}\n`, { mode: 0o600 });
+    const fd = openSync(temp, 'r');
+    try { fsyncSync(fd); } finally { closeSync(fd); }
+    renameSync(temp, path);
+  } catch (error) {
+    try { unlinkSync(temp); } catch { /* no temp file to remove */ }
+    throw error;
+  }
+}
+
+function records(path: string): ConsultRequest[] {
+  try {
+    return readFileSync(path, 'utf8').split('\n').filter(Boolean).map((line) => JSON.parse(line) as ConsultRequest);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+}
+
+function rejected(field: string): Response {
+  debug.log('consult.request', 'rejected', { field });
+  return jsonResponse({ error: 'bad_request', field }, 400);
+}
+
+function singleLine(value: string): string {
+  return value.trim().replace(/[\r\n\u2028\u2029]+/g, ' ');
+}
+
+export async function handleConsultRequests(req: Request, deps: ConsultRequestsDeps = {}): Promise<Response> {
+  if (req.method !== 'GET' && req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
+  const path = file((deps.root ?? effectiveInstanceRoot)());
+  if (req.method === 'GET') {
+    const rawLimit = new URL(req.url).searchParams.get('limit');
+    const limit = rawLimit === null ? 20 : Number(rawLimit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) return rejected('limit');
+    try {
+      const items = records(path).reverse().slice(0, limit).map(({ receiptId, name, org, kind, interest, receivedAt }) =>
+        ({ receiptId, name, org, kind, interest, receivedAt }));
+      return jsonResponse({ items });
+    } catch {
+      return jsonResponse({ error: 'journal-unavailable' }, 503);
+    }
+  }
+
+  let body: unknown;
+  try { body = await req.json(); }
+  catch { return rejected('body'); }
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return rejected('body');
+  const input = body as Record<string, unknown>;
+  for (const field of ['name', 'contact'] as const) {
+    if (typeof input[field] !== 'string' || !input[field].trim()) return rejected(field);
+  }
+  if (input.org !== undefined && (typeof input.org !== 'string' || !input.org.trim())) return rejected('org');
+  if (input.kind !== 'company' && input.kind !== 'personal') return rejected('kind');
+  if (input.interest !== 'A' && input.interest !== 'B') return rejected('interest');
+  if (input.consent !== true) return rejected('consent');
+
+  const entry: ConsultRequest = {
+    receiptId: `R-${randomUUID()}`,
+    name: singleLine(input.name as string),
+    org: typeof input.org === 'string' ? singleLine(input.org) : null,
+    kind: input.kind,
+    interest: input.interest,
+    contact: (input.contact as string).trim(),
+    consent: true,
+    receivedAt: (deps.now ?? (() => new Date().toISOString()))(),
+  };
+  try { append(path, entry); }
+  catch {
+    debug.log('consult.request', 'rejected', { field: 'journal' });
+    return jsonResponse({ error: 'journal-unavailable' }, 503);
+  }
+  debug.log('consult.request', 'accepted', { receiptId: entry.receiptId });
+  try {
+    (deps.send ?? sendOutbound)(
+      `📮 상담 문의 ${entry.receiptId} · ${entry.name}(${entry.kind === 'personal' ? '개인' : (entry.org ?? '회사')}) · 관심 ${entry.interest}\n앱에서 보기`,
+      'alert',
+    );
+  } catch { /* the local receipt remains accepted if delivery is unavailable */ }
+  return jsonResponse({ receiptId: entry.receiptId, receivedAt: entry.receivedAt }, 202);
+}

package/src/nexus/api/discord-trigger-bot.ts

@@ -66,6 +66,8 @@ export interface NexusDiscordTriggerBotOpts {
    *  commands (/cc·/fork·/voice-join·…) route into the same composed
    *  message pipeline. Absent ⇒ interactions ignored (legacy). */
   onInteraction?: (raw: Record<string, unknown>) => void | Promise<void>;
+  /** EV12c — guild text channels answered like DMs (`discord.chatChannels`). Absent ⇒ DM-only. */
+  guildTextChannels?: string[];
   /** Optional logger. Defaults to `[discord/trigger]` prefix. */
   log?: (msg: string) => void;
   /** Test seam — pre-built DiscordBot (factory skips construction +
@@ -156,6 +158,7 @@ export function createNexusDiscordTriggerBot(
   const bot = opts.bot ?? new DiscordBot({
     token: opts.token,
     allowedUsers: opts.allowedUsers,
+    ...(opts.guildTextChannels?.length ? { guildTextChannels: opts.guildTextChannels } : {}),
     // Chat path: the injected self-turn handler (M4b nexus wire) or the
     // legacy trigger-only no-op. Workflows wanting a chat reply can
     // still declare a `chatTrigger` (routes via `/v1/workflows/chat/*`).

package/src/nexus/api/exec-requests.ts

@@ -0,0 +1,51 @@
+import { extname } from 'node:path';
+import { ExecRequestRunner } from '../../exec-requests/runner.js';
+import { jsonResponse } from './json-response.js';
+
+const mime: Record<string, string> = {
+  '.pdf': 'application/pdf', '.mp4': 'video/mp4', '.mov': 'video/quicktime', '.webm': 'video/webm',
+  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp',
+  '.md': 'text/markdown; charset=utf-8', '.txt': 'text/plain; charset=utf-8',
+};
+
+export async function handleExecRequests(req: Request, runner: ExecRequestRunner): Promise<Response> {
+  const path = new URL(req.url).pathname;
+  if (path === '/v1/exec-requests') {
+    if (req.method === 'POST') {
+      let body: unknown;
+      try { body = await req.json(); } catch { return jsonResponse({ error: 'bad_request' }, 400); }
+      const text = body && typeof body === 'object' && !Array.isArray(body) ? (body as { text?: unknown }).text : undefined;
+      if (typeof text !== 'string' || !text.trim()) return jsonResponse({ error: 'bad_request', reason: 'text required' }, 400);
+      const item = runner.submit(text.trim());
+      return jsonResponse({ id: item.id, status: 'planning' }, 202);
+    }
+    if (req.method === 'GET') return jsonResponse({ items: runner.store.list().map(item => {
+      const current = runner.get(item.id) ?? item;
+      return { id: current.id, text: current.text, createdAt: current.createdAt, status: current.status,
+        seats: current.seats.map(({ seat, title, status }) => ({ seat, title, status })), resultCount: current.results.length };
+    }) });
+    return jsonResponse({ error: 'method-not-allowed' }, 405);
+  }
+  const file = /^\/v1\/exec-requests\/([^/]+)\/files\/([^/]+)$/.exec(path);
+  if (file) {
+    if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    let id: string, name: string;
+    try { id = decodeURIComponent(file[1]!); name = decodeURIComponent(file[2]!); }
+    catch { return jsonResponse({ error: 'not-found' }, 404); }
+    const path = runner.file(id, name);
+    if (!path) return jsonResponse({ error: 'not-found' }, 404);
+    return new Response(Bun.file(path), { headers: { 'content-type': mime[extname(path).toLowerCase()] ?? 'application/octet-stream', 'x-content-type-options': 'nosniff' } });
+  }
+  const detail = /^\/v1\/exec-requests\/([^/]+)$/.exec(path);
+  if (detail) {
+    if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    let id: string;
+    try { id = decodeURIComponent(detail[1]!); } catch { return jsonResponse({ error: 'not-found' }, 404); }
+    const item = runner.get(id);
+    if (!item) return jsonResponse({ error: 'not-found' }, 404);
+    const { seats, ...rest } = item;
+    return jsonResponse({ ...rest, seats: seats.map(({ seat, title, status, graphId, runId, reason }) =>
+      ({ seat, title, status, graphId, runId, ...(reason ? { reason } : {}) })) });
+  }
+  return jsonResponse({ error: 'not-found' }, 404);
+}

package/src/nexus/api/field-uploads.ts

@@ -2,11 +2,13 @@
 // 저장 규칙은 src/field/field-media.ts 가 유일한 정본이고 텔레그램 `#현장` 도 같은 함수를 쓴다.
 
 import { debug } from '../../debug/log.js';
+import { readFieldReelStatus, scheduleFieldReel, fieldReelFile, hasFieldReelFile, type FieldReelOptions } from '../../field/field-reel.js';
 import { getElanousConfigDir } from '../../elanous-config-dir.js';
 import {
   FIELD_MAX_FILE_BYTES,
   FIELD_MAX_REQUEST_BYTES,
   FieldUploadError,
+  defaultFieldEvent,
   fieldEventDir,
   isFieldSlug,
   listFieldMedia,
@@ -16,6 +18,9 @@ import {
 import { jsonResponse } from './json-response.js';
 
 export const FIELD_UPLOADS_PATH = '/v1/field/uploads';
+export const FIELD_REEL_PATH = '/v1/field/reel';
+export const FIELD_REEL_FILE_PATH = '/v1/field/reel/file';
+const reelUrl = (event: string) => `${FIELD_REEL_FILE_PATH}?event=${encodeURIComponent(event)}`;
 
 /** 멀티파트 경계·헤더 여유. */
 const MULTIPART_SLACK_BYTES = 4 * 1024 * 1024;
@@ -29,6 +34,9 @@ interface FieldUploadsDeps {
   /** config 뿌리 — 기본 `getElanousConfigDir()`(데몬의 다른 저장소와 같은 해석). 시험은 temp 를 준다. */
   rootDir?: () => string;
   now?: () => Date;
+  reel?: FieldReelOptions;
+  /** 설정 `telegram.fieldDefaultEvent` — 앱이 «오늘» 행사 칸의 기본값으로 받는다(비면 field-<날짜>). */
+  configuredEvent?: () => string | undefined;
 }
 
 function errorResponse(error: FieldUploadError): Response {
@@ -52,6 +60,7 @@ async function readMultipart(req: Request): Promise<FieldMediaInput[]> {
   catch { throw new FieldUploadError('bad-request', 'invalid multipart body'); }
   const files = form.getAll('file').filter((v): v is File => typeof v !== 'string');
   const captured = parseCapturedAtList(form.getAll('capturedAt'));
+  const captions = form.getAll('caption').filter((v): v is string => typeof v === 'string');
   let total = 0;
   const inputs: FieldMediaInput[] = [];
   for (const [i, file] of files.entries()) {
@@ -63,6 +72,7 @@ async function readMultipart(req: Request): Promise<FieldMediaInput[]> {
       mimeType: file.type,
       bytes: new Uint8Array(await file.arrayBuffer()),
       ...(captured[i] ? { capturedAt: captured[i] } : {}),
+      ...((captions.length === 1 ? i === 0 : i < captions.length) ? { caption: captions[i] } : {}),
     });
   }
   return inputs;
@@ -89,22 +99,48 @@ async function readJson(req: Request): Promise<FieldMediaInput[]> {
       ...(typeof f.mimeType === 'string' ? { mimeType: f.mimeType } : {}),
       bytes: new Uint8Array(Buffer.from(f.dataBase64, 'base64')),
       ...(capturedAt !== undefined ? { capturedAt } : {}),
+      ...(typeof f.caption === 'string' ? { caption: f.caption } : {}),
     };
   });
 }
 
 export async function handleFieldUploads(req: Request, deps: FieldUploadsDeps = {}): Promise<Response> {
   const url = new URL(req.url);
-  if (url.pathname !== FIELD_UPLOADS_PATH) return jsonResponse({ error: 'not-found' }, 404);
+  if (![FIELD_UPLOADS_PATH, FIELD_REEL_PATH, FIELD_REEL_FILE_PATH].includes(url.pathname)) return jsonResponse({ error: 'not-found' }, 404);
   if (!deps.authorize?.(req)) return jsonResponse({ error: 'unauthorized' }, 401);
   const rootDir = (deps.rootDir ?? getElanousConfigDir)();
   const event = url.searchParams.get('event') ?? '';
+  // event 없는 GET = 기본 행사 이름만(앱 «오늘» 행사 칸 · 텔레그램 `#현장` 과 같은 기본).
+  if (req.method === 'GET' && !url.searchParams.has('event')) {
+    const defaultEvent = defaultFieldEvent((deps.configuredEvent ?? (() => undefined))(), (deps.now ?? (() => new Date()))());
+    return jsonResponse({ defaultEvent });
+  }
   if (!isFieldSlug(event)) return errorResponse(new FieldUploadError('bad-slug', 'event slug must match ^[a-z0-9][a-z0-9._-]{0,63}$'));
 
+  const dir = fieldEventDir(rootDir, event);
+  if (url.pathname !== FIELD_UPLOADS_PATH && req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+  if (url.pathname === FIELD_REEL_PATH) {
+    const status = readFieldReelStatus(dir);
+    if (!status) return jsonResponse({ error: 'not-found' }, 404);
+    return jsonResponse({ event, state: status.state, items: status.items,
+      ...(status.seconds !== undefined ? { seconds: status.seconds } : {}),
+      ...(status.finishedAt ? { finishedAt: status.finishedAt } : {}),
+      ...(status.state === 'failed' && status.error ? { error: status.error } : {}),
+      ...(status.state === 'done' && hasFieldReelFile(fieldReelFile(dir)) ? { url: reelUrl(event) } : {}) });
+  }
+  if (url.pathname === FIELD_REEL_FILE_PATH) {
+    const status = readFieldReelStatus(dir);
+    const file = fieldReelFile(dir);
+    if (status?.state !== 'done' || !hasFieldReelFile(file)) return jsonResponse({ error: 'not-found' }, 404);
+    return new Response(Bun.file(file), { headers: { 'content-type': 'video/mp4' } });
+  }
   if (req.method === 'GET') {
-    const files = listFieldMedia(fieldEventDir(rootDir, event));
+    const files = listFieldMedia(dir);
+    const status = readFieldReelStatus(dir);
     debug.log('field.upload', 'listed', { count: files.length });
-    return jsonResponse({ event, count: files.length, files });
+    return jsonResponse({ event, count: files.length, files,
+      ...(status ? { reel: { status: status.state, updatedAt: status.updatedAt,
+        ...(status.state === 'done' && hasFieldReelFile(fieldReelFile(dir)) ? { url: reelUrl(event) } : {}) } } : {}) });
   }
   if (req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
 
@@ -131,6 +167,7 @@ export async function handleFieldUploads(req: Request, deps: FieldUploadsDeps =
     debug.log('field.upload', 'saved', {
       surface: 'http', files: result.saved.length, bytes: result.saved.reduce((n, s) => n + s.bytes, 0), count: result.count,
     });
+    scheduleFieldReel(result.dir, deps.reel);
     return jsonResponse({ ok: true, event, saved: result.saved, count: result.count });
   } catch (error) {
     if (error instanceof FieldUploadError) {