elanous 0.2.6 → 0.2.8

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

@@ -0,0 +1,254 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { debug } from '../../debug/log.js';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { submitIntakeWork } from '../../intake-plane/submit-intake-work.js';
+import { parseSeatAddress, resolveSeat } from '../../seat-address/seat-address.js';
+import trackData from '../../../scripts/coord-tracks.json';
+import { jsonResponse } from './json-response.js';
+
+export const SEAT_REQUESTS_PATH = '/v1/seat-requests';
+
+interface SeatRequestItem {
+  receiptId: string;
+  seat: string;
+  text: string;
+  queuedAt: string;
+  status: 'queued';
+}
+
+interface PendingRequest {
+  status: 'pending';
+  key: string;
+  seat: string;
+  text: string;
+  queuedAt: string;
+  ref: string;
+}
+
+interface RejectedRequest extends Omit<PendingRequest, 'status'> {
+  status: 'rejected';
+}
+
+type RecordEntry = (SeatRequestItem & { key: string }) | PendingRequest | RejectedRequest;
+
+export interface SeatRequestsDeps {
+  root?: () => string;
+  submit?: typeof submitIntakeWork;
+  now?: () => string;
+  append?: (path: string, entry: RecordEntry) => void;
+}
+
+const seats = trackData.tracks.filter((entry): entry is typeof entry & { title: string } => 'title' in entry)
+  .map(({ id, title }) => ({ id, title }));
+const inFlight = new Map<string, { payload: string; task: Promise<Response> }>();
+
+function unknownSeat(): Response {
+  debug.log('seat-address.pwa', 'rejected', { reason: 'unknown-seat' });
+  return jsonResponse({ error: 'unknown-seat', seats }, 400);
+}
+
+function file(root: string): string {
+  return join(root, 'seat-requests', 'requests.jsonl');
+}
+
+function append(path: string, entry: RecordEntry): void {
+  mkdirSync(dirname(path), { recursive: true });
+  // Atomically replace the journal so a failed write cannot leave a truncated JSON line.
+  const previous = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  const temp = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temp, `${previous}${JSON.stringify(entry)}\n`);
+    const fd = openSync(temp, 'r');
+    try { fsyncSync(fd); } finally { closeSync(fd); }
+    renameSync(temp, path);
+  } catch (error) {
+    try { unlinkSync(temp); } catch { /* no temp file to remove */ }
+    throw error;
+  }
+}
+
+function records(path: string): Map<string, RecordEntry> {
+  let data: string;
+  try { data = readFileSync(path, 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT' && !existsSync(path)) data = '';
+    else throw error;
+  }
+  const entries = new Map<string, RecordEntry>();
+  for (const line of data.split('\n')) {
+    if (!line) continue;
+    const entry = JSON.parse(line) as RecordEntry;
+    if (typeof entry.key !== 'string' || typeof entry.seat !== 'string' || typeof entry.text !== 'string'
+      || typeof entry.queuedAt !== 'string' || !['pending', 'queued', 'rejected'].includes(entry.status)
+      || (entry.status === 'queued' && typeof entry.receiptId !== 'string')
+      || (entry.status !== 'queued' && typeof entry.ref !== 'string')) {
+      throw new Error('invalid seat request journal');
+    }
+    entries.set(entry.key, entry);
+  }
+  const dir = join(dirname(path), 'outcomes');
+  let names: string[];
+  try { names = readdirSync(dir); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return entries;
+    throw error;
+  }
+  for (const name of names) {
+    if (!/^[a-f0-9]{64}\.json$/.test(name)) continue;
+    const item = JSON.parse(readFileSync(join(dir, name), 'utf8')) as RecordEntry;
+    if (item.key !== name.slice(0, -5) || (item.status !== 'queued' && item.status !== 'rejected')) {
+      throw new Error('invalid seat request outcome');
+    }
+    const current = entries.get(item.key);
+    if (current?.status === 'queued') continue;
+    if (current?.status === 'pending') {
+      if (item.status === 'rejected' && current.ref !== item.ref) continue;
+      if (item.status === 'queued' && current.queuedAt !== item.queuedAt) continue;
+    }
+    entries.set(item.key, item);
+  }
+  return entries;
+}
+
+function outcomeFile(path: string, key: string): string {
+  return join(dirname(path), 'outcomes', `${key}.json`);
+}
+
+function persistOutcome(path: string, entry: RecordEntry, write: typeof append): void {
+  try {
+    write(path, entry);
+    const sidecar = outcomeFile(path, entry.key);
+    if (existsSync(sidecar)) unlinkSync(sidecar);
+  } catch {
+    // The primary journal may be unavailable while the outcome is already committed
+    // to the intake queue. Keep a durable sidecar rather than a process-local receipt.
+    const target = outcomeFile(path, entry.key);
+    mkdirSync(dirname(target), { recursive: true });
+    const temp = `${target}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temp, JSON.stringify(entry));
+      const fd = openSync(temp, 'r');
+      try { fsyncSync(fd); } finally { closeSync(fd); }
+      renameSync(temp, target);
+    } catch (error) {
+      try { unlinkSync(temp); } catch { /* no temp file */ }
+      throw error;
+    }
+  }
+}
+
+function receipt(item: SeatRequestItem): Response {
+  return jsonResponse({ receiptId: item.receiptId, seat: item.seat, queuedAt: item.queuedAt }, 202);
+}
+
+function unavailable(): Response {
+  debug.log('seat-address.pwa', 'rejected', { reason: 'journal-unavailable' });
+  return jsonResponse({ error: 'enqueue-failed' }, 503);
+}
+
+export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps = {}): Promise<Response> {
+  const path = file((deps.root ?? effectiveInstanceRoot)());
+  if (req.method === 'GET') {
+    const params = new URL(req.url).searchParams;
+    const requestedSeat = params.get('seat');
+    const seat = requestedSeat ? resolveSeat(requestedSeat) : undefined;
+    if (requestedSeat && !seat) return unknownSeat();
+    const rawLimit = params.get('limit');
+    const limit = rawLimit === null ? 20 : Number(rawLimit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) return jsonResponse({ error: 'bad_request' }, 400);
+    try {
+      const items = [...records(path).values()].filter((entry): entry is RecordEntry & SeatRequestItem => entry.status === 'queued')
+        .reverse().filter((item) => !seat || item.seat === seat.id).slice(0, limit)
+        .map(({ receiptId, seat: id, text, queuedAt, status }) => ({ receiptId, seat: id, text, queuedAt, status }));
+      return jsonResponse({ items, seats });
+    } catch { return unavailable(); }
+  }
+  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); }
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return jsonResponse({ error: 'bad_request' }, 400);
+  const input = body as Record<string, unknown>;
+  if (typeof input.text !== 'string' || !input.text.trim()
+    || (input.seat !== undefined && typeof input.seat !== 'string')) {
+    debug.log('seat-address.pwa', 'rejected', { reason: 'invalid-body' });
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  // An implicit address must start the text; parseSeatAddress also accepts later lines.
+  const parsed = input.text.startsWith('@') ? parseSeatAddress(input.text) : null;
+  const prefix = parsed ? `@${parsed.seats.join(',')}` : '';
+  const firstAddress = parsed && input.text.startsWith(prefix)
+    && (input.text.length === prefix.length || /[ \t\r\n]/.test(input.text[prefix.length]!)) ? parsed : null;
+  const address = input.seat ?? (firstAddress?.seats.length === 1 ? firstAddress.seats[0] : undefined);
+  const seat = address ? resolveSeat(address) : undefined;
+  if (!seat) return unknownSeat();
+  const text = input.seat === undefined ? firstAddress!.body.trim() : input.text.trim();
+  if (!text) {
+    debug.log('seat-address.pwa', 'rejected', { reason: 'empty-text', seat: seat.id });
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  debug.log('seat-address.pwa', 'parsed', { seat: seat.id, textLength: text.length });
+  const now = (deps.now ?? (() => new Date().toISOString()))();
+  const header = req.headers.get('idempotency-key');
+  if (header !== null && (!header.trim() || header.length > 200)) return jsonResponse({ error: 'bad_request' }, 400);
+  const payload = `${seat.id}\0${text}`;
+  const key = header === null ? createHash('sha256').update(randomUUID()).digest('hex')
+    : createHash('sha256').update(`client\0${header}`).digest('hex');
+  const lock = `${path}\0${key}`;
+  const pending = inFlight.get(lock);
+  if (pending) {
+    if (pending.payload !== payload) return jsonResponse({ error: 'idempotency-conflict' }, 409);
+    return pending.task.then((response) => response.clone());
+  }
+  // Install the lock before starting disk or queue work; a second caller must
+  // wait for the first instead of independently submitting the same key.
+  let start!: () => void;
+  const gate = new Promise<void>((resolve) => { start = resolve; });
+  const task = (async (): Promise<Response> => {
+    await gate;
+    let existing: RecordEntry | undefined;
+    try { existing = records(path).get(key); }
+    catch { return unavailable(); }
+    if (existing) {
+      if (existing.seat !== seat.id || existing.text !== text) return jsonResponse({ error: 'idempotency-conflict' }, 409);
+      if (existing.status === 'queued') return receipt(existing);
+    }
+    const intent: PendingRequest = existing?.status === 'pending'
+      ? existing : { key, seat: seat.id, text, queuedAt: now, status: 'pending', ref: `pwa:${randomUUID()}` };
+    if (existing?.status !== 'pending') {
+      try {
+        (deps.append ?? append)(path, intent);
+        if (existing?.status === 'rejected') {
+          const sidecar = outcomeFile(path, key);
+          if (existsSync(sidecar)) unlinkSync(sidecar);
+        }
+      } catch { return unavailable(); }
+    }
+    let result: Awaited<ReturnType<typeof submitIntakeWork>>;
+    try {
+      result = await (deps.submit ?? submitIntakeWork)({
+        text: `@${seat.title ?? seat.id} ${text}`,
+        track: 'graph',
+        origin: { kind: 'external', ledgerSource: 'pwa', provider: 'other', ref: intent.ref, reportTo: { channel: 'pwa' } },
+      });
+    } catch { return unavailable(); }
+    if (!result.ok || result.track !== 'graph') {
+      debug.log('seat-address.pwa', 'rejected', { reason: result.ok ? 'unexpected-track' : result.reason, seat: seat.id });
+      try { persistOutcome(path, { ...intent, status: 'rejected' }, deps.append ?? append); }
+      catch { return unavailable(); }
+      return unavailable();
+    }
+    const item: RecordEntry & SeatRequestItem = { key, receiptId: result.acceptanceId, seat: seat.id, text, queuedAt: intent.queuedAt, status: 'queued' };
+    try { persistOutcome(path, item, deps.append ?? append); }
+    catch { return unavailable(); }
+    debug.log('seat-address.pwa', 'enqueued', { seat: seat.id, receiptId: item.receiptId });
+    return receipt(item);
+  })();
+  inFlight.set(lock, { payload, task });
+  start();
+  try { return await task; }
+  finally { inFlight.delete(lock); }
+}

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/api/trace-run-scan.ts

@@ -0,0 +1,37 @@
+import { statSync } from 'node:fs';
+import type { LogInstanceView } from '../../mss/logging/instance-registry.js';
+import type { LogStore } from '../../mss/logging/log-store.js';
+
+/** Bounded, read-only fallback when a run's ledger is not on this host. */
+export function scanStoresForRun(
+  runId: string,
+  views: readonly LogInstanceView[],
+  open: (view: LogInstanceView) => Pick<LogStore, 'queryTraceRun' | 'close'> | null,
+  opts: { sinceMs?: number; untilMs?: number; maxStores?: number; deadlineMs?: number; now?: () => number } = {},
+): { universe?: string; checked: number; truncated: boolean; unresolved?: boolean } {
+  const now = opts.now ?? Date.now;
+  const deadline = now() + (opts.deadlineMs ?? 3000);
+  const maxStores = opts.maxStores ?? 200;
+  const mtime = (view: LogInstanceView): number => {
+    try { return statSync(view.dbPath).mtimeMs; } catch { return -Infinity; }
+  };
+  const candidates = views.map((view) => ({ view, at: view.dbExists ? mtime(view) : -Infinity }))
+    .sort((a, b) => (b.at === a.at ? a.view.name.localeCompare(b.view.name) : b.at - a.at));
+  let checked = 0;
+  let unresolved = false;
+  for (const { view } of candidates) {
+    if (checked >= maxStores || now() >= deadline) return { checked, truncated: true };
+    checked++;
+    let store: ReturnType<typeof open> = null;
+    try {
+      if (!view.dbExists) continue;
+      store = open(view);
+      if (!store) { unresolved = true; continue; }
+      if (store.queryTraceRun(runId, { sinceMs: opts.sinceMs, untilMs: opts.untilMs, limit: 1 }).length) {
+        return { universe: view.name, checked, truncated: false };
+      }
+    } catch { unresolved = true; }
+    finally { try { store?.close(); } catch { /* read-only handle cleanup is best effort */ } }
+  }
+  return { checked, truncated: false, ...(unresolved ? { unresolved } : {}) };
+}

package/src/nexus/api/trace.ts

@@ -8,6 +8,7 @@ import { activeStoreNames, parseSinceParam, type LogFabricDeps, registeredLogSto
 import { checkAuth, type MetaApiOpts } from './meta-api.js';
 import { jsonResponse } from './json-response.js';
 import { runLedgerDir, runLedgerPath } from '../../self-implement/run-ledger.js';
+import { scanStoresForRun } from './trace-run-scan.js';
 
 export type TraceLevel = 'L0' | 'L1' | 'L2' | 'L3';
 export interface TraceEvent {
@@ -346,7 +347,8 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
     }
     if (!opened) return jsonResponse({ ok: false, error: 'log-store-unavailable', failedStores: failures }, 503);
     const runId = url.searchParams.get('runId');
-    let resolution: { universe?: string; checked: number } | undefined;
+    let resolution: { universe?: string; checked: number; truncated?: boolean; unresolved?: boolean } | undefined;
+    let resolvedFrom: 'ledger' | 'log-scan' | undefined;
     if ((parsed.level === 'L2' || parsed.level === 'L3') && runId && !rows.some((row) => matches(row, url)) && !requestedUniverse) {
       // A store with no log db at all («has no log store yet» — e.g. the daemon's own tree-derived universe) cannot
       // hold the run, so it must not block the ledger lookup. A store that exists but failed to open/read still does:
@@ -356,6 +358,20 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
       try { resolution = findRunUniverse(runId, names, deps); }
       catch (error) { return jsonResponse({ ok: false, error: 'run-universe-unavailable', reason: error instanceof Error ? error.message : String(error) }, 503); }
       try { debug.log('nexus.trace', 'run-universe-resolved', { runId, universe: resolution.universe ?? 'not-found', checked: resolution.checked }); } catch { /* observation must not block reads */ }
+      if (resolution.universe) resolvedFrom = 'ledger';
+      else {
+        let views: LogInstanceView[];
+        try { views = (deps.instances ?? readLogInstances)(); }
+        catch (error) { return jsonResponse({ ok: false, error: 'run-universe-unavailable', reason: error instanceof Error ? error.message : String(error) }, 503); }
+        resolution = scanStoresForRun(runId, views, (view) => {
+          const store = (deps.openRemoteStore ?? ((v: LogInstanceView) => LogStore.openReadOnly(v.dbPath)))(view);
+          if (!store) return null;
+          return { queryTraceRun: (id, query) => store.queryTraceRun(id, query),
+            close: () => (deps.closeRemoteStore ?? ((s: LogStore) => s.close()))(store) };
+        }, { sinceMs: parsed.from, untilMs: parsed.to });
+        if (resolution.universe) resolvedFrom = 'log-scan';
+        try { debug.log('nexus.trace', 'run-universe-scanned', { runId, universe: resolution.universe ?? (resolution.truncated || resolution.unresolved ? 'unresolved' : 'not-found'), checked: resolution.checked, truncated: resolution.truncated }); } catch { /* observation must not block reads */ }
+      }
       if (resolution.universe && !names.includes(resolution.universe)) {
         const name = resolution.universe;
         names.push(name);
@@ -373,9 +389,9 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
       }
     }
     const filtered = rows.filter((row) => matches(row, url)).sort(sortRows);
-    const trace = buildTrace(filtered.slice(0, parsed.limit), parsed.level, filtered.length > parsed.limit || candidateLimitReached || failures.length > 0);
+    const trace = buildTrace(filtered.slice(0, parsed.limit), parsed.level, filtered.length > parsed.limit || candidateLimitReached || failures.length > 0 || resolution?.truncated === true);
     try { (deps.queryLog ?? ((details) => debug.log('logs.trace', 'query', details)))({ stores: names, level: parsed.level, count: trace.events.length, truncated: trace.truncated, mode: 'rows', runs: trace.nodes.filter((node) => node.level === 'L1' && node.count > 0).length }); } catch { /* query logging must not block reads */ }
-    return jsonResponse({ ok: true, ...trace, stores: names, registeredStores: registeredStoreCount(deps), ...(resolution ? resolution.universe ? { resolvedFrom: 'ledger' as const, runUniverse: resolution.universe } : { runUniverse: 'not-found' as const, checked: resolution.checked } : {}), ...(failures.length ? { failedStores: failures } : {}) }, 200);
+    return jsonResponse({ ok: true, ...trace, stores: names, registeredStores: registeredStoreCount(deps), ...(resolution ? resolution.universe ? { resolvedFrom, runUniverse: resolution.universe, ...(resolvedFrom === 'log-scan' ? { checked: resolution.checked } : {}) } : { runUniverse: resolution.truncated || resolution.unresolved ? 'unresolved' as const : 'not-found' as const, checked: resolution.checked } : {}), ...(failures.length ? { failedStores: failures } : {}) }, 200);
   } finally { closeStores(stores, deps); }
 }
 

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);
@@ -2626,13 +2632,17 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
               getBot: () => getBotRef.current,
               allowedUsers: [...cfg.discord.allowedUsers],
             });
+            const chatChannels = cfg.discord.chatChannels ?? [];
+            debug.log('nexus.discord', 'chat-channels', { count: chatChannels.length });
             const handle = createNexusDiscordTriggerBot({
               token: discordToken,
               allowedUsers: [...cfg.discord.allowedUsers],
+              ...(chatChannels.length ? { guildTextChannels: chatChannels } : {}),
               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);
               },
@@ -2641,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)}`);
               });
@@ -2916,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,