elanous 0.2.7 → 0.2.9

package/src/task-orchestrator/surfaces/pod-command-job.ts

@@ -5,6 +5,7 @@
 // codex·elanous 자격 파일은 이 Job 에 없다. 격리 관문(호스트 넥서스에 닿으면 종료)은 기존 Job 과 같다.
 // 명령 인자는 셸 문자열로 이어붙이지 않고 `"$@"` 로 따로 인용한다.
 
+import { randomBytes } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { isAbsolute } from 'node:path';
 import { getUserConfig } from '../../user-config.js';
@@ -66,6 +67,8 @@ if [ -d "$HOME/outbox" ]; then
 fi`;
 
 export interface PodCommandJobInput {
+  /** POD1 — this launch's own label; cleanup selects by it, never by name alone. */
+  launch?: string;
   name: string;
   namespace: string;
   image: string;
@@ -122,13 +125,13 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
   return {
     apiVersion: 'batch/v1',
     kind: 'Job',
-    metadata: { name: o.name, namespace: o.namespace, labels: { 'elanous.substrate': 'pod', 'elanous.job': o.name, 'elanous.kind': 'command' } },
+    metadata: { name: o.name, namespace: o.namespace, labels: { 'elanous.substrate': 'pod', 'elanous.job': o.name, 'elanous.kind': 'command', ...(o.launch ? { 'elanous.launch': o.launch } : {}) } },
     spec: {
       backoffLimit: 0,
       ttlSecondsAfterFinished: 7200,
       activeDeadlineSeconds: o.deadlineSeconds,
       template: {
-        metadata: { labels: { 'elanous.job': o.name, 'elanous.kind': 'command' } },
+        metadata: { labels: { 'elanous.job': o.name, 'elanous.kind': 'command', ...(o.launch ? { 'elanous.launch': o.launch } : {}) } },
         spec: {
           restartPolicy: 'Never',
           securityContext: { runAsUser: 1000, fsGroup: 1000 },
@@ -166,6 +169,7 @@ export function commandJobSecret(o: {
   skillEnvText: Readonly<Record<string, string>>;
   grokAuth?: string;
   ghToken?: string;
+  launch?: string;
 }): Record<string, unknown> | null {
   const stringData: Record<string, string> = {};
   if (o.grokAuth !== undefined) stringData['grok-auth.json'] = o.grokAuth;
@@ -177,7 +181,7 @@ export function commandJobSecret(o: {
   if (Object.keys(stringData).length === 0) return null;
   return {
     apiVersion: 'v1', kind: 'Secret', type: 'Opaque',
-    metadata: { name: `${o.name}-creds`, namespace: o.namespace, labels: { 'elanous.job': o.name } },
+    metadata: { name: `${o.name}-creds`, namespace: o.namespace, labels: { 'elanous.job': o.name, ...(o.launch ? { 'elanous.launch': o.launch } : {}) } },
     stringData,
   };
 }
@@ -265,7 +269,11 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
   const image = options.image ?? 'elanous-harness:local';
   const repoUrl = options.repoUrl ?? 'https://github.com/ElanvitalAI/elanous';
   const deadlineSeconds = options.deadlineSeconds ?? POD_COMMAND_DEADLINE_SECONDS;
-  const name = options.name ?? podJobName(`cmd-${Date.now().toString(36)}`);
+  // POD1 (10-01): two launches in the same moment got the same `si-cmd-<time>` and the failing one's cleanup
+  // deleted the other's credentials. The name now has a random tail, and cleanup selects this launch's label.
+  const launch = randomBytes(6).toString('hex');
+  const name = options.name ?? podJobName(`cmd-${Date.now().toString(36)}-${randomBytes(4).toString('hex')}`);
+  const own = `elanous.job=${name},elanous.launch=${launch}`;
   const env = options.env ?? process.env;
   const hostMirror = (options.hostMirror ?? env.ELANOUS_POD_HOST_MIRROR
     ?? (options.configHostMirror ?? (() => getUserConfig().pod?.hostMirror))())?.trim() || undefined;
@@ -293,7 +301,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
   const currentContext = member || options.kubectl ? null : baseKubectl(['config', 'current-context']);
   const context = member?.context ?? (currentContext?.status === 0 ? currentContext.stdout.trim() : '');
   const kubectl: Kubectl = (args, stdin) => baseKubectl(context ? ['--context', context, ...args] : [...args], stdin);
-  const cleanupSecret = () => { kubectl(['-n', namespace, 'delete', 'secret', `${name}-creds`, '--ignore-not-found']); };
+  const cleanupSecret = () => { kubectl(['-n', namespace, 'delete', 'secret', '-l', own, '--ignore-not-found']); };
   const artifactsDir = `${options.artifactsRoot ?? `${effectiveInstanceRoot()}/pod-artifacts`}/${name}`;
   try {
     if (!context && !options.kubectl) throw new Error('pod command: kubectl context 를 확인할 수 없다');
@@ -328,19 +336,19 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       if (synced?.imageRef) member = { ...member, imageRef: synced.imageRef };
     }
     const ghToken = options.clone ? (options.ghToken ?? defaultGhToken)() : undefined;
-    const secret = commandJobSecret({ name, namespace, skills, skillEnvText, ...(grokAuth !== undefined ? { grokAuth } : {}), ...(ghToken !== undefined ? { ghToken } : {}) });
+    const secret = commandJobSecret({ name, namespace, launch, skills, skillEnvText, ...(grokAuth !== undefined ? { grokAuth } : {}), ...(ghToken !== undefined ? { ghToken } : {}) });
     if (secret) {
       const applied = kubectl(['apply', '-f', '-'], JSON.stringify(secret));
       if (applied.status !== 0) throw new Error(applied.stderr.trim() || 'pod command: Secret 적용 실패');
     }
     const manifest = podCommandJobManifest({
-      name, namespace, image: member?.imageRef ?? image,
+      name, namespace, launch, image: member?.imageRef ?? image,
       ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
       repoUrl, command, skills, ...(llm ? { llm } : {}), ...(options.clone ? { clone: true } : {}),
       ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(options.memoryLimit ? { memoryLimit: options.memoryLimit } : {}), deadlineSeconds,
       ...(options.runId ? { runId: options.runId } : {}),
     });
-    kubectl(['-n', namespace, 'delete', 'job', name, '--ignore-not-found']);
+    kubectl(['-n', namespace, 'delete', 'job', '-l', own, '--ignore-not-found']);
     const applied = kubectl(['apply', '-f', '-'], JSON.stringify(manifest));
     if (applied.status !== 0) {
       cleanupSecret();

package/src/telegram-commands.ts

@@ -762,6 +762,35 @@ export function defaultTelegramCommands(): TgSlashCommand[] {
         });
       },
     },
+    {
+      name: 'decisions',
+      description: '열린 결정 목록 — 카드를 다시 보내 여기서 바로 정할 수 있습니다',
+      handler: async (_args, ctx) => {
+        const { telegramDecisionService } = await import('./decisions/telegram-decision-cards.js');
+        const service = telegramDecisionService();
+        if (!service) return '결정 카드가 이 봇에 연결되어 있지 않습니다.';
+        if (!service.isOwner(String(ctx.userId))) return '결정은 소유자만 볼 수 있습니다.';
+        // A group would show every member the cards (and route memos from them) — private chat only (TC review #22660).
+        if (ctx.chatId !== ctx.userId) return '결정은 개인 대화에서만 볼 수 있습니다.';
+        return service.listOpen(String(ctx.chatId));
+      },
+    },
+    ...(['coo', 'cto', 'cmo', 'cxo'] as const).map((command) => ({
+      name: command,
+      description: `${command.toUpperCase()} 자리에 일을 넘깁니다 — /${command} <할 일> (조율 채널 ⊕ 자리 메시지함)`,
+      handler: async (args: string[], ctx: { chatId: number; userId: number }) => {
+        const [{ handleCeoSeatCommand }, { telegramDecisionOwner }, { runGh }, { getUserConfig }, { openMsgStore }] = await Promise.all([
+          import('./seat-dispatch/ceo-commands.js'), import('./decisions/telegram-decision-cards.js'), import('./decisions/decision-cards.js'),
+          import('./user-config.js'), import('./msg/msg-store.js'),
+        ]);
+        const cfg = getUserConfig();
+        const replyTarget = (cfg.raw?.decisions as { replyGhPr?: unknown } | undefined)?.replyGhPr;
+        return handleCeoSeatCommand(command, args, ctx, {
+          ownerId: telegramDecisionOwner(cfg), replyTarget: typeof replyTarget === 'string' ? replyTarget : null, runGh,
+          append: (message) => { const store = openMsgStore(); try { return store.append(message); } finally { store.close(); } },
+        });
+      },
+    })),
     {
       name: 'work',
       description: '글을 알맞은 곳(흡수·태스크·하니스)에 넣고 결과를 여기로 답합니다 — /work [absorb|tasks|graph] <글>',

package/src/telegram-run.ts

@@ -11,6 +11,10 @@
 // - 워크플로 트리거는 core 의 `POST /v1/workflows/telegram-dispatch` 로 넘긴다(`telegram-dispatch-forward.ts`).
 
 import { debug } from './debug/log.js';
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { effectiveInstanceRoot } from './instance/resolve.js';
 import { getUserConfig } from './user-config.js';
 import { resolveChannelBotToken } from './channel-bot-token.js';
 import { forwardTelegramDispatch } from './telegram-dispatch-forward.js';
@@ -55,10 +59,10 @@ export function setTelegramPollLockForTesting(deps: typeof pollLockForTesting):
 /** 폴러를 띄우고 핸들을 돌려준다(시험용으로 분리 — 대기는 `runTelegramPoller` 가 한다). */
 export async function startTelegramPollers(): Promise<TelegramRunResult> {
   const cfg = getUserConfig();
-  const mainToken = resolveChannelBotToken('telegram', cfg)?.token;
-  if (!cfg.telegram.enabled || !mainToken) {
-    throw new Error('telegram run: telegram.enabled 가 꺼져 있거나 bot token 이 없다');
-  }
+  if (cfg.telegram.enabled === false) throw new Error('telegram run: telegram.enabled 가 꺼져 있다');
+  const resolved = resolveChannelBotToken('telegram', cfg);
+  if (!resolved.token) throw new Error(`telegram run: bot token 못 풂 — ${resolved.reason}`);
+  const mainToken = resolved.token;
   if (cfg.telegram.poller !== 'standalone') {
     console.warn('[telegram run] ⚠️ telegram.poller 가 standalone 이 아니다 — 넥서스도 같은 토큰을 폴링하려 한다. 토큰 잠금이 먼저 잡은 쪽만 띄운다.');
   }
@@ -105,25 +109,91 @@ export async function startTelegramPollers(): Promise<TelegramRunResult> {
   return { started, refusedBotIds, late };
 }
 
-/** SIGINT/SIGTERM 까지 돈다. */
-export async function runTelegramPoller(): Promise<void> {
+function failurePath(): string { return join(effectiveInstanceRoot(), 'telegram', 'run-failures.json'); }
+
+function failureState(): { count: number; alerted: boolean } {
+  const path = failurePath();
+  if (!existsSync(path)) return { count: 0, alerted: false };
+  const data: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!data || typeof data !== 'object' || !('count' in data) || !Number.isSafeInteger(data.count)
+    || (data.count as number) < 0 || ('alerted' in data && typeof data.alerted !== 'boolean')) {
+    throw new Error(`invalid telegram run failures at ${path}`);
+  }
+  return { count: data.count as number, alerted: 'alerted' in data ? data.alerted as boolean : false };
+}
+
+function writeFailureState(count: number, alerted: boolean): void {
+  const path = failurePath();
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${randomUUID()}.tmp`;
   try {
-    const { registerStandaloneLogSink } = await import('./domains/standalone-log-sink.js');
-    await registerStandaloneLogSink('telegram-run');
+    writeFileSync(tmp, JSON.stringify({ count, alerted }), { mode: 0o600, flag: 'wx' });
+    renameSync(tmp, path);
+  } finally { if (existsSync(tmp)) unlinkSync(tmp); }
+}
+
+/** SIGINT/SIGTERM 까지 돈다. Failure exit policy is tested without a live poller. */
+export async function runTelegramPoller(deps: {
+  start?: typeof startTelegramPollers;
+  alert?: (text: string, kind: string) => boolean;
+  wait?: () => Promise<void>;
+  registerLogSink?: () => Promise<void>;
+} = {}): Promise<void> {
+  try {
+    if (deps.registerLogSink) await deps.registerLogSink();
+    else {
+      const { registerStandaloneLogSink } = await import('./domains/standalone-log-sink.js');
+      await registerStandaloneLogSink('telegram-run');
+    }
   } catch (e) {
     console.error(`[telegram run] ⚠️ 로그 싱크 등록 실패(관측 유실 가능): ${e instanceof Error ? e.message : String(e)}`);
   }
   console.log('[telegram run] 토큰 잠금을 잡는 중 (토큰마다 최대 30초)…');
-  const { started, refusedBotIds, late } = await startTelegramPollers();
+  let result: TelegramRunResult;
+  try {
+    if (!deps.start) {
+      const [{ registerAllCloudBackends }, { selectBackendFromConfig }] = await Promise.all([
+        import('./nexus/config/secrets/register-cloud.js'), import('./nexus/config/secrets/registry.js'),
+      ]);
+      registerAllCloudBackends();
+      selectBackendFromConfig();
+    }
+    result = await (deps.start ?? startTelegramPollers)();
+    if (result.started.length === 0) throw new Error('telegram run: 띄운 폴러가 없다');
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : 'unknown start failure';
+    const previous = failureState();
+    const count = previous.count + 1;
+    writeFailureState(count, previous.alerted);
+    debug.log('telegram.run', 'start-failed', { count, reason });
+    if (count >= 3) {
+      if (!previous.alerted) {
+        try {
+          const alert = deps.alert ?? (await import('./domains/outbound-alert.js')).sendOutbound;
+          if (!alert(`텔레그램 폴러가 3번 연속 못 떴다 — ${reason}`, 'alert')) {
+            throw new Error('telegram run: outbound alert not delivered');
+          }
+        } catch (alertError) {
+          debug.log('telegram.run', 'alert-failed', { count, reason });
+          throw alertError;
+        }
+        writeFailureState(count, true);
+        debug.log('telegram.run', 'alerted', { count, reason });
+      }
+      return;
+    }
+    throw error;
+  }
+  const { started, refusedBotIds, late } = result;
+  const path = failurePath();
+  if (existsSync(path)) unlinkSync(path);
   debug.log('telegram.run', 'started', { pid: process.pid, pollers: started.length, refusedBotIds });
   for (const botId of refusedBotIds) {
     console.warn(`[telegram run] 봇 ${botId}: 다른 프로세스가 폴링 중 — 15초마다 다시 잡으러 간다 (elanous logs --category telegram.run)`);
   }
-  // 하나도 못 잡았으면 끝낸다(exit≠0) — 서비스 관리자(launchd KeepAlive·systemd Restart)가 다시 띄운다.
-  if (started.length === 0) throw new Error('telegram run: 띄운 폴러가 없다');
   for (const { channel } of started) console.log(`[telegram run] 채널 '${channel.name}' 폴러 활성 (${channel.botToken.split(':')[0]})`);
   console.log('[telegram run] Ctrl-C 로 멈춘다.');
-  await new Promise<void>((resolve) => {
+  await (deps.wait?.() ?? new Promise<void>((resolve) => {
     const stop = (): void => {
       process.off('SIGINT', stop);
       process.off('SIGTERM', stop);
@@ -135,5 +205,5 @@ export async function runTelegramPoller(): Promise<void> {
     };
     process.on('SIGINT', stop);
     process.on('SIGTERM', stop);
-  });
+  }));
 }

package/src/telegram.ts

@@ -919,6 +919,24 @@ export class TelegramBot {
     return undefined;
   }
 
+  /** DEC-TG — replace a message's text AND its inline keyboard (empty rows remove the buttons). */
+  async editMessageWithKeyboard(
+    chatId: number,
+    messageId: number,
+    text: string,
+    buttons: Array<Array<{ text: string; data: string }>>,
+  ): Promise<void> {
+    await this.throttledCall<unknown>(chatId, 'editMessageText', {
+      chat_id: chatId,
+      message_id: messageId,
+      text: text.length > this.maxChars ? `${text.slice(0, this.maxChars - 2)} …` : text,
+      reply_markup: { inline_keyboard: buttons.map((row) => row.map((b) => ({ text: b.text, callback_data: b.data.slice(0, 64) }))) },
+    });
+  }
+
+  /** True while the long-poll loop runs — only a polling bot should push decision cards (nexus may hold a send-only bot). */
+  isPolling(): boolean { return this.running; }
+
   /** T2-P6 — acknowledge a callback_query so Telegram clears the
    *  spinner next to the button the user tapped. Pass a `text` to
    *  flash a tiny toast on the user's device (≤200 chars). Returns
@@ -1156,6 +1174,8 @@ export class TelegramBot {
           if (u.callback_query) {
             const cq = u.callback_query;
             if (!this.isOwnerAllowed(cq.from.id)) {
+              // DEC-TG — a decision-card tap from someone else is the rehearsal's «refused» case; name it there too.
+              if ((cq.data ?? '').startsWith('dec:')) debug.log('decisions.telegram', 'tap-refused', { platform: 'telegram', gate: 'owner-allowlist' }, { level: 'warn' });
               debug.log('telegram.owner-gate', 'refused', {
                 kind: 'callback', reason: this.allowedUsers.size === 0 ? 'empty-allowlist' : 'not-allowed', userId: cq.from.id,
               });
@@ -1425,6 +1445,9 @@ export class TelegramBot {
               ...reply, mimeType: 'video/mp4', caption: `현장 영상 · ${event} · ${result.seconds}초`,
             });
             if (!sent) throw new Error('sendDocument failed');
+            if (result.feed?.started) {
+              await this.sendMessage(ctx.chatId, `인스타 피드 초안을 만드는 중 · ${event} — 1분쯤 뒤 앱 «게시 대기»에서 고치고 «최종 게시»를 누르면 됩니다(누르기 전엔 아무 데도 안 올라갑니다).`, reply);
+            }
           } else {
             await this.sendMessage(ctx.chatId, `현장 영상 실패 · ${event} · ${result.error ?? 'render failed'}`, reply);
           }
@@ -2840,6 +2863,17 @@ export function botFromConfig(opts: BotFromConfigOpts): TelegramBot {
   // poll loop requests `callback_query` from the first getUpdates —
   // in-turn approval taps then arrive without a mid-turn delay.
   botRef.ensureSurfaceHitl();
+  // DEC-TG(대표 10-02) — decision cards on the MAIN bot only (other channel pollers carry other tokens). The ticker
+  // itself sends only while this bot polls, so a send-only nexus bot never duplicates the standalone poller's cards.
+  if (opts.userConfig.raw?.decisions === undefined || (opts.userConfig.raw.decisions as { cards?: unknown }).cards !== false) {
+    const mainToken = resolveChannelBotToken('telegram', opts.userConfig)?.token;
+    if (mainToken && botToken === mainToken) {
+      const bot = botRef;
+      void import('./decisions/telegram-decision-cards.js')
+        .then(({ attachTelegramDecisionCards }) => { attachTelegramDecisionCards(bot, opts.userConfig); })
+        .catch((err: unknown) => log(`[telegram] decision cards not attached: ${err instanceof Error ? err.message : String(err)}`));
+    }
+  }
   return botRef;
 }
 

package/src/thinking-line.ts

@@ -156,6 +156,14 @@ function renderLine(
   return `${applyColor(glyph, 'claude')} ${C.muted(message + '…')}${tail}`;
 }
 
+function stoppedMessage(message: string, status: ThinkingStatus): string {
+  const taskName = message.replace(/^(?:Streaming|Thinking)(?=\b|…)(?:\s*…)?\s*/, '').trim();
+  const task = taskName ? `${taskName} ` : '';
+  if (status === 'completed') return `${task}완료`;
+  if (status === 'interrupted') return `${task}중단됨`;
+  return `${task}실패`;
+}
+
 export function startThinking(opts: StartThinkingOpts): ThinkingHandle {
   let message = opts.message ?? 'Thinking';
   let messageFactory: ((frame: number) => string) | null = null;
@@ -222,20 +230,19 @@ export function startThinking(opts: StartThinkingOpts): ThinkingHandle {
       if (metrics.engine) detail.push(metrics.engine);
       const tail = detail.length ? '  ' + C.muted('(' + detail.join(' · ') + ')') : '';
       let finalText: string;
-      if (stopOpts?.finalText) {
+      if (stopOpts?.finalText !== undefined) {
         finalText = stopOpts.finalText;
-      } else if (status === 'completed') {
-        // Green tick + verb kept visible (not muted) so it stands out.
-        const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.TICK, 'success')} ${C.success(currentMessage)}${tail}`;
-      } else if (status === 'interrupted') {
-        const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.warning(currentMessage + ' · interrupted')}${tail}`;
       } else {
-        // failed
-        const err = stopOpts?.errorText ? ` — ${stopOpts.errorText}` : '';
         const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.error(currentMessage + ' · failed' + err)}${tail}`;
+        const label = stoppedMessage(currentMessage, status);
+        if (status === 'completed') {
+          finalText = `${applyColor(FIGURES.TICK, 'success')} ${C.success(label)}${tail}`;
+        } else if (status === 'interrupted') {
+          finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.warning(label)}${tail}`;
+        } else {
+          const err = stopOpts?.errorText ? ` — ${stopOpts.errorText}` : '';
+          finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.error(label + err)}${tail}`;
+        }
       }
 
       // Freeze at tail if sticky='tail' — the indicator was tracking
@@ -310,18 +317,19 @@ export function startPinnedThinking(opts: StartPinnedThinkingOpts): ThinkingHand
       if (metrics.engine) detail.push(metrics.engine);
       const tail = detail.length ? '  ' + C.muted('(' + detail.join(' · ') + ')') : '';
       let finalText: string;
-      if (stopOpts?.finalText) {
+      if (stopOpts?.finalText !== undefined) {
         finalText = stopOpts.finalText;
-      } else if (status === 'completed') {
-        const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.TICK, 'success')} ${C.success(currentMessage)}${tail}`;
-      } else if (status === 'interrupted') {
-        const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.warning(currentMessage + ' · interrupted')}${tail}`;
       } else {
-        const err = stopOpts?.errorText ? ` — ${stopOpts.errorText}` : '';
         const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.error(currentMessage + ' · failed' + err)}${tail}`;
