elanous 0.2.5 → 0.2.7

package/src/tool-runtime/self-cognition-runtimes.ts

@@ -1,7 +1,9 @@
 import { createRequire } from 'node:module';
+import { isMainThread, parentPort, Worker } from 'node:worker_threads';
+import { debug } from '../debug/log.js';
 import type { LLMToolSpec } from '../llm.js';
 import type { NativeToolCatalogEntry } from '../native-tool-catalog.js';
-import type { ToolRunResult, ToolRuntime } from './types.js';
+import type { ToolRunResult, ToolRuntime, ToolRuntimeContext } from './types.js';
 
 /** Canonical names for the read-only self-cognition surface. */
 export const SELF_COGNITION_TOOL_NAMES = [
@@ -12,6 +14,7 @@ export const SELF_COGNITION_TOOL_NAMES = [
 ] as const;
 
 type SelfCognitionToolName = (typeof SELF_COGNITION_TOOL_NAMES)[number];
+type RecallToolName = 'memory_recall' | 'self_recall';
 type CoreToolsModule = typeof import('../domains/core-tools.js');
 
 const require = createRequire(import.meta.url);
@@ -32,12 +35,167 @@ function toToolRunResult(result: unknown): ToolRunResult {
     : { output: String(result) };
 }
 
+const PROGRESS_MS = 10_000;
+const DEFAULT_BUDGET_MS = 60_000;
+const MAX_TIMER_MS = 2_147_483_647;
+
+function hitCount(result: ToolRunResult): number {
+  const data: Record<string, unknown> = result;
+  return Array.isArray(data.hits) ? data.hits.length
+    : Array.isArray(data.events) ? data.events.length
+      : data.restored ? 1 : 0;
+}
+
+function partialResult(name: RecallToolName, result: ToolRunResult | undefined, budgetMs: number): ToolRunResult {
+  const fallback = name === 'memory_recall' ? { hits: [], count: 0 } : { events: [], count: 0, docs: null };
+  const snapshot: Record<string, unknown> = result ?? fallback;
+  const budgetSeconds = budgetMs / 1000;
+  return {
+    ...snapshot,
+    partial: true,
+    note: `${typeof snapshot.note === 'string' ? `${snapshot.note}\n` : ''}(찾던 중 ${budgetSeconds}초에서 멈췄습니다 — 더 찾을까요?)`,
+  };
+}
+
+/** A deadline returns the latest completed search stage; late results cannot replace it. */
+export async function runBudgetedRecall(
+  name: RecallToolName,
+  args: Record<string, unknown>,
+  ctx: ToolRuntimeContext,
+  search: (onPartial: (result: ToolRunResult) => void) => Promise<ToolRunResult>,
+  stop: () => void = () => {},
+  progressAfterMs = PROGRESS_MS,
+): Promise<ToolRunResult> {
+  const started = Date.now();
+  const budgetMs = typeof args.timeBudgetMs === 'number' && Number.isFinite(args.timeBudgetMs) && args.timeBudgetMs > 0
+    ? Math.min(args.timeBudgetMs, MAX_TIMER_MS) : DEFAULT_BUDGET_MS;
+  let latest: ToolRunResult | undefined;
+  let settled = false;
+  const query = typeof args.query === 'string' && args.query.trim()
+    ? args.query.trim().replace(/\s+/g, ' ').slice(0, 80)
+    : name === 'self_recall' ? '자기 구현·자율행동 이력' : '최근 발송·대화';
+  const log = (event: 'progress' | 'budget-hit' | 'done', result?: ToolRunResult) => {
+    debug.log('tool.memory-recall', event, { elapsedMs: Date.now() - started, hits: hitCount(result ?? latest ?? {}) });
+  };
+  let progressTimer: ReturnType<typeof setTimeout> | undefined;
+  let budgetTimer: ReturnType<typeof setTimeout> | undefined;
+  return new Promise<ToolRunResult>((resolve, reject) => {
+    const finish = (result: ToolRunResult, budgetHit: boolean) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(progressTimer);
+      clearTimeout(budgetTimer);
+      log(budgetHit ? 'budget-hit' : 'done', result);
+      if (budgetHit) stop();
+      resolve(result);
+    };
+    progressTimer = setTimeout(() => {
+      if (settled) return;
+      const line = `기억을 찾는 중 — ${query}`;
+      ctx.emitFeedback?.({
+        envelopeVersion: 1,
+        sessionId: ctx.sessionId ?? '',
+        blockId: `${ctx.sessionId ?? 'recall'}:tool:${ctx.toolCallId ?? name}:progress`,
+        parentToolCallId: ctx.toolCallId,
+        kind: 'tool.progress', phase: 'delta', emittedAt: Date.now(), seq: 1,
+        payload: { stream: 'generic', lines: [line] }, asciiFallback: [line],
+      });
+      log('progress');
+    }, progressAfterMs);
+    budgetTimer = setTimeout(() => finish(partialResult(name, latest, budgetMs), true), budgetMs);
+    try {
+      void search(result => { if (!settled) latest = result; }).then(
+        result => finish(result, false),
+        error => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(progressTimer);
+          clearTimeout(budgetTimer);
+          stop();
+          reject(error);
+        },
+      );
+    } catch (error) {
+      settled = true;
+      clearTimeout(progressTimer);
+      clearTimeout(budgetTimer);
+      stop();
+      reject(error);
+    }
+  });
+}
+
+// Separate thread: synchronous SQLite and S3 restore must not block progress/deadline timers.
+if (!isMainThread && parentPort) {
+  parentPort.on('message', async ({ name, args }: { name: RecallToolName; args: Record<string, unknown> }) => {
+    try {
+      if (name === 'self_recall') {
+        const { existsSync } = await import('node:fs');
+        const { surfaceEventsDbPath, openSurfaceEventsDb, recallEvents } = await import('../domains/surface-events.js');
+        if (existsSync(surfaceEventsDbPath())) {
+          const db = openSurfaceEventsDb();
+          try {
+            const query = typeof args.query === 'string' ? args.query : '';
+            const hits = recallEvents(db, {
+              domain: 'elanous',
+              sinceHours: typeof args.sinceHours === 'number' ? args.sinceHours : 720,
+              limit: typeof args.limit === 'number' ? args.limit : 8,
+              ...(query ? { query } : {}),
+            });
+            const events = hits.map(h => ({
+              when: h.ts, tool: h.surface, kind: h.kind ?? 'impl',
+              summary: (h.summary ?? h.text).slice(0, 300), score: Math.round(h.score * 1000) / 1000,
+            }));
+            parentPort?.postMessage({ stage: 'partial', result: { events, count: events.length, docs: null } });
+          } catch { /* self_recall's episode stage is fail-soft */ } finally { db.close(); }
+        }
+      }
+      const result = await coreTools().dispatchRecallUnbudgeted(name, args, partial => {
+        parentPort?.postMessage({ stage: 'partial', result: partial });
+      });
+      parentPort?.postMessage({ stage: 'done', result });
+    } catch (error) {
+      parentPort?.postMessage({ stage: 'error', error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+}
+
+export type RecallSearch = (name: RecallToolName, args: Record<string, unknown>, onPartial: (result: ToolRunResult) => void) => Promise<ToolRunResult>;
+
+export function runRecall(name: RecallToolName, args: Record<string, unknown>, ctx: ToolRuntimeContext, injectedSearch?: RecallSearch, onPartial?: (result: ToolRunResult) => void): Promise<ToolRunResult> {
+  const worker = injectedSearch ? undefined : new Worker(new URL(import.meta.url));
+  let active = true;
+  const search = (capture: (result: ToolRunResult) => void) => {
+    const report = (result: ToolRunResult) => {
+      if (!active) return;
+      capture(result);
+      onPartial?.(result);
+    };
+    return injectedSearch
+      ? injectedSearch(name, args, report)
+      : new Promise<ToolRunResult>((resolve, reject) => {
+        worker!.on('message', (message: { stage: string; result?: unknown; error?: string }) => {
+          if (message.stage === 'partial') report(toToolRunResult(message.result));
+          else if (message.stage === 'done') resolve(toToolRunResult(message.result));
+          else if (message.stage === 'error') reject(new Error(message.error));
+        });
+        worker!.on('error', reject);
+        worker!.on('exit', code => { if (code !== 0) reject(new Error(`Recall worker exited: ${code}`)); });
+        worker!.postMessage({ name, args });
+      });
+  };
+  return runBudgetedRecall(name, args, ctx, search, () => { active = false; if (worker) void worker.terminate(); })
+    .finally(() => { active = false; if (worker) void worker.terminate(); });
+}
+
 export const SELF_COGNITION_RUNTIMES: readonly ToolRuntime[] = SELF_COGNITION_TOOL_NAMES.map(name => ({
   id: name,
   get spec() {
     return coreSpec(name);
   },
-  run: async (args) => toToolRunResult(await coreTools().buildCoreTools().dispatch(name, args)),
+  run: async (args, ctx) => name === 'memory_recall' || name === 'self_recall'
+    ? runRecall(name, args, ctx)
+    : toToolRunResult(await coreTools().buildCoreTools().dispatch(name, args)),
 }));
 
 /** MCP catalog metadata derived from the same name ledger as the runtimes. */

package/src/user-config.ts

@@ -47,6 +47,7 @@ import {
   GLM_MODEL,
 } from './config.js';
 import type { SkillTier } from './skills/runner.js';
+import { sharedAgentSkillRoots } from './skills/shared-agent-skill-roots.js';
 import {
   isModelTier,
   isModelTierPersona,
@@ -439,6 +440,8 @@ export type SkillSetName =
 export interface SkillsConfig {
   activeSet: SkillSetName;
   dirs: string[];
+  /** Include the existing shared ~/.agents/skills directory. Default true; false opts out. */
+  includeSharedAgentSkills?: boolean;
   /** Explicit skill-name allowlist. When set and non-empty, the skill
    *  index filters to this list — all other skills are hidden from
    *  routing, autocompletion, and `/run-skill`. Use when a project
@@ -505,6 +508,8 @@ export interface DefaultSkillDirsOptions {
   pluginsRoot?: string;
   /** Override the installed package root. Tests pass a temp root; production omits this. */
   bundledSkillsRoot?: string;
+  /** Override the shared-agent home for isolated discovery tests. */
+  sharedAgentHome?: string;
 }
 
 /** Resolve the `skills/` directory shipped with this installed package. */
@@ -527,6 +532,15 @@ export function defaultSkillDirs(
     } else if (sk.dirs.length > 0) {
       base = [...sk.dirs];
     }
+    const shared = sharedAgentSkillRoots({
+      home: opts?.sharedAgentHome ?? REMOTE_HOME,
+      includeSharedAgentSkills: sk.includeSharedAgentSkills !== false,
+    });
+    try { debug.log('skills.roots', 'shared-agent', { found: shared.length }); }
+    catch { /* discovery remains fail-soft when observation is unavailable */ }
+    for (const dir of shared) {
+      if (!base.includes(dir)) base.push(dir);
+    }
     base = sk.includeClaudePackageSkills === true
       ? appendClaudePackageSkillDirs(base, opts?.pluginsRoot)
       : base;
@@ -685,6 +699,7 @@ function skillsDefaults(): SkillsConfig {
   return {
     activeSet: 'claudecode',
     dirs: d ? [d] : [],
+    includeSharedAgentSkills: true,
     allow: [],
     deny: [],
     urlRouting: urlRoutingDefaults(),
@@ -833,6 +848,8 @@ export interface TelegramConfig {
   /** 발송 목적(kind) → 채널 역할. 명시 `channels` 가 있을 때만 쓴다 — 표에 없는 kind 는 옛 `reportChannel` 로 간다.
    *  기본표는 `DEFAULT_KIND_ROLES`(telegram-report.ts) · 여기 값이 덮어쓴다. */
   kindRoles?: Record<string, string>;
+  /** `#현장` 캡션에 행사 슬러그가 없을 때 쓸 기본 행사(예: `marketers-night-2026-10`). 없으면 `field-<로컬 날짜>`. */
+  fieldDefaultEvent?: string;
 }
 
 const TELEGRAM_DEFAULTS: TelegramConfig = { enabled: false, allowedUsers: [] };
@@ -884,6 +901,9 @@ export interface DiscordConfig {
   allowedUsers: string[];
   /** Channel snowflake for cron / push output (optional). */
   homeChannel?: string;
+  /** EV12c — guild text channels where the production bot chats like a DM (allowlist still applies).
+   *  Empty / absent = DM-only, as before. */
+  chatChannels?: string[];
   /** Standalone `elanous discord-test` scope — same token, dedicated
    *  channel, isolated state. See DiscordTestChannel. */
   testChannel?: DiscordTestChannel;
@@ -894,6 +914,7 @@ const DISCORD_DEFAULTS: DiscordConfig = { enabled: false, allowedUsers: [] };
 // ── Onboarding ───────────────────────────────────────────────────────
 
 export interface OnboardingConfig {
+  webFirst?: boolean;
   completed: boolean;
   completedAt?: string;
   version: number;
@@ -1364,6 +1385,8 @@ export interface ChatCompactConfig {
 }
 
 export interface ChatConfig {
+  /** Short questions may receive a tool-free first reply. Default true. */
+  fastPath: boolean;
   conciseness: ChatConcisenessConfig;
   toolOutput: ChatToolOutputConfig;
   autoCompact: ChatAutoCompactConfig;
@@ -1390,6 +1413,7 @@ const CHAT_CONCISENESS_DEFAULTS: ChatConcisenessConfig = {
 };
 
 export const CHAT_DEFAULTS: ChatConfig = {
+  fastPath: true,
   conciseness: { ...CHAT_CONCISENESS_DEFAULTS },
   toolOutput: {
     persistOnOverflow: true,
@@ -3322,9 +3346,16 @@ export function resolveRoleModel(role: ModelRole, config: UserConfig = getUserCo
 }
 
 
+export type SeatLoopMode = 'off' | 'shadow' | 'on';
+
+export interface SeatLoopConfig {
+  /** No seat actions by default; shadow observes without execution, on permits the seat loop to act. */
+  mode: SeatLoopMode;
+}
+
 export interface UserConfig {
-  /** Steward loop: observe-only until an independently approved act implementation exists. */
-  loops?: { steward?: { mode?: 'observe' | 'act'; linearTeam?: string; roles?: Record<string, { maxConcurrent?: number }>; budget?: number; tracks?: Record<string, string> } };
+  /** Steward and seat loops are parsed independently. An absent seat remains off. */
+  loops?: { steward?: { mode?: 'observe' | 'act'; linearTeam?: string; roles?: Record<string, { maxConcurrent?: number }>; budget?: number; tracks?: Record<string, string>; alertAfterFailures?: number }; seat?: SeatLoopConfig };
   /** 🔐 Pod 의 Grok API 키 과금은 명시 opt-in 만. 생략·잘못된 값은 false.
    *  budgetGate 와 같은 `harness` 객체다 — 중복 선언이면 뒤 타입이 앞을 지운다. */
   harness?: { pod?: { grokApiKeyOptIn: boolean }; budgetGate?: HarnessBudgetGateConfig; defaultRepo?: string; substrate?: 'local' | 'pod'; podPool?: string };
@@ -3428,7 +3459,7 @@ export interface UserConfig {
   /** 승인 뒤 조율 채널 페이즈 배달(기본 OFF) 및 트랙 에이전트(기본 OFF, 최대 동시 2개). */
   autopilot?: {
     trackCourier?: { enabled?: boolean; channelPr?: number; handoffMinutes?: number };
-    trackAgent?: { enabled: boolean; maxConcurrent: number };
+    trackAgent?: { enabled: boolean; maxConcurrent: number; shadow: boolean; shadowMaxDecisionsPerDay: number };
   };
   /** 하니스 예산 게이트 설정. 판정은 P15 — 여기선 칸만 싣는다. 파서는 항상 기본을 채운다.
    *  선택이다 — 기존 UserConfig 리터럴이 이 칸 없이 컴파일되게 한다. 해석기는 없으면 기본을 쓴다.
@@ -3616,6 +3647,10 @@ function parseAutopilotConfig(raw: unknown): UserConfig['autopilot'] | undefined
       enabled: v.enabled === true,
       maxConcurrent: typeof v.maxConcurrent === 'number' && Number.isSafeInteger(v.maxConcurrent) && v.maxConcurrent > 0
         ? Math.min(v.maxConcurrent, 2) : 2,
+      shadow: v.shadow === true,
+      shadowMaxDecisionsPerDay: typeof v.shadowMaxDecisionsPerDay === 'number'
+        && Number.isSafeInteger(v.shadowMaxDecisionsPerDay) && v.shadowMaxDecisionsPerDay >= 0
+        ? v.shadowMaxDecisionsPerDay : 20,
     };
   }
   return Object.keys(parsed).length > 0 ? parsed : undefined;
@@ -3647,6 +3682,7 @@ function parseRoleLlmConfig(raw: unknown): RoleLlmConfig | undefined {
 
 function defaultConfig(): UserConfig {
   return {
+    loops: { seat: { mode: 'off' } },
     skillRouter: { ...SR_DEFAULTS },
     llm: { ...LLM_DEFAULTS },
     skills: skillsDefaults(),
@@ -3659,6 +3695,7 @@ function defaultConfig(): UserConfig {
     logs: { retention: { ...LOGS_DEFAULTS.retention } },
     shell: { ...SHELL_DEFAULTS },
     chat: {
+      fastPath: CHAT_DEFAULTS.fastPath,
       conciseness: { ...CHAT_CONCISENESS_DEFAULTS },
       toolOutput: { ...CHAT_DEFAULTS.toolOutput },
       autoCompact: { ...CHAT_DEFAULTS.autoCompact },
@@ -4124,6 +4161,14 @@ function parseStewardTracks(input: unknown): Record<string, string> | undefined
   return Object.keys(out).length ? out : undefined;
 }
 
+function parseSeatLoopsConfig(input: unknown): SeatLoopConfig {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return { mode: 'off' };
+  const seat = (input as Record<string, unknown>).seat;
+  if (!seat || typeof seat !== 'object' || Array.isArray(seat)) return { mode: 'off' };
+  const mode = (seat as Record<string, unknown>).mode;
+  return { mode: mode === 'on' || mode === 'shadow' ? mode : 'off' };
+}
+
 function parseStewardLoopsConfig(input: unknown): UserConfig['loops'] {
   if (!input || typeof input !== 'object' || Array.isArray(input)) return undefined;
   const value = (input as Record<string, unknown>).steward;
@@ -4142,6 +4187,7 @@ function parseStewardLoopsConfig(input: unknown): UserConfig['loops'] {
     ...(typeof s.linearTeam === 'string' && s.linearTeam.trim() ? { linearTeam: s.linearTeam.trim() } : {}),
     ...(Object.keys(roles).length ? { roles } : {}),
     ...(typeof s.budget === 'number' && Number.isFinite(s.budget) && s.budget >= 0 ? { budget: s.budget } : {}),
+    ...(typeof s.alertAfterFailures === 'number' && Number.isSafeInteger(s.alertAfterFailures) && s.alertAfterFailures > 0 ? { alertAfterFailures: s.alertAfterFailures } : {}),
     ...(parseStewardTracks(s.tracks) ? { tracks: parseStewardTracks(s.tracks)! } : {}),
   } };
 }
@@ -4372,6 +4418,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
     skills: {
       activeSet: normalizeSkillSet(sk.activeSet),
       dirs: strArray(sk.dirs, skillsDefaults().dirs),
+      includeSharedAgentSkills: sk.includeSharedAgentSkills !== false,
       allow: strArray(sk.allow, []),
       deny: strArray(sk.deny, []),
       urlRouting: parseUrlRouting(sk.urlRouting),
@@ -4393,6 +4440,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       testChannel: normalizeTestChannel(tg.testChannel),
       ...(tg.poller === 'standalone' || tg.poller === 'nexus' ? { poller: tg.poller } : {}),
       ...(normalizeKindRoles(tg.kindRoles) ? { kindRoles: normalizeKindRoles(tg.kindRoles)! } : {}),
+      ...(str(tg.fieldDefaultEvent) ? { fieldDefaultEvent: str(tg.fieldDefaultEvent)! } : {}),
     },
     discord: {
       enabled: dc.enabled === true,
@@ -4406,6 +4454,9 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       homeChannel: typeof dc.homeChannel === 'string' ? dc.homeChannel
         : typeof dc.homeChannel === 'number' ? String(dc.homeChannel) : undefined,
       testChannel: normalizeDiscordTestChannel((dc as Record<string, unknown>).testChannel),
+      ...(Array.isArray(dc.chatChannels)
+        ? { chatChannels: (dc.chatChannels as unknown[]).map(v => String(v).trim()).filter(Boolean) }
+        : {}),
       // Sprint 21 wiring sub-block (2026-05-01)
     },
     finance: {
@@ -4449,6 +4500,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       relaxedGates: fin.relaxedGates === true,
     },
     onboarding: {
+      ...(typeof ob2.webFirst === 'boolean' ? { webFirst: ob2.webFirst } : {}),
       completed: ob2.completed === true,
       completedAt: str(ob2.completedAt),
       version: typeof ob2.version === 'number' ? ob2.version : 0,
@@ -4495,6 +4547,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       allowDashboardOptionalTools: sh.allowDashboardOptionalTools !== false,
     },
     chat: {
+      fastPath: chat.fastPath === false || chat.fastPath === 'false' ? false : CHAT_DEFAULTS.fastPath,
       conciseness: {
         enabled: chatConciseness.enabled === false ? false : CHAT_CONCISENESS_DEFAULTS.enabled,
         finalMessageMaxLines: clampNum(
@@ -4873,7 +4926,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
     goals: parseGoalsConfig(rawObj.goals),
     registry: parseRegistryConfig(rawObj.registry),
     tools: parseToolsConfig(rawObj.tools),
-    ...(stewardLoops ? { loops: stewardLoops } : {}),
+    loops: { ...(stewardLoops ?? {}), seat: parseSeatLoopsConfig(rawObj.loops) },
     // M1-1: sparse — undefined when the user hasn't set anything, so
     // resolvers fall through to zero-config defaults.
     ...spreadIfDefined('modelTier', parseModelTierConfig(rawObj.modelTier)),
@@ -5447,6 +5500,11 @@ export function saveUserConfig(
   const rawHarness = rawRest.harness && typeof rawRest.harness === 'object' && !Array.isArray(rawRest.harness)
     ? rawRest.harness as Record<string, unknown> : {};
   delete rawRest.harness;
+  const rawAutopilot = rawRest.autopilot && typeof rawRest.autopilot === 'object' && !Array.isArray(rawRest.autopilot)
+    ? rawRest.autopilot as Record<string, unknown> : {};
+  const rawLoops = rawRest.loops && typeof rawRest.loops === 'object' && !Array.isArray(rawRest.loops)
+    ? rawRest.loops as Record<string, unknown> : {};
+  if (cfg.loops) delete rawRest.loops;
   if (cfg.pod?.hostMirror) {
     const rawPod = rawRest.pod && typeof rawRest.pod === 'object' && !Array.isArray(rawRest.pod)
       ? rawRest.pod as Record<string, unknown> : {};
@@ -5463,6 +5521,24 @@ export function saveUserConfig(
       podPool: cfg.harness?.podPool,
     }),
     ...rawRest,
+    ...(cfg.loops ? { loops: {
+      ...rawLoops,
+      ...(cfg.loops.seat ? { seat: { mode: cfg.loops.seat.mode } } : {}),
+    } } : {}),
+    ...(cfg.autopilot ? { autopilot: {
+      ...rawAutopilot,
+      ...cfg.autopilot,
+      ...(cfg.autopilot.trackAgent ? { trackAgent: {
+        ...(rawAutopilot.trackAgent && typeof rawAutopilot.trackAgent === 'object' && !Array.isArray(rawAutopilot.trackAgent)
+          ? rawAutopilot.trackAgent as Record<string, unknown> : {}),
+        ...cfg.autopilot.trackAgent,
+      } } : {}),
+      ...(cfg.autopilot.trackCourier ? { trackCourier: {
+        ...(rawAutopilot.trackCourier && typeof rawAutopilot.trackCourier === 'object' && !Array.isArray(rawAutopilot.trackCourier)
+          ? rawAutopilot.trackCourier as Record<string, unknown> : {}),
+        ...cfg.autopilot.trackCourier,
+      } } : {}),
+    } } : {}),
     skillRouter: cfg.skillRouter,
     llm: stripUndef({
       provider: cfg.llm.provider,
@@ -5565,12 +5641,14 @@ export function saveUserConfig(
       // ★ 2026-09-25: `poller`(T1 분리 스위치)가 파서엔 있고 이 whitelist 에 없어 `config set telegram.poller` 가
       //   「직렬화 드롭」으로 조용히 사라졌다 — 운영 전환 스위치를 켤 방법이 없었다(07-22 botUsername 과 같은 모양).
       poller: cfg.telegram.poller,
+      fieldDefaultEvent: cfg.telegram.fieldDefaultEvent,
     }),
     discord: stripUndef({
       enabled: cfg.discord.enabled,
       botToken: cfg.discord.botToken,
       allowedUsers: [...cfg.discord.allowedUsers],
       homeChannel: cfg.discord.homeChannel,
+      chatChannels: cfg.discord.chatChannels ? [...cfg.discord.chatChannels] : undefined,
       testChannel: cfg.discord.testChannel
         ? stripUndef({
             channelId: cfg.discord.testChannel.channelId,
@@ -5597,6 +5675,7 @@ export function saveUserConfig(
       relaxedGates: cfg.finance.relaxedGates,
     }),
     onboarding: stripUndef({
+      webFirst: cfg.onboarding.webFirst,
       completed: cfg.onboarding.completed,
       completedAt: cfg.onboarding.completedAt,
       version: cfg.onboarding.version,
@@ -5605,6 +5684,7 @@ export function saveUserConfig(
     logs: cfg.logs,
     shell: cfg.shell,
     chat: stripUndef({
+      fastPath: cfg.chat.fastPath,
       conciseness: stripUndef({
         enabled: cfg.chat.conciseness.enabled,
         finalMessageMaxLines: cfg.chat.conciseness.finalMessageMaxLines,

package/src/version/packed-revision.json

@@ -1 +1 @@
-{"commit":"e491ebfd1661520b780aff439e71baa26895ab53"}
+{"commit":"eadd7c31e07d4414ce452d943984a2e58a01ede4"}

package/src/video-pipeline/recipes/character.ts

@@ -14,8 +14,10 @@
  *     (📏 2026-09-23: 연출 있는 shot2 = 0.708 < 연출 없는 대조군 0.851).
  */
 import { spawnSync } from 'node:child_process';
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { searchVflowReferences } from '../vflow-reference.js';
 import { run } from './ffmpeg.js';
 import { resolvePython } from '../../python/resolve-python.js';
 import { UNOBSERVED, type Recipe } from './types.js';
@@ -111,14 +113,49 @@ export const identityHoldsGate: Recipe = async (ctx) => {
 export const directedShots: Recipe = async (ctx) => {
   const src = ctx.state.shot_sources as Record<string, string> | undefined;
   if (!src) return need('shot_sources');
-  const shot_paths = Object.values(src).filter(existsSync);
-  if (shot_paths.length === 0) return { outcome: 'error', note: '샷 0 — ⛔ 이 러너는 크레딧을 안 쓴다(Seedance·Kling 생성은 스킬 세션의 몫)' };
+  const prompts = ctx.state.shot_prompts as Record<string, string> | undefined;
+  const existingShots = Object.entries(src).filter(([, path]) => existsSync(path));
+  const shot_paths = existingShots.map(([, path]) => path);
+  const promptedShots = existingShots.filter(([shot]) => prompts?.[shot] !== undefined);
+  const shot_references: Record<string, { url: string; videoUrl: string | null; model: string; name: string; author: string | null; authorUrl: string | null; camera: string[] }[]> = {};
+  let referenceNote = '';
+  if (prompts && Object.keys(prompts).length && shot_paths.length) {
+    const file = (ctx.state.vflow_file as string | undefined) ?? join(homedir(), 'docs', 'ref', 'vflow', 'prompts.ndjson');
+    const taxonomy = readFileSync(join(import.meta.dir, '../../../graphs/video/reference/vflow-taxonomy.yaml'), 'utf8');
+    const cameraAxis = taxonomy.match(/^  camera_movement:.*\n((?:^    .*\n)*)/m)?.[1] ?? '';
+    const cameraTerms = [...cameraAxis.matchAll(/term:\s*([^,}]+)/g)].map((match) => match[1]!.trim());
+    // These shot-prompt camera terms supplement the site's taxonomy axis.
+    cameraTerms.push('crash zoom', 'dolly', 'static');
+    const cameraPatterns = cameraTerms.map((term) => {
+      const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      return { term, pattern: new RegExp(`(?<![\\p{L}\\p{N}])${escaped}(?![\\p{L}\\p{N}])`, 'iu') };
+    });
+    let found = 0;
+    for (const [shot] of promptedShots) {
+      const prompt = prompts[shot]!;
+      const camera = cameraPatterns.filter(({ pattern }) => pattern.test(prompt)).map(({ term }) => term);
+      const result = searchVflowReferences(file, { camera, model: ctx.state.shot_model as string | undefined, limit: camera.length ? 3 : 0 });
+      if (!result.available) {
+        referenceNote = `vflow DB 없음(${result.reason})`;
+        break;
+      }
+      shot_references[shot] = result.rows.map((row) => ({
+        url: row.url, videoUrl: row.video?.url ?? null, model: row.model, name: row.name,
+        author: row.author, authorUrl: row.authorUrl, camera: row.spec?.camera ?? [],
+      }));
+      if (shot_references[shot]!.length) found++;
+    }
+    if (!referenceNote) referenceNote = `vflow 참고 ${found}샷/${shot_paths.length}샷`;
+  }
+  const note = (text: string) => referenceNote ? `${text}\n${referenceNote}` : text;
+  if (shot_paths.length === 0) return { outcome: 'error', produced: prompts ? { shot_references } : undefined, note: note('샷 0 — ⛔ 이 러너는 크레딧을 안 쓴다(Seedance·Kling 생성은 스킬 세션의 몫)') };
+  const produced = { shot_paths, shot_count: shot_paths.length, ...(prompts ? { shot_references } : {}) };
   // ⛔⭐ 되돌이 수렴(🩸 2026-09-23 실물: fullbleed → shots → «같은» 샷 → fullbleed … 예산 소진).
   //   리프레임 자가 「그 비율로 다시 렌더하라」고 돌려보냈는데 이 러너는 다시 그릴 수 없다(크레딧 무사용)
   //   ⇒ 같은 샷을 또 내면 같은 판정이 난다. 「못 다시 그린다」를 error 로 말해 `rendered-unedited` 로 끝낸다.
   const pending = (ctx.state.fullbleed_cuts as string[] | undefined) ?? [];
-  if (pending.length) return { outcome: 'error', produced: { shot_paths, shot_count: shot_paths.length }, note: `전용 비율 재렌더가 필요한 샷 ${pending.join(', ')} — ⛔ 이 러너는 다시 그리지 않는다(크레딧 무사용) · 그 비율 렌더를 스킬 세션에서 만든 뒤 native 로 넘겨라` };
-  return { outcome: 'ok', produced: { shot_paths, shot_count: shot_paths.length }, note: `샷 ${shot_paths.length}개 · ⚠️ 이미 생성된 것을 받았다` };
+  if (pending.length) return { outcome: 'error', produced, note: note(`전용 비율 재렌더가 필요한 샷 ${pending.join(', ')} — ⛔ 이 러너는 다시 그리지 않는다(크레딧 무사용) · 그 비율 렌더를 스킬 세션에서 만든 뒤 native 로 넘겨라`) };
+  return { outcome: 'ok', produced, note: note(`샷 ${shot_paths.length}개 · ⚠️ 이미 생성된 것을 받았다`) };
 };
 
 /** `08_shot_ruler.py` 의 `shot_variation` 한 칸만 읽는다(그 자가 «살아남은 유일한 칸»이라 스스로 적었다). */