elanous 0.2.6 → 0.2.8

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,
@@ -436,9 +437,28 @@ const LLM_DEFAULTS: LLMConfig = { provider: 'auto' };
 export type SkillSetName =
   | 'claudecode' | 'opencode' | 'codex' | 'hermes' | 'openclaw' | 'custom';
 
+export type SkillSourceKind = 'preset' | 'shared' | 'connected' | 'package';
+
+/** One skill root elanous reads. `mode` is always `ref` today (the folder is read where it is). */
+export interface SkillSource {
+  id: string;
+  path: string;
+  kind: SkillSourceKind;
+  enabled: boolean;
+}
+
 export interface SkillsConfig {
   activeSet: SkillSetName;
   dirs: string[];
+  /** Include the existing shared ~/.agents/skills directory. Default true; false opts out. */
+  includeSharedAgentSkills?: boolean;
+  /**
+   * EN5 — the one source list. On disk it holds only what `elanous connect` registered (kind `connected`, read in
+   * place, never copied); the preset (`activeSet`/`dirs`), the shared `~/.agents/skills` root and Claude package
+   * roots are derived at read time by `resolveSkillSources()`. The dev-only `connected: string[]` key (EN9, never
+   * released) is read and folded in here; the next save writes `sources` instead.
+   */
+  sources?: SkillSource[];
   /** 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 +525,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. */
@@ -512,25 +534,84 @@ export function bundledSkillsDir(packageRoot: string = dirname(import.meta.dir))
   return join(packageRoot, 'skills');
 }
 
-export function defaultSkillDirs(
-  cfg?: UserConfig,
-  opts?: DefaultSkillDirsOptions,
-): string[] {
+function packageOptIn(cfg?: UserConfig): boolean {
+  try { return (cfg ?? getUserConfig()).skills.includeClaudePackageSkills === true; } catch { return false; }
+}
+
+/** Stable id for a connected root: the agent it belongs to, else the folder (plugin) name. */
+export function skillSourceId(path: string): string {
+  if (/[/\\]\.codex[/\\]skills\/?$/.test(path)) return 'codex';
+  if (/[/\\]\.claude[/\\]skills\/?$/.test(path)) return 'claude';
+  const parts = path.split(/[/\\]/).filter(Boolean);
+  const last = parts[parts.length - 1] === 'skills' ? parts[parts.length - 2] : parts[parts.length - 1];
+  return `plugin:${last ?? 'skills'}`;
+}
+
+/** Parse persisted `skills.sources` ⊕ the dev-only `skills.connected` key into connected sources (deduped by path). */
+export function parsePersistedSkillSources(rawSources: unknown, legacyConnected: unknown): SkillSource[] | undefined {
+  const out: SkillSource[] = [];
+  const seen = new Set<string>();
+  const push = (source: SkillSource) => { if (!seen.has(source.path)) { seen.add(source.path); out.push(source); } };
+  if (Array.isArray(rawSources)) {
+    for (const row of rawSources) {
+      if (!row || typeof row !== 'object') continue;
+      const r = row as Record<string, unknown>;
+      if (typeof r.path !== 'string' || !r.path.trim()) continue;
+      const path = r.path.trim();
+      push({ id: typeof r.id === 'string' && r.id.trim() ? r.id.trim() : skillSourceId(path), path, kind: 'connected', enabled: r.enabled !== false });
+    }
+  }
+  if (Array.isArray(legacyConnected)) {
+    for (const path of legacyConnected) if (typeof path === 'string' && path.trim()) push({ id: skillSourceId(path.trim()), path: path.trim(), kind: 'connected', enabled: true });
+  }
+  return out.length ? out : undefined;
+}
+
+/**
+ * ★ EN5 — the ONE function every reader uses (loader · setup checklist · connect · onboarding).
+ * Order is the historical order, so an old config resolves to exactly the old directory list:
+ * preset (activeSet/dirs) → shared ~/.agents/skills (only when it exists) → connected → Claude package roots (opt-in).
+ * Packaged `skills/` is appended by defaultSkillDirs, not listed here.
+ */
+export function resolveSkillSources(cfg?: UserConfig, opts?: DefaultSkillDirsOptions): SkillSource[] {
   const claudecode = skillSetDir('claudecode')!; // = ~/.claude/skills (LOCAL_SKILLS_DIR)
-  let base = [claudecode];
+  const preset = (paths: string[], id: string): SkillSource[] => paths.map((path, i) => ({ id: paths.length > 1 ? `${id}:${i + 1}` : id, path, kind: 'preset', enabled: true }));
+  let sources: SkillSource[] = preset([claudecode], 'claudecode');
   try {
     const sk = (cfg ?? getUserConfig()).skills;
     if (sk.activeSet !== 'custom') {
       const d = skillSetDir(sk.activeSet);
-      if (d) base = [d];
-      else if (sk.dirs.length > 0) base = [...sk.dirs];
+      if (d) sources = preset([d], sk.activeSet);
+      else if (sk.dirs.length > 0) sources = preset([...sk.dirs], 'custom');
     } else if (sk.dirs.length > 0) {
-      base = [...sk.dirs];
+      sources = preset([...sk.dirs], 'custom');
+    }
+    const has = (path: string) => sources.some((source) => source.path === path);
+    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 path of shared) if (!has(path)) sources.push({ id: 'agents', path, kind: 'shared', enabled: true });
+    for (const source of sk.sources ?? []) if (!has(source.path)) sources.push({ ...source, kind: 'connected' });
+    if (sk.includeClaudePackageSkills === true) {
+      for (const path of appendClaudePackageSkillDirs([], opts?.pluginsRoot)) {
+        if (!has(path)) sources.push({ id: `package:${skillSourceId(path).replace(/^plugin:/, '')}`, path, kind: 'package', enabled: true });
+      }
     }
-    base = sk.includeClaudePackageSkills === true
-      ? appendClaudePackageSkillDirs(base, opts?.pluginsRoot)
-      : base;
   } catch { /* fail-soft — config 없거나 파싱 실패 시 기본 경로 */ }
+  return sources;
+}
+
+export function defaultSkillDirs(
+  cfg?: UserConfig,
+  opts?: DefaultSkillDirsOptions,
+): string[] {
+  const sources = resolveSkillSources(cfg, opts);
+  const paths = sources.filter((source) => source.enabled).map((source) => source.path);
+  // Historical: the package opt-in path also collapsed duplicate user dirs; the plain path kept them (index dedupes later).
+  const base = sources.some((source) => source.kind === 'package') || packageOptIn(cfg) ? uniqueSkillDirsPreserveOrder(paths) : paths;
   return appendBundledSkillsDir(base, opts?.bundledSkillsRoot);
 }
 
