elanous 0.2.0 → 0.2.4

package/src/nexus/api/pod-credential-api.ts

@@ -0,0 +1,133 @@
+/** POST /v1/pod/credential/grok — Pod 가 만료 전에 새 grok access 만 받는 문.
+ *
+ *  인증은 넥서스 bearer 가 아니다. `mintGroundingToken({ scope: 'llm-credential' })` 만 통과한다.
+ *  응답 키는 `key`·`expires_at` 둘뿐. refresh·계정 id·파일 경로는 응답·로그·에러에 싣지 않는다.
+ */
+import { debug } from '../../debug/log.js';
+import { verifyGroundingToken, type GroundingTokenDeps } from '../../grounding/token.js';
+import { isGrokSubscriptionExpiring, readGrokSubscriptionAccess, refreshGrokSubscriptionToken } from '../../grok/credential.js';
+
+export const POD_CREDENTIAL_GROK_PATH = '/v1/pod/credential/grok';
+/** 만료까지 이 안이면 기존 호스트 갱신(`refreshGrokSubscriptionToken`)을 한 번 부른다. */
+export const POD_CREDENTIAL_HOST_REFRESH_WINDOW_MS = 10 * 60 * 1000;
+/** runId 당 분당 1회. */
+export const POD_CREDENTIAL_PER_RUN_PER_MIN = 1;
+/** ⓢ6 — 토큰이 새어 runId 를 늘려도 막는 프로세스 전역 분당 상한. */
+export const POD_CREDENTIAL_GLOBAL_PER_MIN = 30;
+
+export type PodCredentialReason = 'expired' | 'revoked' | 'scope' | 'rate' | 'unauthorized' | 'unavailable';
+
+export interface PodCredentialDeps {
+  readonly token?: GroundingTokenDeps;
+  readonly now?: () => number;
+  readonly home?: string;
+  readonly env?: NodeJS.ProcessEnv;
+  /** 테스트 심 — 호스트 grok 바이너리 대신. */
+  readonly refreshExec?: (cmd: string, args: string[], timeoutMs: number) => void;
+  readonly loadAccess?: (home: string | undefined, env: NodeJS.ProcessEnv) => { key: string; expiresAt: string } | null;
+}
+
+interface HitWindow {
+  readonly stamps: number[];
+}
+
+const hitsByRun = new Map<string, HitWindow>();
+const globalHits: number[] = [];
+
+export function resetPodCredentialRateForTesting(): void {
+  hitsByRun.clear();
+  globalHits.length = 0;
+}
+
+function prune(stamps: number[], now: number): number[] {
+  return stamps.filter((t) => now - t < 60_000);
+}
+
+function takeRate(runId: string, now: number): boolean {
+  const prev = prune(hitsByRun.get(runId)?.stamps ?? [], now);
+  const global = prune(globalHits, now);
+  globalHits.length = 0;
+  globalHits.push(...global);
+  if (prev.length >= POD_CREDENTIAL_PER_RUN_PER_MIN || globalHits.length >= POD_CREDENTIAL_GLOBAL_PER_MIN) {
+    hitsByRun.set(runId, { stamps: prev });
+    return false;
+  }
+  prev.push(now);
+  globalHits.push(now);
+  hitsByRun.set(runId, { stamps: prev });
+  return true;
+}
+
+function bearerOf(req: Request): string | null {
+  const raw = req.headers.get('authorization') ?? req.headers.get('Authorization');
+  if (!raw) return null;
+  const m = /^Bearer\s+(\S+)$/.exec(raw.trim());
+  return m?.[1] ?? null;
+}
+
+function reasonResponse(status: number, reason: PodCredentialReason): Response {
+  return Response.json({ reason }, { status });
+}
+
+function defaultLoad(home: string | undefined, _env: NodeJS.ProcessEnv, refreshExec?: PodCredentialDeps['refreshExec'], now?: () => number): { key: string; expiresAt: string } | null {
+  if (isGrokSubscriptionExpiring({
+    ...(home ? { home } : {}),
+    bufferMs: POD_CREDENTIAL_HOST_REFRESH_WINDOW_MS,
+    ...(now ? { now } : {}),
+  })) {
+    refreshGrokSubscriptionToken({
+      ...(home ? { home } : {}),
+      ...(refreshExec ? { execImpl: refreshExec } : {}),
+    });
+  }
+  const access = readGrokSubscriptionAccess(home);
+  if (!access?.expiresAt) return null;
+  return { key: access.key, expiresAt: access.expiresAt };
+}
+
+/** 핸들러 몸. http-server 는 이 함수를 부르기 «전»에 `authenticatePodCredential` 을 먼저 부른다. */
+export async function handlePodGrokCredential(req: Request, deps: PodCredentialDeps = {}): Promise<Response> {
+  const gate = await authenticatePodCredential(req, deps);
+  if (!gate.ok) return gate.response;
+  const now = (deps.now ?? Date.now)();
+  if (!takeRate(gate.runId, now)) return reasonResponse(429, 'rate');
+
+  const env = deps.env ?? process.env;
+  let loaded: { key: string; expiresAt: string } | null;
+  try {
+    loaded = deps.loadAccess
+      ? deps.loadAccess(deps.home, env)
+      : defaultLoad(deps.home, env, deps.refreshExec, deps.now);
+  } catch {
+    return reasonResponse(503, 'unavailable');
+  }
+  if (!loaded || !loaded.key) return reasonResponse(503, 'unavailable');
+
+  const expiresAt = loaded.expiresAt;
+  debug.log('pod.credential', 'grok-issued', { runId: gate.runId, job: gate.job, expiresAt });
+  debug.log('pod.credential', 'issuance', { runId: gate.runId, job: gate.job, exp: gate.exp });
+  return Response.json({ key: loaded.key, expires_at: expiresAt });
+}
+
+/**
+ * 쓰기 관문. 본문을 읽지 않는다. 토큰이 없거나 서명이 깨지면 401,
+ * scope·만료·회수는 403 과 사유만.
+ */
+export async function authenticatePodCredential(
+  req: Request,
+  deps: PodCredentialDeps = {},
+): Promise<
+  | { readonly ok: true; readonly runId: string; readonly job: string; readonly exp: number }
+  | { readonly ok: false; readonly response: Response }
+> {
+  const token = bearerOf(req);
+  if (!token) return { ok: false, response: Response.json({ error: 'unauthorized' }, { status: 401 }) };
+  const verified = await verifyGroundingToken(token, { ...(deps.token ?? {}), expectedScope: 'llm-credential' });
+  if (!verified.ok) {
+    if (verified.reason === 'expired' || verified.reason === 'revoked' || verified.reason === 'scope') {
+      return { ok: false, response: reasonResponse(403, verified.reason) };
+    }
+    return { ok: false, response: Response.json({ error: 'unauthorized' }, { status: 401 }) };
+  }
+  return { ok: true, runId: verified.runId, job: verified.job, exp: verified.exp };
+}

