elanous 0.2.7 → 0.2.8

package/src/intake-plane/seat-doc-route.ts

@@ -10,6 +10,7 @@ import { getElanousConfigDir } from '../elanous-config-dir.js';
 import type { ExecRequest } from '../exec-requests/store.js';
 import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
 import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
+import { answerAsSeat, isNoGraphFailure } from './seat-answer.js';
 
 const POLL_MS = 5_000;
 const TIMEOUT_MS = 30 * 60_000;
@@ -34,7 +35,9 @@ export interface SeatDocDeps {
   sleep?: (ms: number) => Promise<void>;
   now?: () => number;
   pwaUrl?: () => string | undefined;
-  log?: (event: 'submitted' | 'research' | 'settled' | 'delivered' | 'delivery-failed', data: Record<string, unknown>) => void;
+  log?: (event: 'submitted' | 'research' | 'settled' | 'delivered' | 'delivery-failed' | 'seat-answer', data: Record<string, unknown>) => void;
+  /** EV12d — the seat's own answer when no installed graph fits (default = role file ⊕ owned checklist ⊕ recent, one LLM call). */
+  seatAnswer?: (seatAddress: string, question: string) => Promise<{ title: string; text: string } | null>;
 }
 
 export function isSeatDocRequest(text: string): boolean {
@@ -194,9 +197,20 @@ export async function submitSeatDocRequest({ text, reportTo, deps = {} }: {
     }
     log('settled', { id, status: result?.status ?? (lookupAvailable ? 'timeout' : 'lookup-unavailable'), lastConfirmedStatus });
     const links = result?.status === 'done' ? await fileLinks(id, result, deps) : new Map<string, string>();
+    let reply = message(id, result, withoutResearch, lookupAvailable, accessiblePwaUrl((deps.pwaUrl ?? chatPwaUrl)()), links);
+    if (isNoGraphFailure(result)) {
+      // EV12d — a question with no fitting graph gets the seat's own answer, not «문서 요청 실패».
+      const seat = result!.seats![0]!.seat;
+      try {
+        const answer = await (deps.seatAnswer ?? answerAsSeat)(seat, body);
+        if (answer) reply = `${answer.title} 답 (접수번호 ${id})\n${answer.text}`;
+        log('seat-answer', { id, seat, answered: !!answer });
+      } catch (error) {
+        log('seat-answer', { id, seat, answered: false, reason: String(error).slice(0, 200) });
+      }
+    }
     try {
-      const sent = await (deps.sendOutbound ?? sendOutbound)(message(id, result, withoutResearch, lookupAvailable,
-        accessiblePwaUrl((deps.pwaUrl ?? chatPwaUrl)()), links), 'report', reportTo);
+      const sent = await (deps.sendOutbound ?? sendOutbound)(reply, 'report', reportTo);
       log(sent ? 'delivered' : 'delivery-failed', { id });
     } catch (error) {
       log('delivery-failed', { id, reason: String(error).slice(0, 200) });

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

@@ -2,7 +2,8 @@ import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, re
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { debug } from '../../debug/log.js';
-import { sendOutbound } from '../../domains/outbound-alert.js';
+import { routeOutbound } from '../outbound/router.js';
+import { getUserConfig } from '../../user-config.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { jsonResponse } from './json-response.js';
 
@@ -22,7 +23,10 @@ interface ConsultRequest {
 export interface ConsultRequestsDeps {
   root?: () => string;
   now?: () => string;
-  send?: typeof sendOutbound;
+  /** Owner alert. Default = the daemon's own in-process router (the same one `/v1/outbound` uses).
+   *  ⛔ Never `sendOutbound` here: it is a synchronous curl to this very daemon's `/v1/outbound`, so inside the
+   *  daemon it blocks the event loop until it times out (~25 s · `unreachable`) and the alert is lost (CS1 · 10-01). */
+  send?: (text: string, kind: string) => unknown;
 }
 
 function file(root: string): string {
@@ -107,11 +111,18 @@ export async function handleConsultRequests(req: Request, deps: ConsultRequestsD
     return jsonResponse({ error: 'journal-unavailable' }, 503);
   }
   debug.log('consult.request', 'accepted', { receiptId: entry.receiptId });
-  try {
-    (deps.send ?? sendOutbound)(
-      `📮 상담 문의 ${entry.receiptId} · ${entry.name}(${entry.kind === 'personal' ? '개인' : (entry.org ?? '회사')}) · 관심 ${entry.interest}\n앱에서 보기`,
-      'alert',
-    );
-  } catch { /* the local receipt remains accepted if delivery is unavailable */ }
+  const alert = `📮 상담 문의 ${entry.receiptId} · ${entry.name}(${entry.kind === 'personal' ? '개인' : (entry.org ?? '회사')}) · 관심 ${entry.interest}\n앱에서 보기`;
+  // Fire and forget — the receipt is already on disk; the answer must not wait for the channel.
+  void Promise.resolve()
+    .then(() => (deps.send ?? notifyInProcess)(alert, 'alert'))
+    .catch((error: unknown) => { debug.log('consult.request', 'notify-failed', { receiptId: entry.receiptId, reason: error instanceof Error ? error.message : String(error) }); });
   return jsonResponse({ receiptId: entry.receiptId, receivedAt: entry.receivedAt }, 202);
 }
+
+async function notifyInProcess(text: string, kind: string): Promise<void> {
+  const result = await routeOutbound(getUserConfig(), { text, markdown: false, kind });
+  debug.log('consult.request', result.delivered ? 'notified' : 'notify-failed', {
+    delivered: result.delivered,
+    channels: result.channels.map((channel) => `${channel.type}:${channel.ok ? 'ok' : 'fail'}`),
+  });
+}

package/src/nexus/api/error-reports.ts

@@ -0,0 +1,108 @@
+// ER2 — the Primary side of error reports. The bot VM forwards each accepted report here over the tailnet
+// (ingest token). It is stored under <instance>/error-reports/YYYY/MM/DD/<reportId>.json for 30 days, and the
+// operator gets one Telegram line per distinct error per hour — never the message, stack or identity.
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../../debug/log.js';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import type { ReceivedReport } from '../../hooks/error-report.js';
+import { validateErrorReport } from '../../hooks/error-report.js';
+import { jsonResponse } from './json-response.js';
+import { routeOutboundInProcess } from './outbound-report.js';
+
+export const ERROR_REPORT_KEEP_DAYS = 30;
+const DAY_MS = 86_400_000;
+
+export interface ErrorReportIngestDeps {
+  root?: () => string;
+  now?: () => number;
+  /** Operator alert. Default = the daemon's in-process router (never a self-call · OB8). */
+  alert?: (text: string, kind: string) => Promise<boolean>;
+}
+
+function storeDir(root: string): string { return join(root, 'error-reports'); }
+
+/** Removes day folders older than the keep window. Returns how many days were removed. */
+export function pruneErrorReports(root: string, now: number): number {
+  const base = storeDir(root);
+  if (!existsSync(base)) return 0;
+  let removed = 0;
+  for (const year of readdirSync(base).filter((n) => /^\d{4}$/.test(n))) {
+    for (const month of readdirSync(join(base, year)).filter((n) => /^\d{2}$/.test(n))) {
+      for (const day of readdirSync(join(base, year, month)).filter((n) => /^\d{2}$/.test(n))) {
+        const at = Date.parse(`${year}-${month}-${day}T00:00:00Z`);
+        if (Number.isFinite(at) && now - at > ERROR_REPORT_KEEP_DAYS * DAY_MS + DAY_MS) {
+          rmSync(join(base, year, month, day), { recursive: true, force: true });
+          removed++;
+        }
+      }
+    }
+  }
+  return removed;
+}
+
+/** One alert per dedupe per hour, remembered on disk so a restart does not repeat it. */
+function shouldAlert(root: string, dedupe: string, now: number): boolean {
+  const path = join(storeDir(root), 'alerts.json');
+  let seen: Record<string, number> = {};
+  try { seen = JSON.parse(readFileSync(path, 'utf8')) as Record<string, number>; } catch { /* first alert */ }
+  for (const [k, t] of Object.entries(seen)) if (now - t > DAY_MS) delete seen[k];
+  const last = seen[dedupe];
+  if (last !== undefined && now - last < 3600_000) return false;
+  seen[dedupe] = now;
+  mkdirSync(storeDir(root), { recursive: true, mode: 0o700 });
+  writeFileSync(path, JSON.stringify(seen), { mode: 0o600 });
+  return true;
+}
+
+export function errorReportAlertText(item: ReceivedReport, count24h: number): string {
+  const r = item.report;
+  return `🧯 오류 보고 ${r.code} · v${r.app.version} · ${r.app.surface} · 같은 오류 24h ${count24h}회 · ${item.reportId}`;
+}
+
+/** Same dedupe stored in the last 24 h, counted from the store itself. */
+function count24h(root: string, dedupe: string, now: number): number {
+  let n = 0;
+  for (const offset of [0, 1]) {
+    const d = new Date(now - offset * DAY_MS);
+    const dir = join(storeDir(root), String(d.getUTCFullYear()), String(d.getUTCMonth() + 1).padStart(2, '0'), String(d.getUTCDate()).padStart(2, '0'));
+    if (!existsSync(dir)) continue;
+    for (const name of readdirSync(dir).filter((f) => f.endsWith('.json'))) {
+      try {
+        const item = JSON.parse(readFileSync(join(dir, name), 'utf8')) as ReceivedReport;
+        if (item.dedupe === dedupe && now - Date.parse(item.receivedAt) < DAY_MS) n++;
+      } catch { /* a broken file is not counted */ }
+    }
+  }
+  return n;
+}
+
+/** POST /v1/reports/ingest — the caller (router) has already checked the ingest token. */
+export async function handleErrorReportIngest(req: Request, deps: ErrorReportIngestDeps = {}): Promise<Response> {
+  const root = (deps.root ?? effectiveInstanceRoot)();
+  const now = (deps.now ?? Date.now)();
+  let body: unknown;
+  try { body = await req.json(); } catch { return jsonResponse({ error: 'invalid', field: 'body' }, 400); }
+  const item = body as Partial<ReceivedReport>;
+  if (typeof item.reportId !== 'string' || !/^er_[0-9a-z]{26}$/.test(item.reportId)) return jsonResponse({ error: 'invalid', field: 'reportId' }, 400);
+  if (typeof item.dedupe !== 'string' || !/^[0-9a-f]{12}$/.test(item.dedupe)) return jsonResponse({ error: 'invalid', field: 'dedupe' }, 400);
+  if (typeof item.receivedAt !== 'string' || !Number.isFinite(Date.parse(item.receivedAt))) return jsonResponse({ error: 'invalid', field: 'receivedAt' }, 400);
+  const checked = validateErrorReport(item.report);
+  if (!checked.ok) return jsonResponse({ error: 'invalid', field: `report.${checked.field}` }, 400);
+  const stored: ReceivedReport = { reportId: item.reportId, dedupe: item.dedupe, receivedAt: item.receivedAt, report: checked.report };
+  const at = new Date(Date.parse(stored.receivedAt));
+  const dir = join(storeDir(root), String(at.getUTCFullYear()), String(at.getUTCMonth() + 1).padStart(2, '0'), String(at.getUTCDate()).padStart(2, '0'));
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  writeFileSync(join(dir, `${stored.reportId}.json`), JSON.stringify(stored), { mode: 0o600 });
+  let pruned = 0;
+  try { pruned = pruneErrorReports(root, now); } catch { /* pruning never blocks a receipt */ }
+  const count = count24h(root, stored.dedupe, now);
+  const alerted = shouldAlert(root, stored.dedupe, now);
+  debug.log('error-report.ingest', 'stored', { code: stored.report.code, surface: stored.report.app.surface, count24h: count, alerted, pruned });
+  if (alerted) {
+    const alert = deps.alert ?? routeOutboundInProcess;
+    void Promise.resolve().then(() => alert(errorReportAlertText(stored, count), 'alert'))
+      .catch((error: unknown) => debug.log('error-report.ingest', 'alert-failed', { reason: error instanceof Error ? error.message : String(error) }));
+  }
+  return jsonResponse({ stored: true, reportId: stored.reportId, count }, 202);
+}

package/src/nexus/api/http-server.ts

@@ -15,6 +15,7 @@
 // Port policy (N1-2 decision): auto-pick from 31415 upward. Actual port
 // is recorded in runtime.json + printed in boot banner.
 
+import { setInProcessOutbound } from '../../domains/outbound-alert.js';
 import { getUserConfig } from '../../user-config.js';
 import type { TelegramEvent } from '../../workflow-runtime/triggers/telegram-source.js';
 import { spawnSync } from 'node:child_process';
@@ -385,6 +386,8 @@ import {
 import { handleSessionTurnControl, SESSION_TURN_CONTROL_PATH } from '../../session/session-turn-control.js';
 import { authenticatePodCredential, handlePodGrokCredential, handlePodGithubCredential, POD_CREDENTIAL_GROK_PATH, POD_CREDENTIAL_GITHUB_PATH } from './pod-credential-api.js';
 import { handleOutboundReport } from './outbound-report.js';
+import { handleErrorReportIngest } from './error-reports.js';
+import { routeOutboundInProcess } from './outbound-report.js';
 import { handleSelfEvent } from './self-event.js';
 /** 매매 «실행»은 애드온이다(대표 09-20 결정 ③ · 별도 상용 저장소 · release/trading-export.yaml) — 공개 코어엔 없다.
  *  있으면 그 경로를 켜고, 없으면 501. 경로를 변수로 둬 공개본 타입 검사가 «모듈 없음»으로 막히지 않게 한다. */
@@ -757,6 +760,8 @@ export function startNexusHttpServer(opts: NexusHttpServerOpts): NexusHttpServer
         ...(websocketHandler ? { websocket: websocketHandler } : {}),
       } as unknown as Parameters<typeof Bun.serve>[0];
       server = Bun.serve(fetchOpts);
+      // OB8 — this process now answers /v1/outbound itself; its own sendOutbound calls must not curl it.
+      setInProcessOutbound(routeOutboundInProcess);
       // 데몬이 «실제로» 떴을 때만 재시작 복구(맡긴 일) — 주입된 러너(시험)는 건드리지 않는다.
       if (!opts.execRequests) { try { execRequestRunner().reconcileInterrupted(); } catch { /* 복구 실패가 서버 기동을 막지 않는다 */ } }
       resolvedPort = port;
@@ -781,6 +786,7 @@ export function startNexusHttpServer(opts: NexusHttpServerOpts): NexusHttpServer
     url,
     stop() {
       try { server!.stop(true); } catch { /* idempotent */ }
+      setInProcessOutbound(null);
     },
   };
 }
@@ -876,7 +882,7 @@ export async function routeRequest(
     const fallbackAuthorized = fallbackToken !== undefined && offered?.startsWith('Bearer ') === true
       && compareTokenConstTime(offered.slice('Bearer '.length).trim(), fallbackToken);
     if (!(opts.metaApi ? checkAuth(req, opts.metaApi) : fallbackAuthorized)) {
-      const name = method === 'POST' && pathname === '/v1/tasks' && opts.metaApi
+      const name = method === 'POST' && (pathname === '/v1/tasks' || pathname === '/v1/reports/ingest') && opts.metaApi
         ? matchIngestAuthorization(req)?.name
         : undefined;
       if (name === undefined) {
@@ -1304,6 +1310,8 @@ export async function routeRequest(
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
       return handleTaskCreatePost(req, opts.metaApi);
     }
+    // ER2 — error reports forwarded by the bot VM (ingest token · same as /v1/tasks).
+    if (method === 'POST' && pathname === '/v1/reports/ingest') return handleErrorReportIngest(req);
     if (method === 'POST' && pathname.startsWith('/v1/tasks/') && pathname.endsWith('/approve')) {
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
       let taskId: string;
@@ -1969,6 +1977,18 @@ export async function routeRequest(
     }
     // HANDOFF §4.2 follow-up — skill-side mirror of the workflow
     // router. Same regex → LLM cascade, applied to the skill index.
+    // SK2 (PWA) — skills the index could not read: list ⊕ confirmed repair.
+    if (pathname === '/v1/skills/problems' || pathname === '/v1/skills/problems/repair') {
+      if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
+      const { handleSkillProblems } = await import('./skill-problems.js');
+      return handleSkillProblems(req, opts.metaApi);
+    }
+    // SC1 (PWA · beta) — «공유용 캡처»: masked screen PNG in, metadata chunks stripped, stored under <configDir>/captures.
+    if (pathname === '/v1/captures' || pathname.startsWith('/v1/captures/')) {
+      if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
+      const { handleShareCaptures } = await import('./share-captures.js');
+      return handleShareCaptures(req, opts.metaApi);
+    }
     if (pathname === '/v1/skills/route' && method === 'POST') {
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
       return handleSkillRoute(req, opts.metaApi);

package/src/nexus/api/outbound-report.ts

@@ -44,6 +44,13 @@ function json(body: unknown, status: number): Response {
   });
 }
 
+/** The daemon's own sendOutbound path (OB8) — what POST /v1/outbound does, without the HTTP self-call. */
+export async function routeOutboundInProcess(text: string, kind: string): Promise<boolean> {
+  const result = await routeOutbound(getUserConfig(), { text, markdown: false, kind });
+  if (result.delivered) recordOutboundEvent(text, kind);
+  return result.delivered;
+}
+
 /** POST /v1/outbound — fan one message out to the routed channels. */
 export async function handleOutboundReport(req: Request, metaApi: MetaApiOpts): Promise<Response> {
   if (!checkAuth(req, metaApi)) return json({ error: 'unauthorized' }, 401);

package/src/nexus/api/running-runs-background.ts

@@ -0,0 +1,68 @@
+// The terminals list must answer at once and must never share the event loop with a ledger scan: the running-runs query
+// reads every run ledger synchronously (~5k files · 0.9–1.8 s on 10-02), which froze typing in the web terminal while the
+// PWA polled the list. This keeps the last result as a snapshot and refreshes it in a separate bun process, on demand.
+import { join } from 'node:path';
+import { debug } from '../../debug/log.js';
+import type { RunningRunsResult } from '../../self-implement/running-runs.js';
+
+export const RUNNING_RUNS_REFRESH_MS = 15_000;
+/** A refresh that has not answered by then is abandoned; the next request starts another. */
+export const RUNNING_RUNS_REFRESH_TIMEOUT_MS = 60_000;
+
+export interface RunningRunsSnapshot {
+  /** Last result, or null before the first refresh finished (subjects then keep unknown assessments). */
+  readonly result: RunningRunsResult | null;
+  /** Milliseconds since `result` was computed; null when there is none. */
+  readonly ageMs: number | null;
+}
+
+/** Runs the query somewhere other than this event loop and resolves with its JSON output. */
+export type RunningRunsRunner = (includeTest: boolean) => Promise<RunningRunsResult>;
+
+export const RUNNING_RUNS_CHILD_SCRIPT = join(import.meta.dir, 'running-runs-child.ts');
+
+/** Default runner: `bun running-runs-child.ts [--include-test]` — the child does the ledger I/O, we only parse its stdout. */
+export const childProcessRunner: RunningRunsRunner = async (includeTest) => {
+  const proc = Bun.spawn([process.execPath, RUNNING_RUNS_CHILD_SCRIPT, ...(includeTest ? ['--include-test'] : [])], {
+    stdout: 'pipe', stderr: 'ignore', stdin: 'ignore', env: process.env,
+  });
+  const timer = setTimeout(() => proc.kill(), RUNNING_RUNS_REFRESH_TIMEOUT_MS);
+  try {
+    const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+    if (code !== 0) throw new Error(`running-runs child exit ${code}`);
+    return JSON.parse(out) as RunningRunsResult;
+  } finally { clearTimeout(timer); }
+};
+
+export interface RunningRunsBackground {
+  /** Never blocks: returns the last snapshot and starts a refresh when it is stale and none is in flight. */
+  snapshot(options: { includeTest?: boolean }): RunningRunsSnapshot;
+}
+
+export function createRunningRunsBackground(runner: RunningRunsRunner = childProcessRunner, now: () => number = Date.now, refreshMs = RUNNING_RUNS_REFRESH_MS): RunningRunsBackground {
+  const slots = new Map<boolean, { at: number; result: RunningRunsResult }>();
+  const flights = new Set<boolean>();
+  const refresh = (includeTest: boolean): void => {
+    if (flights.has(includeTest)) return;
+    flights.add(includeTest);
+    const started = now();
+    void runner(includeTest)
+      .then((result) => {
+        slots.set(includeTest, { at: now(), result });
+        debug.log('nexus.terminals', 'running-runs-refreshed', { includeTest, ms: now() - started });
+      })
+      .catch((error: unknown) => {
+        debug.log('nexus.terminals', 'running-runs-refresh-failed', { includeTest, reason: error instanceof Error ? error.message.slice(0, 80) : 'unknown' }, { level: 'warn' });
+      })
+      .finally(() => { flights.delete(includeTest); });
+  };
+  return {
+    snapshot(options) {
+      const includeTest = options.includeTest === true;
+      const slot = slots.get(includeTest);
+      const t = now();
+      if (!slot || t - slot.at >= refreshMs) refresh(includeTest);
+      return slot ? { result: slot.result, ageMs: t - slot.at } : { result: null, ageMs: null };
+    },
+  };
+}

package/src/nexus/api/running-runs-child.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+// Child of running-runs-background.ts: runs the running-runs query (all the ledger I/O) and prints the result as JSON.
+import { queryRunningRuns } from '../../self-implement/running-runs.js';
+
+const result = queryRunningRuns({ includeTest: process.argv.includes('--include-test'), caller: 'nexus.terminals' });
+process.stdout.write(JSON.stringify(result));

package/src/nexus/api/share-captures.ts

@@ -0,0 +1,91 @@
+// SC1 — 앱 안 «공유용 캡처»(beta) 받는 쪽. PWA 가 화면을 가린 뒤 PNG 로 올린다(티저·현장·보고용).
+// POST /v1/captures          body = image/png(≤ 8 MiB) → { id, bytes, droppedChunks }
+// GET  /v1/captures          → { items: [{ id, bytes, at }] } (최신 먼저 · 50개)
+// GET  /v1/captures/<id>     → image/png
+// ⛔ 두 번째 방어: 받은 PNG 에서 «그림 아닌» 덩어리(tEXt·iTXt·zTXt·eXIf·iCCP·tIME 등 메타)를 전부 걷고 저장한다 —
+//    화면 쪽 가림이 놓친 것이 파일 메타로 새지 않게. 남기는 것은 그림을 그리는 데 필요한 덩어리뿐이다.
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../../debug/log.js';
+import { getElanousConfigDir } from '../../elanous-config-dir.js';
+import { jsonResponse } from './json-response.js';
+import { checkAuth, type MetaApiOpts } from './meta-api.js';
+
+export const SHARE_CAPTURES_PATH = '/v1/captures';
+const MAX_BYTES = 8 * 1024 * 1024;
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+/** Chunks needed to draw the picture. Everything else (text, EXIF, ICC profile, time…) is dropped. */
+const KEEP = new Set(['IHDR', 'PLTE', 'IDAT', 'IEND', 'tRNS', 'gAMA', 'cHRM', 'sRGB', 'pHYs']);
+const ID = /^share-\d{8}-\d{6}-[0-9a-f]{6}$/;
+
+export interface ShareCapturesDeps { configDir?: string; now?: () => Date }
+
+/** Rebuild a PNG with only drawing chunks. Returns null when it is not a well-formed PNG. */
+export function stripPngMetadata(input: Uint8Array): { png: Buffer; dropped: string[] } | null {
+  const buf = Buffer.from(input);
+  if (buf.length < 8 + 12 || !buf.subarray(0, 8).equals(PNG_SIGNATURE)) return null;
+  const parts: Buffer[] = [PNG_SIGNATURE];
+  const dropped: string[] = [];
+  let offset = 8;
+  let sawHeader = false;
+  let sawEnd = false;
+  while (offset + 12 <= buf.length) {
+    const length = buf.readUInt32BE(offset);
+    const type = buf.subarray(offset + 4, offset + 8).toString('latin1');
+    const end = offset + 12 + length;
+    if (end > buf.length || !/^[A-Za-z]{4}$/.test(type)) return null;
+    if (!sawHeader && type !== 'IHDR') return null;
+    sawHeader = true;
+    if (KEEP.has(type)) parts.push(buf.subarray(offset, end)); else dropped.push(type);
+    offset = end;
+    if (type === 'IEND') { sawEnd = true; break; }
+  }
+  if (!sawEnd) return null;
+  return { png: Buffer.concat(parts), dropped };
+}
+
+function capturesDir(deps: ShareCapturesDeps): string {
+  return join(deps.configDir ?? getElanousConfigDir(), 'captures');
+}
+
+function newId(now: Date): string {
+  const p = (n: number) => String(n).padStart(2, '0');
+  return `share-${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}-${randomBytes(3).toString('hex')}`;
+}
+
+export async function handleShareCaptures(req: Request, metaApi: MetaApiOpts, deps: ShareCapturesDeps = {}): Promise<Response> {
+  if (!checkAuth(req, metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+  const pathname = new URL(req.url).pathname;
+  const dir = capturesDir(deps);
+
+  if (pathname === SHARE_CAPTURES_PATH && req.method === 'POST') {
+    const declared = Number(req.headers.get('content-length') ?? 0);
+    if (declared > MAX_BYTES) return jsonResponse({ error: 'too-large', maxBytes: MAX_BYTES }, 413);
+    const body = new Uint8Array(await req.arrayBuffer());
+    if (body.byteLength > MAX_BYTES) return jsonResponse({ error: 'too-large', maxBytes: MAX_BYTES }, 413);
+    const cleaned = stripPngMetadata(body);
+    if (!cleaned) return jsonResponse({ error: 'not-png' }, 400);
+    const id = newId((deps.now ?? (() => new Date()))());
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(join(dir, `${id}.png`), cleaned.png, { mode: 0o600, flag: 'wx' });
+    debug.log('share-capture', 'stored', { id, bytes: cleaned.png.length, dropped: cleaned.dropped });
+    return jsonResponse({ id, bytes: cleaned.png.length, droppedChunks: cleaned.dropped }, 201);
+  }
+
+  if (pathname === SHARE_CAPTURES_PATH && req.method === 'GET') {
+    const items = existsSync(dir)
+      ? readdirSync(dir).filter((f) => f.endsWith('.png') && ID.test(f.slice(0, -4))).sort().reverse().slice(0, 50)
+        .map((f) => { const s = statSync(join(dir, f)); return { id: f.slice(0, -4), bytes: s.size, at: s.mtime.toISOString() }; })
+      : [];
+    return jsonResponse({ items });
+  }
+
+  const id = pathname.slice(SHARE_CAPTURES_PATH.length + 1);
+  if (req.method === 'GET' && ID.test(id)) {
+    const file = join(dir, `${id}.png`);
+    if (!existsSync(file)) return jsonResponse({ error: 'not-found' }, 404);
+    return new Response(readFileSync(file), { headers: { 'content-type': 'image/png', 'cache-control': 'no-store' } });
+  }
+  return jsonResponse({ error: 'not-found' }, 404);
+}

package/src/nexus/api/skill-problems.ts

@@ -0,0 +1,56 @@
+// SK2 (PWA) — 색인이 못 읽은 스킬을 PWA 에도 «안내 ⊕ 확인 뒤 수리»로.
+// GET  /v1/skills/problems           → { items: [{ id, name, code, fixable, hint? }] } — 경로 대신 해시 id 만 내보낸다
+// POST /v1/skills/problems/repair    → body { id } · 고칠 수 있는 것만 고친다(남의 도구 파일 — PWA 가 먼저 확인을 받는다)
+import { createHash } from 'node:crypto';
+import { debug } from '../../debug/log.js';
+import { getSkillIndex, skillIndexProblems, type SkillIndexProblem } from '../../skills/index.js';
+import { applySkillRepair, planSkillRepair } from '../../skills/repair.js';
+import { jsonResponse } from './json-response.js';
+import { checkAuth, type MetaApiOpts } from './meta-api.js';
+
+export const SKILL_PROBLEMS_PATH = '/v1/skills/problems';
+
+export interface SkillProblemsDeps {
+  problems?: () => SkillIndexProblem[];
+}
+
+function problemId(p: SkillIndexProblem): string {
+  return createHash('sha256').update(`${p.dir}\u0000${p.name}`).digest('hex').slice(0, 16);
+}
+
+function current(deps: SkillProblemsDeps): SkillIndexProblem[] {
+  if (deps.problems) return deps.problems();
+  getSkillIndex();
+  return skillIndexProblems();
+}
+
+export async function handleSkillProblems(req: Request, metaApi: MetaApiOpts, deps: SkillProblemsDeps = {}): Promise<Response> {
+  if (!checkAuth(req, metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+  const pathname = new URL(req.url).pathname;
+  if (pathname === SKILL_PROBLEMS_PATH) {
+    if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    const items = current(deps).map((p) => {
+      const plan = planSkillRepair(p);
+      return {
+        id: problemId(p), name: p.name, code: p.code,
+        fixable: plan.kind === 'fixable' || plan.kind === 'fixable-permission',
+        ...(plan.kind === 'permission' || plan.kind === 'manual' ? { hint: plan.hint.replace(p.dir, '…') } : {}),
+      };
+    });
+    return jsonResponse({ items });
+  }
+  if (pathname === `${SKILL_PROBLEMS_PATH}/repair`) {
+    if (req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    let body: unknown;
+    try { body = await req.json(); } catch { return jsonResponse({ error: 'bad_request' }, 400); }
+    const id = body && typeof body === 'object' && typeof (body as { id?: unknown }).id === 'string' ? (body as { id: string }).id : '';
+    const problem = current(deps).find((p) => problemId(p) === id);
+    if (!problem) return jsonResponse({ error: 'not-found' }, 404);
+    const plan = planSkillRepair(problem);
+    if (plan.kind !== 'fixable' && plan.kind !== 'fixable-permission') return jsonResponse({ error: 'not-fixable', hint: plan.hint.replace(problem.dir, '…') }, 409);
+    const result = applySkillRepair(plan);
+    debug.log('skills.repair', 'pwa-request', { name: problem.name, ok: result.ok });
+    return result.ok ? jsonResponse({ ok: true, name: problem.name }) : jsonResponse({ ok: false, reason: result.reason }, 409);
+  }
+  return jsonResponse({ error: 'not-found' }, 404);
+}

package/src/nexus/api/terminals.ts

@@ -34,6 +34,7 @@ import { classifyPtyOwnerRunUsage, joinPtyLineage, resolveRunTermination, type P
 import { loadRunLedger, resolveFederatedRunLedgerDirectories, runLedgerDir } from '../../self-implement/run-ledger.js';
 import { requestRemotePtyControl, type PtyControlAction, type PtyControlPayload, type PtyControlRequestOptions, type PtyControlResult } from '../../pty-shell/pty-control-ipc.js';
 import { encodeSgrMouse, type PtyMouseInput } from '../../pty-shell/pty-mouse.js';
+import { createRunningRunsBackground, type RunningRunsBackground } from './running-runs-background.js';
 import { queryRunningRuns, type RunningRunAssessment, type RunningRunPresence, type RunningRunStatus, type RunningRunsResult } from '../../self-implement/running-runs.js';
 // ⭐P4 §4-1 — 표시 폭(wide-char/CJK/emoji 인지) SSOT. PNG 캔버스 cols 파생용.
 import { cellWidth } from '../../ui/printer.js';
@@ -494,6 +495,12 @@ function runningRunsCacheFor(
   return binding.cache;
 }
 
+let liveBackground: RunningRunsBackground | null = null;
+function liveRunningRunsBackground(): RunningRunsBackground {
+  liveBackground ??= createRunningRunsBackground();
+  return liveBackground;
+}
+
 const liveTerminalsListDeps: TerminalsListDeps = {
   ptyManifestTargets,
   listPtyManifestRows,
@@ -1054,17 +1061,26 @@ export function handleTerminalsList(req: Request, opts: MetaApiOpts, deps: Termi
   const resolveRunTerminationForRow = (runId: string): RunTermination => deps.runTerminated
     ? deps.runTerminated(runId, { includeTest })
     : 'ledger-indeterminate';
-  const runningRunsCache = runningRunsCacheFor(getRunningRuns, deps.now ?? Date.now);
   let runningRuns: RunningRunsResult | null = null;
   let runningRunsAgeMs = 0;
   let runningRunsQueryFailed = false;
-  try {
-    const cached = runningRunsCache({ includeTest });
-    runningRuns = cached.result;
-    runningRunsAgeMs = cached.ageMs;
-  } catch {
-    // Fail-soft and do not cache: subjects keep unknown assessments.
-    runningRunsQueryFailed = true;
+  if (getRunningRuns === queryRunningRuns) {
+    // Live daemon: never scan ledgers on this event loop (it froze web-terminal typing) — use the last snapshot a
+    // separate process refreshed. Before the first one lands, subjects keep unknown assessments and the age is null.
+    const snap = liveRunningRunsBackground().snapshot({ includeTest });
+    runningRuns = snap.result;
+    if (snap.ageMs === null) runningRunsQueryFailed = true;
+    else runningRunsAgeMs = snap.ageMs;
+  } else {
+    const runningRunsCache = runningRunsCacheFor(getRunningRuns, deps.now ?? Date.now);
+    try {
+      const cached = runningRunsCache({ includeTest });
+      runningRuns = cached.result;
+      runningRunsAgeMs = cached.ageMs;
+    } catch {
+      // Fail-soft and do not cache: subjects keep unknown assessments.
+      runningRunsQueryFailed = true;
+    }
   }
   const ptyLessSubAgentCollection = collectPtyLessSubAgents(
     getLogStore,

package/src/nexus/index.ts

@@ -2609,10 +2609,16 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
               runTurnImpl,
               getBot: () => getBotRef.current,
             });
+            // DEC-TG(대표 10-02) — decision cards in the owner's Discord DM. Filled once the bot exists (below).
+            let decisionWire: import('../decisions/discord-decision-cards.js').DiscordDecisionWire | null = null;
             const composedOnMessage = async (
               ctx: import('../discord.js').DcIncoming,
               streamer?: import('../discord.js').DcMessageStreamer,
             ): Promise<string | void> => {
+              if (decisionWire && ctx.text.trim() === '/decisions') {
+                const { discordDecisionsCommand } = await import('../decisions/discord-decision-cards.js');
+                return discordDecisionsCommand(decisionWire.service, ctx);
+              }
               const voiceReply = await voiceWire.dispatchVoiceCommand(ctx);
               if (voiceReply !== null) return voiceReply;
               return selfOnMessage(ctx, streamer as never);
@@ -2635,7 +2641,8 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
               dispatch: (event) => workflowDaemon!.dispatchDiscord(event),
               onMessage: composedOnMessage,
               onInteraction: async (raw) => {
-                // C1 버튼 탭 우선(elanous-q: 소비) → 아니면 C3 슬래시.
+                // DEC-TG 결정 카드(dec:/decmemo:) → C1 버튼 탭(elanous-q: 소비) → 아니면 C3 슬래시.
+                if (decisionWire && await decisionWire.onInteraction(raw)) return;
                 if (await questionRuntime.handleComponentInteraction(raw)) return;
                 await slashWire.onInteraction(raw);
               },
@@ -2644,6 +2651,14 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
             if (handle) {
               getBotRef.current = handle.bot;
               workflowDiscordBot = handle;
+              if ((cfg.raw?.decisions as { cards?: unknown } | undefined)?.cards !== false) {
+                try {
+                  const { attachDiscordDecisionCards } = await import('../decisions/discord-decision-cards.js');
+                  decisionWire = attachDiscordDecisionCards(handle.bot, cfg);
+                } catch (err) {
+                  console.warn(`[nexus] decision cards (discord) not attached: ${err instanceof Error ? err.message : String(err)}`);
+                }
+              }
               void slashWire.registerCommands().catch((err: unknown) => {
                 console.warn(`[nexus] slash registration failed: ${err instanceof Error ? err.message : String(err)}`);
               });
@@ -2919,6 +2934,15 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
         : readyCount === 1 ? readyServerIds[0] : undefined,
       readyCount,
     });
+    // TERM1 ④ — the first web-terminal spawn used to pay the login-shell env capture (spawnSync · ~3 s with the
+    // daemon frozen) and the terminal module import (~0.9 s). Warm both off the event loop shortly after boot.
+    if (!opts.startNexusHttpServerFn) {
+      const warm = setTimeout(() => {
+        void import('../shell-env-bootstrap.js').then(({ warmCapturedEnv }) => warmCapturedEnv()).catch(() => undefined);
+        void import('../web-terminal/preview-tap-registry.js').then(() => import('../preview/terminal.js')).catch(() => undefined);
+      }, 1_500);
+      (warm as { unref?: () => void }).unref?.();
+    }
     httpServer = startHttpServer({
       state,
       registry,