+        const label = stoppedMessage(currentMessage, status);
+        if (status === 'completed') {
+          finalText = `${applyColor(FIGURES.TICK, 'success')} ${C.success(label)}${tail}`;
+        } else if (status === 'interrupted') {
+          finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.warning(label)}${tail}`;
+        } else {
+          const err = stopOpts?.errorText ? ` — ${stopOpts.errorText}` : '';
+          finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.error(label + err)}${tail}`;
+        }
       }
       opts.target.current = finalText;
       opts.onFrame();

package/src/tui/chat/execution-badge.ts

@@ -1,7 +1,7 @@
 // ── TUI TRUE-execution badge (self-cognition §1) ──────────────────────
 //
 // Resolves the compact engine/model badge for the dashboard chat
-// completion line — `✔ Streaming (19s · ↓ 200 tokens · 🧠 terra(high))`.
+// completion line — `✔ 완료 (19s · ↓ 200 tokens · 🧠 terra(high))`.
 // The value is the model that ACTUALLY ran this turn (from the route
 // decision recorded in the ACP bridge's getActiveModel), not the config
 // original — so the "config=opus but codex/terra ran" illusion is

package/src/user-config.ts

@@ -437,11 +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
@@ -517,34 +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 dir of shared) {
-      if (!base.includes(dir)) base.push(dir);
+    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);
 }
 
@@ -1384,6 +1451,28 @@ 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;
@@ -3373,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;
@@ -4419,6 +4510,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       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),
@@ -4546,6 +4638,7 @@ 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: {
@@ -5590,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,
@@ -5683,6 +5780,7 @@ 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({

package/src/ux-sim/turn-states.ts

@@ -69,7 +69,7 @@ export function simLines(spec: TurnSimSpec): string[] {
     case 'idle': return [];
     case 'interrupted':
       return [...head, '  일부 답변이 여기까지 나왔습니다.', '',
-        '  ✘ Streaming · interrupted  (24s · ↓ 34 tokens)'];
+        '  ✘ 중단됨  (24s · ↓ 34 tokens)'];
     case 'streaming-with-subagents': {
       const n = Math.max(1, spec.children ?? 2);
       return [...head, ...Array.from({ length: n }, (_, i) =>

package/src/version/packed-revision.json

@@ -1 +1 @@
-{"commit":"eadd7c31e07d4414ce452d943984a2e58a01ede4"}
+{"commit":"8f3512a904cff53bb1595fffc091f7443a29c2c2"}