package/src/nexus/api/public-routes.ts

@@ -0,0 +1,80 @@
+// NEXUS `/v1` default-deny allowlist — one code constant.
+//
+// `routeRequest` calls `isPublicRoute` before any handler. A `/v1/` path
+// that is not listed here must pass the existing `checkAuth` (same-origin
+// exemption + constant-time bearer). Static `/app/*` and `/` are outside
+// `/v1` and are not gate subjects.
+//
+// Callbacks and webhooks stay off this list:
+//   - `handleHitlCallback` (`src/nexus/api/meta-api.ts`) calls `checkAuth`
+//     itself; it does not verify a callback signature or token of its own.
+//   - `checkAuth` (`src/workflow-runtime/triggers/webhook-router.ts`)
+//     returns success when the registered trigger has no `auth`, so an
+//     unauthenticated POST can still dispatch a workflow.
+
+export type PublicRouteMatch = 'exact' | 'prefix';
+
+export interface PublicRoute {
+  method: string;
+  match: PublicRouteMatch;
+  path: string;
+  why: string;
+  /** The handler verifies its own credential (not the nexus bearer) and may answer 401 itself. */
+  selfVerified?: true;
+}
+
+export const PUBLIC_ROUTES: Array<PublicRoute> = [
+  {
+    method: 'GET',
+    match: 'exact',
+    path: '/v1/health',
+    why: 'liveness probe and setup-mode signal (F condition 2)',
+  },
+  {
+    method: 'GET',
+    match: 'exact',
+    path: '/v1/push/vapid-public-key',
+    why: 'PWA fetches the VAPID public key before a bearer is pasted',
+  },
+  {
+    method: 'GET',
+    match: 'exact',
+    path: '/v1/nexus/connect-info',
+    why: 'connect metadata only; auto_token removed in #20782',
+  },
+  {
+    method: 'POST',
+    match: 'exact',
+    path: '/v1/pod/credential/grok',
+    selfVerified: true,
+    why: 'Pod grok access relay (#20789); Pods hold no nexus bearer — pod-credential-api.ts verifies its own llm-credential token (verifyGroundingToken expectedScope) before reading the body',
+  },
+  {
+    method: 'GET',
+    match: 'prefix',
+    path: '/v1/setup/',
+    why: 'setup wizard routes; public only while setupMode is true (P24b)',
+  },
+];
+
+export interface PublicRouteContext {
+  setupMode: boolean;
+}
+
+/** True when this method+pathname is on the public allowlist. */
+export function isPublicRoute(
+  method: string,
+  pathname: string,
+  ctx: PublicRouteContext,
+): boolean {
+  for (const route of PUBLIC_ROUTES) {
+    if (route.method !== method) continue;
+    if (route.path.startsWith('/v1/setup/') && !ctx.setupMode) continue;
+    if (route.match === 'exact') {
+      if (pathname === route.path) return true;
+    } else if (pathname === route.path || pathname.startsWith(route.path)) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/nexus/api/rest-route-paths.ts

@@ -32,9 +32,24 @@
  *  bun test test/rest-route-paths-single-home.test.ts
  *  ``` */
 
+/** `POST /v1/design-direction` — owner-authenticated repository design direction selection. */
+export const DESIGN_DIRECTION_PATH = '/v1/design-direction';
+
+/** `POST /v1/design-system` — owner-authenticated custom system from a URL or a palette. */
+export const DESIGN_SYSTEM_PATH = '/v1/design-system';
+
+/** `GET /v1/design-previews` — HTML previews under the resolved repository. */
+export const DESIGN_PREVIEWS_PATH = '/v1/design-previews';
+
+/** `GET /v1/design-previews/<system>` — one preview document. */
+export const DESIGN_PREVIEW_PATH_PREFIX = '/v1/design-previews/';
+
 /** `GET /v1/devices` — 디바이스 함대 스냅샷. */
 export const DEVICES_PATH = '/v1/devices';
 
+/** Owner-only idea PR review and merge. */
+export const APPROVALS_MERGES_PATH = '/v1/approvals/merges';
+
 /** `POST /v1/templates/capability-preview` — 템플릿 능력 미리보기.
  *  📏 이 여섯째는 앞 다섯을 접자 «자가 곧바로 다음 후보로 올려 준 것»이다 — 같은 부류라 같이 접었다. */
 export const TEMPLATE_CAPABILITY_PREVIEW_PATH = '/v1/templates/capability-preview';

package/src/nexus/api/schedules-action.ts

@@ -18,9 +18,13 @@ interface ScheduleActionBody {
   command?: string;
   category?: string;
   note?: string;
+  confirm?: boolean;
 }
 
-export async function handleSchedulesActionPost(req: Request): Promise<Response> {
+export async function handleSchedulesActionPost(
+  req: Request,
+  dispatch?: (args: Record<string, unknown>) => Promise<unknown>,
+): Promise<Response> {
   let body: ScheduleActionBody;
   try {
     body = (await req.json()) as ScheduleActionBody;
@@ -29,9 +33,14 @@ export async function handleSchedulesActionPost(req: Request): Promise<Response>
   }
   const action = typeof body.action === 'string' ? body.action.trim() : '';
   if (!action) return jsonResponse({ error: 'action 필수 (adopt/release/enable/disable/delete/update/create)' }, 400);
+  if (['delete', 'migrate', 'adopt', 'release'].includes(action) && body.confirm !== true) {
+    const id = typeof body.id === 'string' ? body.id : '';
+    return jsonResponse({ dryRun: true, action, id,
+      plan: `${id || '(id 미지정)'}: ${action} 적용 예정 — confirm:true 로 확인 후 실행.` });
+  }
 
-  const { dispatchScheduleManage } = await import('../../domains/schedule-manage-tool.js');
-  const result = await dispatchScheduleManage({
+  const run = dispatch ?? (await import('../../domains/schedule-manage-tool.js')).dispatchScheduleManage;
+  const result = await run({
     action,
     ...(body.id !== undefined ? { id: body.id } : {}),
     ...(body.cron !== undefined ? { cron: body.cron } : {}),

package/src/nexus/api/schedules-read.ts

@@ -0,0 +1,228 @@
+import { existsSync } from 'node:fs';
+import { Database } from 'bun:sqlite';
+import { redactSecretText } from '../../debug/log.js';
+import { logsDbPath, LogStore } from '../../mss/logging/log-store.js';
+import {
+  listSchedules, parseCronLine, cronEntryId, unwrapCronCommand, scriptName, readCrontab, schedulesDbPath,
+  type ScheduleRow,
+} from '../../domains/schedule-registry.js';
+import {
+  computeScheduleState, displayName, findDuplicates, futureRuns, listLaunchdElanous,
+  type LaunchdEntry, type ScheduleState,
+} from '../../domains/schedule-state.js';
+import { getToxRuntimeDeps } from '../../task-orchestrator/runtime-deps.js';
+import { tasksDbPath } from '../../task-orchestrator/paths.js';
+import { jsonResponse } from './http-server.js';
+import { checkAuth, type MetaApiOpts } from './meta-api.js';
+import { listScheduleRuns } from '../../domains/schedule-runs.js';
+
+export interface SchedulesReadDeps {
+  rows?: () => ScheduleRow[];
+  crontab?: () => string;
+  launchd?: () => LaunchdEntry[];
+  triggerIds?: () => ReadonlySet<string>;
+  logsPath?: () => string;
+  /** 발화 이력 원천(`schedule_runs`) — 기본은 schedules.db 를 읽기 전용으로 연다. */
+  schedulesDbPath?: () => string;
+  now?: () => Date;
+}
+
+interface ScheduleRun {
+  at: string;
+  status: string | null;
+  exit: number | null;
+  durationMs: number | null;
+  via: string | null;
+  matchedBy: 'name' | 'id';
+  runId?: string | null;
+}
+
+interface ScheduleCard {
+  id: string;
+  name: string;
+  source: string;
+  cron: string | null;
+  intervalMs: number | null;
+  command: string | null;
+  /** 레지스트리 메타(🅕 09-28 · PWA Schedules 탭이 대시보드 경로 없이 그리게) — 실행 주체·분류·설명. */
+  runVia: string | null;
+  category: string | null;
+  domain: string | null;
+  note: string | null;
+  state: ScheduleState;
+  registryEnabled: boolean;
+  next: string[];
+  lastRun: { at: string; status: string | null; exit: number | null; durationMs: number | null; via: string | null } | null;
+  flags: string[];
+  pid?: number | null;
+  lastExit?: number | null;
+}
+
+/** Open only existing stores and never invoke inventory/migration on a GET. */
+function registryRows(): ScheduleRow[] {
+  if (!existsSync(schedulesDbPath())) return [];
+  try {
+    const db = new Database(schedulesDbPath(), { readonly: true });
+    try { return listSchedules(db); } finally { db.close(); }
+  } catch { return []; }
+}
+
+/** Match persisted TOX task identity to an *active* daemon subscription, not to registry.enabled. */
+function registeredTriggerIds(): ReadonlySet<string> {
+  const daemon = getToxRuntimeDeps().getWorkflowDaemon?.() as {
+    status?: () => { started: boolean; subscriptions: Array<{ workflowName: string; nodeId: string }> };
+  } | null | undefined;
+  let status: { started: boolean; subscriptions: Array<{ workflowName: string; nodeId: string }> } | undefined;
+  try { status = daemon?.status?.(); } catch { return new Set(); }
+  if (!status?.started || !existsSync(tasksDbPath())) return new Set();
+  const subscriptions = new Set(status.subscriptions.filter(s => s.nodeId === 'trigger').map(s => s.workflowName));
+  try {
+    const db = new Database(tasksDbPath(), { readonly: true });
+    try {
+      const tasks = db.query("SELECT id, scheduler_job_id FROM tox_tasks WHERE scheduler_job_id IS NOT NULL AND schedule_text IS NOT NULL AND status NOT IN ('done','failed','cancelled','superseded')").all() as Array<{ id: string; scheduler_job_id: string }>;
+      return new Set(tasks.filter(t => subscriptions.has(`tox-task-${t.id}`)).map(t => t.scheduler_job_id));
+    } finally { db.close(); }
+  } catch { return new Set(); }
+}
+
+function recordedRuns(name: string, path: string = logsDbPath()): ScheduleRun[] {
+  if (!existsSync(path)) return [];
+  let store: LogStore;
+  try { store = LogStore.openReadOnly(path); } catch { return []; }
+  try {
+    // The current log has no schedule id; match the exact event name, never substring grep.
+    return store.query({ exactCategories: ['schedule.run'], events: [name], limit: 50 }).map(row => {
+      let data: { status?: string; exit?: number | null; ms?: number | null; via?: string } = {};
+      try { data = JSON.parse(row.data ?? '{}'); } catch { /* old log without JSON */ }
+      return { at: row.ts, status: data.status ?? null, exit: data.exit ?? null,
+        durationMs: data.ms ?? null, via: data.via ?? null, matchedBy: 'name' };
+    });
+  } catch { return []; } finally { store.close(); }
+}
+
+/** 행 id 로 쓴 발화 이력(`schedule_runs` · S2) — 이름 매칭보다 정확하다. 표·파일이 없으면 빈 목록. */
+function idRuns(id: string, deps: SchedulesReadDeps, opts: { limit?: number; before?: string } = {}): ScheduleRun[] {
+  const path = deps.schedulesDbPath?.() ?? schedulesDbPath();
+  if (path !== ':memory:' && !existsSync(path)) return [];
+  let db: Database;
+  try { db = new Database(path, { readonly: true }); } catch { return []; }
+  try {
+    return listScheduleRuns(db, id, opts).map((run) => ({
+      at: run.fired_at, status: run.status, exit: run.exit, durationMs: run.duration_ms, via: run.via, matchedBy: 'id' as const, runId: run.run_id,
+    }));
+  } finally { db.close(); }
+}
+
+function inventory(deps: SchedulesReadDeps): { cards: ScheduleCard[]; names: Map<string, string> } {
+  const now = deps.now?.() ?? new Date();
+  const lines = (deps.crontab ?? readCrontab)().split('\n');
+  const launches = (deps.launchd ?? listLaunchdElanous)();
+  const triggers = (deps.triggerIds ?? registeredTriggerIds)();
+  const rows = [...(deps.rows ?? registryRows)()];
+  const known = new Set(rows.map(r => r.id));
+  // Bare crontab jobs are part of the live inventory even before the registry has scanned them.
+  for (const line of lines) {
+    const entry = parseCronLine(line);
+    if (!entry) continue;
+    const id = cronEntryId(entry.cron, unwrapCronCommand(entry.command));
+    if (known.has(id) || rows.some(r => r.cron === entry.cron &&
+      (unwrapCronCommand(r.command ?? '').trim() === unwrapCronCommand(entry.command).trim() ||
+        (!!r.raw && r.raw.trim() === line.trim())))) continue;
+    known.add(id);
+    rows.push({ id, name: scriptName(entry.command), source: 'crontab', cron: entry.cron,
+      interval_ms: null, command: entry.command, category: 'maintenance', domain: null, enabled: 0,
+      last_seen: null, last_run: null, note: null, managed_by: 'manual', raw: line, run_via: 'crontab' });
+  }
+  const names = new Map<string, string>();
+  const cards: ScheduleCard[] = rows.map(row => {
+    const next = futureRuns(row, now);
+    const state = computeScheduleState({ row, crontabLines: lines, triggerRegistered: triggers.has(row.id),
+      launchdLoaded: false, now, nextRuns: next });
+    names.set(row.id, row.name);
+    return {
+      id: row.id, name: redactSecretText(row.command ? displayName(row.command) : row.name), source: row.source,
+      cron: row.cron, intervalMs: row.interval_ms, command: row.command ? redactSecretText(row.command) : null,
+      runVia: row.run_via ?? null, category: row.category ?? null, domain: row.domain ?? null,
+      note: row.note ? redactSecretText(row.note) : null,
+      state, registryEnabled: !!row.enabled, next,
+      lastRun: row.last_run ? { at: row.last_run, status: row.last_status ?? null, exit: row.last_exit ?? null,
+        durationMs: row.last_duration_ms ?? null, via: row.last_via ?? null } : null,
+      flags: [ ...(state === 'stale' ? ['stale'] : []), ...(!row.last_run ? ['no-history'] : []),
+        ...(/(?:^|\s|\/)pilot(?:\/|\s|$)/.test(row.command ?? '') ? ['pilot-path'] : []) ],
+    } satisfies ScheduleCard;
+  });
+  for (const row of rows) {
+    if (!triggers.has(row.id)) continue;
+    const crontabOwns = lines.some(line => {
+      const parsed = parseCronLine(line);
+      return !!parsed && parsed.cron === row.cron &&
+        (unwrapCronCommand(parsed.command).trim() === unwrapCronCommand(row.command ?? '').trim() ||
+          (!!row.raw && line.trim() === row.raw.trim()));
+    });
+    if (!crontabOwns) continue;
+    const original = cards.find(card => card.id === row.id)!;
+    cards.push({ ...original, id: `trigger:${row.id}`, source: 'trigger', runVia: 'trigger',
+      state: computeScheduleState({ row: { ...row, run_via: 'trigger' }, crontabLines: [], triggerRegistered: true,
+        launchdLoaded: false, now, nextRuns: original.next }) });
+    names.set(`trigger:${row.id}`, row.name);
+  }
+  for (const launch of launches) {
+    cards.push({ id: `launchd:${launch.label}`, name: launch.label.slice('com.elanous.'.length), source: 'launchd',
+      cron: null, intervalMs: null, command: null, runVia: 'launchd', category: 'maintenance', domain: 'elanous', note: null, state: 'live', registryEnabled: false, next: [],
+      lastRun: null, flags: ['no-history'], pid: launch.pid, lastExit: launch.lastExit });
+  }
+  const commands = new Map(rows.map(row => [row.id, row.command]));
+  for (const row of rows) if (triggers.has(row.id)) commands.set(`trigger:${row.id}`, row.command);
+  const duplicateCandidates = cards.map(card => ({ command: commands.get(card.id) ?? null,
+    state: card.state, flags: [] as string[] }));
+  findDuplicates(duplicateCandidates);
+  duplicateCandidates.forEach((candidate, index) => {
+    if (candidate.flags.includes('duplicate')) cards[index]!.flags.push('duplicate');
+  });
+  // The same active crontab line twice collapses into one row above; each copy still fires, so count them.
+  for (const row of rows) {
+    const copies = lines.filter(line => {
+      const parsed = parseCronLine(line);
+      return !!parsed && parsed.cron === row.cron &&
+        (unwrapCronCommand(parsed.command).trim() === unwrapCronCommand(row.command ?? '').trim() ||
+          (!!row.raw && line.trim() === row.raw.trim()));
+    }).length;
+    const card = cards.find(c => c.id === row.id);
+    if (copies >= 2 && card && !card.flags.includes('duplicate')) card.flags.push('duplicate');
+  }
+  return { cards, names };
+}
+
+export function handleSchedulesList(req: Request, opts: MetaApiOpts, deps: SchedulesReadDeps = {}): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  const { cards } = inventory(deps);
+  const schedules = new URL(req.url).searchParams.get('includeOff') === '1' ? cards : cards.filter(c => c.state !== 'off');
+  return jsonResponse({ schedules, count: schedules.length }, 200);
+}
+
+export function handleScheduleDetail(req: Request, id: string, opts: MetaApiOpts, deps: SchedulesReadDeps = {}): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (!id || id.includes('/') || id.includes('\\') || id.includes('..')) return jsonResponse({ error: 'bad_request' }, 400);
+  const { cards, names } = inventory(deps);
+  const schedule = cards.find(card => card.id === id);
+  if (!schedule) return jsonResponse({ error: 'not_found' }, 404);
+  const byId = idRuns(id, deps);
+  const runs = byId.length ? byId : names.has(id) ? recordedRuns(names.get(id)!, deps.logsPath?.()) : [];
+  return jsonResponse({ schedule, runs }, 200);
+}
+
+/** `GET /v1/schedules/:id/runs?before=&limit=` — 행 id 로 쓴 발화 이력 쪽 넘김(최신순 · 기본 50 · 상한 500). */
+export function handleScheduleRuns(req: Request, id: string, opts: MetaApiOpts, deps: SchedulesReadDeps = {}): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (!id || id.includes('/') || id.includes('\\') || id.includes('..')) return jsonResponse({ error: 'bad_request' }, 400);
+  const url = new URL(req.url);
+  const limitRaw = url.searchParams.get('limit');
+  const before = url.searchParams.get('before') ?? undefined;
+  const limit = limitRaw === null ? undefined : Number(limitRaw);
+  try {
+    const runs = idRuns(id, deps, { ...(limit !== undefined ? { limit } : {}), ...(before !== undefined ? { before } : {}) });
+    return jsonResponse({ id, runs, count: runs.length }, 200);
+  } catch (error) {
+    return jsonResponse({ error: 'bad_request', reason: error instanceof Error ? error.message : String(error) }, 400);
+  }
+}

package/src/nexus/api/sessions-store.ts

@@ -102,8 +102,14 @@ export function handleSessionsStoreList(req: Request, opts: MetaApiOpts): Respon
 export function handleSessionsStoreGet(req: Request, id: string, opts: MetaApiOpts): Response {
   if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
   const loaded = loadSession(id);
-  if (!loaded) return jsonResponse({ ok: false, error: 'not_found' }, 404);
-  return jsonResponse({ ok: true, meta: loaded.meta, messages: loaded.messages }, 200);
+  if (!loaded) {
+    // `?ifExists=1` — «있으면 복원»하는 호출자(PWA 챗·터미널 독: 새 세션은 아직 저장소에 없다)용.
+    // 없음을 오류가 아니라 값으로 돌려준다 — 404 가 매 새 세션마다 콘솔에 빨간 줄을 남겼다(탭 트리아지 P0).
+    // ⛔ 기본은 404 그대로(다른 호출자 계약 불변).
+    if (new URL(req.url).searchParams.get('ifExists') === '1') return jsonResponse({ ok: true, exists: false, messages: [] }, 200);
+    return jsonResponse({ ok: false, error: 'not_found' }, 404);
+  }
+  return jsonResponse({ ok: true, exists: true, meta: loaded.meta, messages: loaded.messages }, 200);
 }
 
 /** POST /v1/sessions/store/:id/fork — 히스토리 복사 새 세션(원본 불변·forkedFromId 링크).

package/src/nexus/api/setup-answer-priority.ts

@@ -0,0 +1,130 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { debug } from '../../debug/log.js';
+import { ANSWER_PRIORITY_CHOICES, type AnswerPriority } from '../../onboarding.js';
+import { getUserConfig, reloadUserConfig, userConfigPath } from '../../user-config.js';
+
+function json(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json; charset=utf-8', 'access-control-allow-origin': '*' },
+  });
+}
+
+// Locate a direct JSON member without reserializing its siblings. Values may contain
+// escaped quotes, nested objects and arrays; the scan never treats their keys as siblings.
+function scanValue(text: string, start: number): number {
+  const first = text[start];
+  if (first === '"') {
+    let escaped = false;
+    for (let i = start + 1; i < text.length; i++) {
+      if (!escaped && text[i] === '"') return i + 1;
+      if (!escaped && text[i] === '\\') escaped = true;
+      else escaped = false;
+    }
+  } else if (first === '{' || first === '[') {
+    const close = first === '{' ? '}' : ']';
+    let pos = start + 1;
+    while (pos < text.length) {
+      pos = skipSpace(text, pos);
+      if (text[pos] === close) return pos + 1;
+      if (text[pos] === ',' || text[pos] === ':') { pos++; continue; }
+      pos = scanValue(text, pos);
+    }
+  } else {
+    let pos = start;
+    while (pos < text.length && !/[\s,}\]]/.test(text[pos]!)) pos++;
+    return pos;
+  }
+  throw new Error('invalid config JSON');
+}
+
+function skipSpace(text: string, pos: number): number {
+  while (/\s/.test(text[pos] ?? '')) pos++;
+  return pos;
+}
+
+class DuplicateConfigKeyError extends Error {}
+
+function member(text: string, start: number, name: string): { start: number; end: number } | null {
+  let pos = start + 1;
+  let found: { start: number; end: number } | null = null;
+  while (true) {
+    pos = skipSpace(text, pos);
+    if (text[pos] === '}') return found;
+    const keyEnd = scanValue(text, pos);
+    const key = JSON.parse(text.slice(pos, keyEnd)) as string;
+    const colon = skipSpace(text, keyEnd);
+    if (text[colon] !== ':') throw new Error('invalid config JSON');
+    const valueStart = skipSpace(text, colon + 1);
+    const valueEnd = scanValue(text, valueStart);
+    if (key === name) {
+      if (found) throw new DuplicateConfigKeyError(`duplicate config key: ${name}`);
+      found = { start: valueStart, end: valueEnd };
+    }
+    pos = skipSpace(text, valueEnd);
+    if (text[pos] === ',') pos++;
+  }
+}
+
+function insertMember(text: string, start: number, key: string, value: string): string {
+  const end = scanValue(text, start) - 1;
+  const hasMembers = skipSpace(text, start + 1) < end;
+  return text.slice(0, end) + `${hasMembers ? ',' : ''}${JSON.stringify(key)}:${value}` + text.slice(end);
+}
+
+/** Change only the JSON span of llm.answerPriority; preserve all other bytes. */
+function writeAnswerPriority(value: AnswerPriority): void {
+  const path = userConfigPath();
+  let source: string;
+  try { source = readFileSync(path, 'utf8'); }
+  catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
+    source = '{}\n';
+  }
+  const parsed = JSON.parse(source) as unknown;
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('config JSON must be an object');
+  const root = skipSpace(source, 0);
+  const llm = member(source, root, 'llm');
+  const next = !llm
+    ? insertMember(source, root, 'llm', JSON.stringify({ answerPriority: value }))
+    : (() => {
+      const current = (parsed as { llm?: unknown }).llm;
+      if (!current || typeof current !== 'object' || Array.isArray(current)) throw new Error('config llm must be an object');
+      const answer = member(source, llm.start, 'answerPriority');
+      return answer
+        ? source.slice(0, answer.start) + JSON.stringify(value) + source.slice(answer.end)
+        : insertMember(source, llm.start, 'answerPriority', JSON.stringify(value));
+    })();
+  writeFileSync(path, next, 'utf8');
+}
+
+/** GET /v1/setup/answer-priority */
+export function handleAnswerPriorityGet(): Response {
+  const value = getUserConfig().llm.answerPriority ?? null;
+  return json({ value, effective: value ?? 'balanced', choices: ANSWER_PRIORITY_CHOICES.map(({ value, label, description }) => ({ value, label, description })) });
+}
+
+/** POST /v1/setup/answer-priority */
+export async function handleAnswerPrioritySet(req: Request): Promise<Response> {
+  let body: unknown;
+  try { body = await req.json(); }
+  catch { return json({ error: 'invalid-json', reason: '본문이 JSON 객체가 아니다' }, 400); }
+  if (!body || typeof body !== 'object' || Array.isArray(body)) {
+    return json({ error: 'invalid-body', reason: '본문은 { value } 객체여야 한다' }, 400);
+  }
+  const fields = Object.keys(body).filter((key) => key !== 'value');
+  if (fields.length) return json({ error: 'unknown-fields', reason: `알 수 없는 칸: ${fields.join(', ')}`, fields }, 400);
+  const raw = (body as { value?: unknown }).value;
+  const choice = ANSWER_PRIORITY_CHOICES.find((item) => item.value === raw);
+  if (!choice) return json({ error: 'invalid-answer-priority', reason: '허용되지 않은 답변 깊이' }, 400);
+  try { writeAnswerPriority(choice.value); }
+  catch (error) {
+    if (error instanceof DuplicateConfigKeyError) {
+      return json({ error: 'duplicate-config-key', reason: error.message }, 400);
+    }
+    throw error;
+  }
+  reloadUserConfig();
+  debug.log('pwa.settings', 'answer-priority-set', { value: choice.value });
+  return json({ value: choice.value });
+}