@@ -685,6 +766,7 @@ function skillsDefaults(): SkillsConfig {
   return {
     activeSet: 'claudecode',
     dirs: d ? [d] : [],
+    includeSharedAgentSkills: true,
     allow: [],
     deny: [],
     urlRouting: urlRoutingDefaults(),
@@ -886,6 +968,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;
@@ -896,6 +981,7 @@ const DISCORD_DEFAULTS: DiscordConfig = { enabled: false, allowedUsers: [] };
 // ── Onboarding ───────────────────────────────────────────────────────
 
 export interface OnboardingConfig {
+  webFirst?: boolean;
   completed: boolean;
   completedAt?: string;
   version: number;
@@ -1365,7 +1451,31 @@ export interface ChatCompactConfig {
   archiveRetentionMb: number;
 }
 
+/** ER1 — 액티브 덤퍼(오류 자동 보고). 기본 켬(첫 실행 안내 한 번 · 대표 10-01) · 신원(email/telegramUser)은 따로 «예»일 때만. */
+export interface ErrorReportsConfig {
+  /** false = never send. Absent = on (the first-run notice says how to turn it off). */
+  enabled?: boolean;
+  /** true = also send email / telegramUser below with each report. Default false. */
+  identity?: boolean;
+  email?: string;
+  telegramUser?: string;
+}
+
+export function parseErrorReportsConfig(raw: unknown): ErrorReportsConfig | undefined {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+  const r = raw as Record<string, unknown>;
+  const out: ErrorReportsConfig = {};
+  if (r.enabled === false || r.enabled === 'false') out.enabled = false;
+  else if (r.enabled === true || r.enabled === 'true') out.enabled = true;
+  if (r.identity === true || r.identity === 'true') out.identity = true;
+  if (typeof r.email === 'string' && r.email.trim()) out.email = r.email.trim();
+  if (typeof r.telegramUser === 'string' && r.telegramUser.trim()) out.telegramUser = r.telegramUser.trim();
+  return Object.keys(out).length ? out : undefined;
+}
+
 export interface ChatConfig {
+  /** Short questions may receive a tool-free first reply. Default true. */
+  fastPath: boolean;
   conciseness: ChatConcisenessConfig;
   toolOutput: ChatToolOutputConfig;
   autoCompact: ChatAutoCompactConfig;
@@ -1392,6 +1502,7 @@ const CHAT_CONCISENESS_DEFAULTS: ChatConcisenessConfig = {
 };
 
 export const CHAT_DEFAULTS: ChatConfig = {
+  fastPath: true,
   conciseness: { ...CHAT_CONCISENESS_DEFAULTS },
   toolOutput: {
     persistOnOverflow: true,
@@ -3324,9 +3435,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 };
@@ -3344,6 +3462,8 @@ export interface UserConfig {
   logs: LogsConfig;
   shell: ShellConfig;
   chat: ChatConfig;
+  /** ER1 — optional so older fixtures stay valid; absent = defaults. */
+  errorReports?: ErrorReportsConfig;
   voice: VoiceConfig;
   intake: IntakeConfig;
   dashboard: DashboardConfig;
@@ -3430,7 +3550,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 리터럴이 이 칸 없이 컴파일되게 한다. 해석기는 없으면 기본을 쓴다.
@@ -3618,6 +3738,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;
@@ -3649,6 +3773,7 @@ function parseRoleLlmConfig(raw: unknown): RoleLlmConfig | undefined {
 
 function defaultConfig(): UserConfig {
   return {
+    loops: { seat: { mode: 'off' } },
     skillRouter: { ...SR_DEFAULTS },
     llm: { ...LLM_DEFAULTS },
     skills: skillsDefaults(),
@@ -3661,6 +3786,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 },
@@ -4126,6 +4252,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;
@@ -4144,6 +4278,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)! } : {}),
   } };
 }
@@ -4374,6 +4509,8 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
     skills: {
       activeSet: normalizeSkillSet(sk.activeSet),
       dirs: strArray(sk.dirs, skillsDefaults().dirs),
+      includeSharedAgentSkills: sk.includeSharedAgentSkills !== false,
+      ...(() => { const sources = parsePersistedSkillSources(sk.sources, sk.connected); return sources ? { sources } : {}; })(),
       allow: strArray(sk.allow, []),
       deny: strArray(sk.deny, []),
       urlRouting: parseUrlRouting(sk.urlRouting),
@@ -4409,6 +4546,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: {
@@ -4452,6 +4592,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,
@@ -4497,7 +4638,9 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       // false required to short-circuit `buildDashboardOptionalToolSpecs`.
       allowDashboardOptionalTools: sh.allowDashboardOptionalTools !== false,
     },
+    ...((): { errorReports?: ErrorReportsConfig } => { const er = parseErrorReportsConfig(rawObj.errorReports); return er ? { errorReports: er } : {}; })(),
     chat: {
+      fastPath: chat.fastPath === false || chat.fastPath === 'false' ? false : CHAT_DEFAULTS.fastPath,
       conciseness: {
         enabled: chatConciseness.enabled === false ? false : CHAT_CONCISENESS_DEFAULTS.enabled,
         finalMessageMaxLines: clampNum(
@@ -4876,7 +5019,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)),
@@ -5450,6 +5593,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> : {};
@@ -5466,6 +5614,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,
@@ -5517,6 +5683,10 @@ export function saveUserConfig(
     skills: stripUndef({
       activeSet: cfg.skills.activeSet,
       dirs: [...cfg.skills.dirs],
+      // EN5 — only connected roots are persisted (preset/shared/package are derived). The dev-only `connected` key is not written back.
+      sources: cfg.skills.sources && cfg.skills.sources.some((source) => source.kind === 'connected')
+        ? cfg.skills.sources.filter((source) => source.kind === 'connected').map(({ id, path, enabled }) => ({ id, path, enabled }))
+        : undefined,
       // Omit allow/deny when empty to keep disk JSON minimal for the
       // common "no filter" case.
       allow: cfg.skills.allow && cfg.skills.allow.length > 0 ? [...cfg.skills.allow] : undefined,
@@ -5575,6 +5745,7 @@ export function saveUserConfig(
       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,
@@ -5601,6 +5772,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,
@@ -5608,7 +5780,9 @@ export function saveUserConfig(
     debug: cfg.debug,
     logs: cfg.logs,
     shell: cfg.shell,
+    errorReports: cfg.errorReports ? stripUndef({ ...cfg.errorReports }) : undefined,
     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":"65a4c7230c60a536b0f0f0428322c8ddcbcac752"}
+{"commit":"eca73b4a3a106df99424c22206165f2fe4e5e910"}

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` 한 칸만 읽는다(그 자가 «살아남은 유일한 칸»이라 스스로 적었다). */