elanous 0.2.4 → 0.2.5

package/src/intake-plane/digest.ts

@@ -3,10 +3,11 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { basename, join, relative } from 'node:path';
 import { loadIntakeLedger, type IntakeItem } from './items.js';
+import { readSavedCursorAt } from './collect-telegram-saved.js';
 import { intakeOutboxDir, kstDay } from './route.js';
 
 export interface DigestEntry { id: string; sources: string[]; url?: string; note?: string; noteName?: string; oneLiner?: string; axis: string }
-export interface IntakeDigest { day: string; absorbed: DigestEntry[]; goals: { fact: string; url?: string }[]; review?: { fact: string; note?: string }[]; grounding: number; release: number; manual: number }
+export interface IntakeDigest { day: string; absorbed: DigestEntry[]; goals: { fact: string; url?: string }[]; review?: { fact: string; note?: string }[]; grounding: number; release: number; manual: number; savedSilence?: { days: number; lastNewAt: string } }
 
 const AXIS_LABEL: Record<string, string> = {
   video_automation: '영상 자동화', agent_basics: '에이전트 기본', agent_applied: '에이전트 응용', unrelated: '그 밖',
@@ -36,7 +37,10 @@ function readJsonl(file: string): Record<string, unknown>[] {
 }
 
 /** `day`(KST YYYY-MM-DD)에 흡수·갈래가 끝난 항목과 그날의 산출 큐를 모은다. */
-export function buildIntakeDigest(root: string, day: string, readFile: (p: string) => string | undefined = (p) => (existsSync(p) ? readFileSync(p, 'utf8') : undefined)): IntakeDigest {
+/** Saved Messages silent for more than two days → the digest says so (a quiet 0 must not look like «nothing to do»). */
+const SAVED_SILENCE_MS = 48 * 3600_000;
+
+export function buildIntakeDigest(root: string, day: string, readFile: (p: string) => string | undefined = (p) => (existsSync(p) ? readFileSync(p, 'utf8') : undefined), now: Date = new Date()): IntakeDigest {
   const items = [...loadIntakeLedger(root).items.values()]
     .filter((i) => (i.status === 'absorbed' || i.status === 'routed') && kstDay(i.lastSeenAt) === day && i.outputs.some((o) => o.kind === 'note'));
   const absorbed = items.map((i: IntakeItem): DigestEntry => {
@@ -53,16 +57,20 @@ export function buildIntakeDigest(root: string, day: string, readFile: (p: strin
   const goals = readJsonl(join(out, 'goals', `${day}.jsonl`)).map((g) => ({ fact: String(g.fact ?? ''), ...(g.url ? { url: String(g.url) } : {}) }));
   const review = readJsonl(join(out, 'review', `${day}.jsonl`)).map((r) => ({ fact: String(r.fact ?? ''), ...(r.note ? { note: String(r.note) } : {}) }));
   const grounding = readJsonl(join(out, 'grounding.jsonl')).filter((g) => typeof g.at === 'string' && kstDay(g.at) === day).length;
+  const lastNewAt = readSavedCursorAt(root);
+  const silentMs = lastNewAt ? now.getTime() - Date.parse(lastNewAt) : NaN;
   return {
     day, absorbed, goals, review, grounding,
     release: readJsonl(join(out, 'release', `${day}.jsonl`)).length,
     manual: readJsonl(join(out, 'manual', `${day}.jsonl`)).length,
+    ...(lastNewAt && silentMs > SAVED_SILENCE_MS ? { savedSilence: { days: Math.floor(silentMs / 86_400_000), lastNewAt } } : {}),
   };
 }
 
 /** 노트 절 — 축별 묶음 · 노트 링크 · 한 줄 요약 · 골 후보. */
 export function renderDigestMarkdown(d: IntakeDigest): string {
   const L: string[] = [`## 📰 오늘의 흡수 요약 (${d.absorbed.length})`, ''];
+  if (d.savedSilence) L.push(`> ⚠️ 텔레그램 «저장된 메시지»에서 새 글을 ${d.savedSilence.days}일째 못 받았다(마지막 새 글 수집 ${kstDay(d.savedSilence.lastNewAt)}) — 저장했는데 안 들어왔다면 저장한 곳(본인 «저장된 메시지»인지)을 확인한다.`, '');
   if (!d.absorbed.length) { L.push('오늘 흡수한 것이 없다.', ''); return L.join('\n'); }
   const byAxis = new Map<string, DigestEntry[]>();
   for (const e of d.absorbed) (byAxis.get(e.axis) ?? byAxis.set(e.axis, []).get(e.axis)!).push(e);
@@ -89,6 +97,7 @@ export function renderDigestMarkdown(d: IntakeDigest): string {
 /** 텔레그램 짧은 판 — 수 · 한 줄 요약 다섯 · 골 후보 · 노트 자리. */
 export function renderDigestTelegram(d: IntakeDigest, opts: { vaultRoot?: string; notePath?: string } = {}): string {
   const L = [`📰 *${d.day} 흡수 ${d.absorbed.length}편*`];
+  if (d.savedSilence) L.push(`⚠️ 저장된 메시지 새 글 ${d.savedSilence.days}일째 0 — 저장한 곳 확인`);
   for (const e of d.absorbed.slice(0, 5)) L.push(`• ${e.oneLiner ?? e.noteName ?? e.url ?? e.id}`);
   if (d.absorbed.length > 5) L.push(`… 외 ${d.absorbed.length - 5}편`);
   if (d.goals.length) L.push('', `🔴 엘라누스에 없는 것 ${d.goals.length}건 — 골 후보`);

package/src/live/detail-switch.ts

@@ -7,7 +7,7 @@
 // 상태 = `<state>/live/detail.json` `{ scope: 'all' | '<runId>', until: <epoch ms>, by?, since }`.
 //   - 넥서스(`/v1/live/detail`)가 쓰고, 하니스·런(다른 프로세스)은 파일을 읽는다 — 프로세스 경계를 넘는 가장 단순한 관.
 //   - `until` 이 지나면 꺼진 것이다(자동 꺼짐 · 파일을 지우는 사람이 없어도 된다).
-// ⛔ 읽기 실패·깨진 파일은 «꺼짐» — 상세 관측은 비용이라 fail-closed.
+// ⛔ 읽기 실패·깨진 파일은 기본 «꺼짐» — 단 유효한 미래 ELANOUS_LIVE_DETAIL_UNTIL 은 전체 범위를 켠다.
 
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
@@ -107,10 +107,15 @@ export function selectLiveDetail(opts: DetailReadOptions = {}): LiveDetailSelect
   return { ...selection, state: parsed && parsed.until > now ? parsed : null };
 }
 
-/** 이 런에 상세 관측이 켜져 있나 — 두 뿌리에 공통인 5초 캐시. */
+/** 이 런에 상세 관측이 켜져 있나 — 파일은 5초 캐시, env 만료는 매번 확인한다. */
 export function isLiveDetailOn(runId?: string, opts: DetailReadOptions = {}): boolean {
   const now = opts.now ?? Date.now();
-  return matches(selectLiveDetail({ ...opts, now }).state, runId, now);
+  const state = selectLiveDetail({ ...opts, now }).state;
+  if (state) return matches(state, runId, now);
+  const rawUntil = process.env.ELANOUS_LIVE_DETAIL_UNTIL;
+  if (!rawUntil || !/^\d+$/.test(rawUntil)) return false;
+  const until = Number(rawUntil);
+  return Number.isSafeInteger(until) && until > now;
 }
 
 function matches(state: LiveDetailState | null, runId: string | undefined, now: number): boolean {

package/src/llm/usable-llm.ts

@@ -0,0 +1,32 @@
+import { decideProviderForConfig, type ProviderDecision } from '../llm.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
+
+export interface UsableLlm {
+  usable: boolean;
+  provider?: string;
+  via: 'login' | 'key' | 'local-server' | 'none';
+  why: string;
+}
+
+export interface UsableLlmDeps {
+  config?: UserConfig;
+  /** The same selector used to construct a runtime LLM; injectable for isolated tests. */
+  decide?: (config: UserConfig) => ProviderDecision;
+}
+
+/** Evaluate the selected route, not the union of discovered credentials or servers. */
+export function resolveUsableLlm(deps: UsableLlmDeps = {}): UsableLlm {
+  const decision = (deps.decide ?? decideProviderForConfig)(deps.config ?? getUserConfig());
+  const provider = decision.provider.replace(/^auto:/, '');
+  // Never echo an untrusted configured provider or a model/URL/credential into output.
+  const known = ['openai-codex', 'openai', 'anthropic', 'grok', 'gemini', 'openrouter', 'local'];
+  if (provider === 'auto' || decision.auth === 'none') {
+    // An explicitly selected provider stays named so callers can offer that provider's fix,
+    // not the Codex login (the auto route's default remedy).
+    const explicit = !decision.provider.startsWith('auto') && known.includes(provider);
+    return { usable: false, ...(explicit ? { provider } : {}), via: 'none', why: 'no usable LLM route selected' };
+  }
+  if (!known.includes(provider)) return { usable: false, via: 'none', why: 'no usable LLM route selected' };
+  const via = decision.auth === 'oauth' ? 'login' : decision.auth === 'apikey' ? 'key' : 'local-server';
+  return { usable: true, provider, via, why: `LLM via ${via} (${provider})` };
+}

package/src/loops/registry.ts

@@ -48,9 +48,13 @@ function graphFiles(dir: string): string[] {
   return entries.flatMap(e => e.isDirectory() ? graphFiles(join(dir, e.name)) : e.isFile() && /\.ya?ml$/.test(e.name) ? [join(dir, e.name)] : []).sort();
 }
 
+/** A wrapper cron that runs the graph itself declares its loop with a trailing `# elanous-loop=<graph_id>` comment. */
+const LOOP_MARKER = /#\s*elanous-loop=([A-Za-z0-9][\w.-]*)\s*$/;
+
 /** Match only the actual graph CLI invocation, not a filename mentioned in a shell argument. */
-export function graphJobMatches(command: string | null, file: string, root: string): boolean {
+export function graphJobMatches(command: string | null, file: string, root: string, graphId?: string): boolean {
   if (!command) return false;
+  if (graphId && command.match(LOOP_MARKER)?.[1] === graphId) return true;
   const invocation = /(?:^|&&\s*|;\s*)(?:(?:\S*\/)?(?:bun|node)\s+(?:\S*\/)?bin\/elanous\.mjs|(?:\S*\/)?elanous)\s+(?:--test(?:=\S+|\s+\S+)\s+)?graph\s+run\s+(['"]?)([^\s'";&|]+)\1(?=\s|$|[;&|])/g;
   for (const match of command.matchAll(invocation)) {
     const arg = match[2]!;
@@ -100,8 +104,17 @@ function schedules(opts: LoopRegistryOptions): ScheduleRow[] {
   } finally { db.close(); }
 }
 
+/** Where loop graphs live and where their cron line `cd`s — the same rule as the other elanous crons:
+ *  the installed package when there is one, else this checkout. Never the caller's cwd: a loop started
+ *  from a disposable worktree would schedule a cron into a directory that is about to disappear (🅣 09-29). */
+export function defaultLoopRoot(): string {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { installedCronRoot, repoRoot } = require('../domains/schedule-registry.js') as typeof import('../domains/schedule-registry.js');
+  return installedCronRoot() ?? repoRoot();
+}
+
 export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
-  const root = resolve(opts.root ?? process.cwd());
+  const root = resolve(opts.root ?? defaultLoopRoot());
   const stateRoot = opts.stateRoot ?? effectiveInstanceRoot();
   const rows = schedules(opts);
   const loops: LoopEntry[] = [];
@@ -117,7 +130,7 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
     const trigger = header?.trigger && typeof header.trigger === 'object' && !Array.isArray(header.trigger) ? header.trigger as Record<string, unknown> : null;
     const declaredCron = typeof trigger?.cron === 'string' ? trigger.cron : null;
     const events = Array.isArray(trigger?.events) ? trigger.events.filter((e): e is string => typeof e === 'string') : [];
-    const matched = rows.filter(row => graphJobMatches(row.command, file, root) && row.source === 'crontab' && row.run_via === 'crontab' && row.disabled_reason !== 'vanished');
+    const matched = rows.filter(row => graphJobMatches(row.command, file, root, doc.graph_id as string) && row.source === 'crontab' && row.run_via === 'crontab' && row.disabled_reason !== 'vanished');
     if (!declaredCron && !events.length && !matched.length) continue;
     if (!/^[a-zA-Z0-9][\w.-]*$/.test(doc.graph_id)) throw new Error(`unsafe loop graph_id: ${doc.graph_id}`);
     if (loops.some(loop => loop.id === doc.graph_id)) throw new Error(`duplicate loop graph_id: ${doc.graph_id}`);
@@ -142,6 +155,15 @@ export function loopStatus(id: string, opts: LoopRegistryOptions = {}): LoopEntr
   return { ...loop, recentRuns: recent };
 }
 
+/** The crontab line a loop runs — same shape as the other elanous crons: cron starts in $HOME with a thin PATH,
+ *  so a bare `elanous graph run <relative file>` fails silently every tick (09-29 steward). */
+export function loopCronCommand(id: string, file: string, root: string, bun = process.execPath): string {
+  // Quote only when needed: the other crons (and `graphJobMatches`) use bare absolute paths.
+  const q = (value: string) => /^[\w./@+-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+  const log = `/tmp/elanous-loop-${id.replace(/[^\w.-]/g, '_')}.log`;
+  return `cd ${q(root)} && ${q(bun)} bin/elanous.mjs graph run ${q(file)} >> ${log} 2>&1`;
+}
+
 export async function setLoopEnabled(id: string, enabled: boolean, yes = false, opts: LoopRegistryOptions = {}): Promise<unknown> {
   const loop = loopStatus(id, opts);
   const action = enabled ? 'start' : 'stop';
@@ -149,7 +171,7 @@ export async function setLoopEnabled(id: string, enabled: boolean, yes = false,
   const pending = loop.jobs.filter(job => job.enabled !== enabled);
   if (!pending.length && loop.jobs.length) return { action, id, changed: false, enabled: loop.enabled };
   const changes = loop.jobs.length ? pending.map(job => ({ action: enabled ? 'enable' : 'disable', id: job.id })) :
-    [{ action: 'create', cron: loop.trigger.cron, command: `elanous graph run ${loop.file}` }];
+    [{ action: 'create', cron: loop.trigger.cron, command: loopCronCommand(id, loop.file, resolve(opts.root ?? defaultLoopRoot())) }];
   if (!yes) return { action, id, dryRun: true, changes, note: 'Apply with --yes (crontab backup).' };
   const dispatch = opts.scheduleAction ?? (async (kind: 'create' | 'enable' | 'disable', args: Record<string, unknown>) => {
     const { dispatchScheduleManage } = await import('../domains/schedule-manage-tool.js');
@@ -170,5 +192,5 @@ export async function setLoopEnabled(id: string, enabled: boolean, yes = false,
 export async function runLoop(id: string, dryRun = false, opts: LoopRegistryOptions = {}): Promise<GraphRunState> {
   const loop = loopStatus(id, opts);
   debug.log('loops.registry', 'run', { id, dryRun });
-  return runGraph(join(resolve(opts.root ?? process.cwd()), loop.file), { dryRun, deps: { root: opts.stateRoot ?? effectiveInstanceRoot() } });
+  return runGraph(join(resolve(opts.root ?? defaultLoopRoot()), loop.file), { dryRun, deps: { root: opts.stateRoot ?? effectiveInstanceRoot() } });
 }

package/src/market/publish.ts

@@ -7,6 +7,41 @@ import { debug } from '../debug/log.js';
 import { packDirDeterministic } from './tgz.js';
 import { signIndex, verifyIndex, type MarketplaceIndex } from './signed-index.js';
 
+type IndexConnector = MarketplaceIndex['plugins'][number]['ai.elanous']['connectors'][number];
+
+function normalizeConnectors(connectors: unknown): { ok: true; value: IndexConnector[] } | { ok: false } {
+  if (!Array.isArray(connectors)) return { ok: false };
+  const value: IndexConnector[] = [];
+  const record = (item: unknown): item is Record<string, unknown> =>
+    item !== null && typeof item === 'object' && !Array.isArray(item);
+  for (const connector of connectors) {
+    if (!record(connector) || typeof connector.id !== 'string' || !connector.id) return { ok: false };
+    if (Array.isArray(connector.userConfig)) {
+      if (typeof connector.kind !== 'string' || !connector.userConfig.every((field: unknown) =>
+        record(field) && typeof field.key === 'string' && field.key.trim().length > 0 && typeof field.label === 'string' &&
+        typeof field.secret === 'boolean' && (field.env === undefined || typeof field.env === 'string'))) {
+        return { ok: false };
+      }
+      value.push(connector as IndexConnector);
+    } else if (Array.isArray(connector.fields)) {
+      if ((connector.kind !== undefined && typeof connector.kind !== 'string') || !connector.fields.every((field: unknown) =>
+        record(field) && typeof field.name === 'string' && field.name.trim().length > 0 && typeof field.secret === 'boolean' &&
+        (field.label === undefined || typeof field.label === 'string') &&
+        (field.env === undefined || typeof field.env === 'string'))) {
+        return { ok: false };
+      }
+      value.push({ id: connector.id, kind: (connector.kind ?? 'credentials') as string,
+        userConfig: connector.fields.map((field: Record<string, unknown>) => ({
+          key: field.name as string, label: (field.label ?? field.name) as string, secret: field.secret === true,
+          ...(field.env ? { env: field.env as string } : {}),
+        })) });
+    } else {
+      return { ok: false };
+    }
+  }
+  return { ok: true, value };
+}
+
 function unpackLocal(archive: Uint8Array, destination: string): void {
   const tar = gunzipSync(archive);
   const field = (part: Buffer) => part.toString('utf8').replace(/\0.*$/, '');
@@ -113,13 +148,15 @@ export function publishMarket(input: {
         skip('invalid-plugin.json'); continue;
       }
       const { category, bundle, ...metadata } = ai as MarketplaceIndex['plugins'][number]['ai.elanous'] & { category?: string; bundle?: unknown };
-      if (!Array.isArray(metadata.capabilities) || !Array.isArray(metadata.connectors) ||
+      if (!Array.isArray(metadata.capabilities) ||
           (category !== undefined && typeof category !== 'string')) {
         skip('invalid-plugin.json'); continue;
       }
       if (metadata.pricing !== undefined && metadata.pricing?.model !== 'free') {
         skip('paid-not-allowed-in-M0'); continue;
       }
+      const normalized = normalizeConnectors(metadata.connectors);
+      if (!normalized.ok) { skip('invalid-connectors'); continue; }
       const bundleItem = (item: unknown): item is string | { from: string; as: string } => typeof item === 'string' ||
         (!!item && typeof item === 'object' && !Array.isArray(item) && typeof (item as { from?: unknown }).from === 'string' &&
           typeof (item as { as?: unknown }).as === 'string');
@@ -208,7 +245,26 @@ export function publishMarket(input: {
         if (message.startsWith('bundle-conflict')) { skip('bundle-conflict'); continue; }
         throw error;
       }
-      const sha256 = createHash('sha256').update(archive).digest('hex');
+      let sha256 = createHash('sha256').update(archive).digest('hex');
+      const recorded = recordedHashes.get(JSON.stringify([manifest.name, manifest.version]));
+      if (recorded && recorded !== sha256) {
+        const existingPath = join(input.outDir, manifest.name, manifest.version, `${recorded}.tgz`);
+        let sameContent = false;
+        if (existsSync(existingPath)) {
+          try {
+            const existing = readFileSync(existingPath);
+            sameContent = createHash('sha256').update(existing).digest('hex') === recorded &&
+              gunzipSync(existing).equals(gunzipSync(archive));
+            if (sameContent) {
+              archive = existing;
+              sha256 = recorded;
+            }
+          } catch { /* An unreadable archive cannot prove immutability. */ }
+        }
+        if (!sameContent) throw new Error(`version-immutable: ${manifest.name}@${manifest.version}`);
+        debug.log('market.publish', 'reused-artifact', { name: manifest.name, version: manifest.version,
+          reason: 'same-content-different-gzip' });
+      }
       remember(manifest.name, manifest.version, sha256);
       const key = `${manifest.name}/${manifest.version}/${sha256}.tgz`;
       const source: MarketplaceIndex['plugins'][number]['source'] = input.source
@@ -218,7 +274,7 @@ export function publishMarket(input: {
         policy: { installation: 'AVAILABLE', authentication: 'ON_USE' },
         category: category ?? 'Productivity', version: manifest.version,
         description: manifest.description, artifact: { sha256, bytes: archive.length, key },
-        'ai.elanous': { ...metadata, pricing: metadata.pricing ?? { model: 'free' } },
+        'ai.elanous': { ...metadata, connectors: normalized.value, pricing: metadata.pricing ?? { model: 'free' } },
       });
       archives.push({ key, data: archive, name: dir });
       published.push({ name: manifest.name, version: manifest.version, sha256, bundled });

package/src/native-tool-catalog.ts

@@ -1142,8 +1142,8 @@ export const nativeToolCatalog: NativeToolCatalogEntry[] = [
     kind: 'web',
     aliases: ['WebSearch', 'web_search'],
     displayName: 'WebSearch',
-    description: 'Search the public web via a configured provider (Grok live-search / Firecrawl / MCP / custom).',
-    promptSummary: '`WebSearch` (provider-backed web search — Grok live-search by default; pair with WebFetch for full bodies)',
+    description: 'Search the public web via a configured provider (Grok live-search / Firecrawl / MCP / custom); when no key is available, fall back to keyless DuckDuckGo.',
+    promptSummary: '`WebSearch` (provider-backed web search — Grok live-search by default; when no key is available, fall back to keyless DuckDuckGo; pair with WebFetch for full bodies)',
     host: ['skill'],
     safety: ['network', 'read-only'],
     supportsParallel: true,

package/src/nexus/api/graph-approvals.ts

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync, readdirSync, type Dirent } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../../debug/log.js';
+import { decideGraphApproval, lastJsonObject, type GraphRunState } from '../../graph-runner/runner.js';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { jsonResponse } from './json-response.js';
+
+export const GRAPH_APPROVALS_PATH = '/v1/graph-approvals';
+const SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+interface GraphApprovalItem {
+  graphId: string;
+  runId: string;
+  nodeId: string;
+  message: string;
+  since: string;
+  path: string[];
+  recent: Array<{ nodeId: string; ok: boolean; outcome?: string; summary?: string }>;
+}
+
+interface GraphApprovalsDeps {
+  authorize?: (request: Request) => boolean;
+  /** Credential the request carries, checked independently of same-origin (`bearerCredential`).
+   * A decision needs a bearer token: same-origin alone is not trusted because behind
+   * `tailscale serve` every tailnet peer (Pod included) arrives from loopback. */
+  authReason?: (request: Request) => string | undefined;
+  root?: string;
+}
+
+const DECISION_AUTH_REASONS = new Set(['bearer-match', 'temp-token', 'noauth']);
+
+function validSegment(value: string): boolean {
+  return SEGMENT.test(value) && value !== '.' && value !== '..';
+}
+
+function readRun(root: string, graphId: string, runId: string): GraphRunState | null {
+  if (!validSegment(graphId) || !validSegment(runId)) return null;
+  try {
+    const state = JSON.parse(readFileSync(join(root, 'graph-runs', graphId, `${runId}.json`), 'utf8')) as GraphRunState;
+    return state.graphId === graphId && state.runId === runId ? state : null;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function undecided(state: GraphRunState, root: string): boolean {
+  return state.status === 'awaiting-approval' && !!state.pending && !state.pending.decision
+    && Array.isArray(state.path) && !existsSync(join(root, 'graph-runs', state.graphId, `${state.runId}.json.${state.path.length}.decision.json`));
+}
+
+function list(root: string): GraphApprovalItem[] {
+  const dir = join(root, 'graph-runs');
+  let graphs: Dirent[];
+  try { graphs = readdirSync(dir, { withFileTypes: true }); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  const items: GraphApprovalItem[] = [];
+  for (const graph of graphs) {
+    if (!graph.isDirectory() || !validSegment(graph.name)) continue;
+    for (const file of readdirSync(join(dir, graph.name), { withFileTypes: true })) {
+      if (!file.isFile() || !file.name.endsWith('.json') || file.name.endsWith('.decision.json')) continue;
+      const runId = file.name.slice(0, -5);
+      const state = readRun(root, graph.name, runId);
+      if (!state || !undecided(state, root) || !Array.isArray(state.nodes)) continue;
+      const pending = state.pending!;
+      items.push({
+        graphId: state.graphId, runId: state.runId, nodeId: pending.nodeId, message: pending.message,
+        since: pending.since, path: state.path,
+        recent: state.nodes.slice(-5).map((node) => {
+          const output = lastJsonObject(node.output);
+          return {
+            nodeId: node.nodeId, ok: node.ok,
+            ...(typeof output?.outcome === 'string' ? { outcome: output.outcome } : {}),
+            ...(typeof output?.summary === 'string' ? { summary: output.summary } : {}),
+          };
+        }),
+      });
+    }
+  }
+  return items.sort((a, b) => b.since.localeCompare(a.since));
+}
+
+export async function handleGraphApprovals(req: Request, deps: GraphApprovalsDeps = {}): Promise<Response> {
+  const pathname = new URL(req.url).pathname;
+  const match = /^\/v1\/graph-approvals\/([^/]+)\/([^/]+)$/.exec(pathname);
+  if (pathname !== GRAPH_APPROVALS_PATH && !match) return jsonResponse({ error: 'not-found' }, 404);
+  if (!deps.authorize?.(req)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (pathname === GRAPH_APPROVALS_PATH) {
+    if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    return jsonResponse({ items: list(deps.root ?? effectiveInstanceRoot()) });
+  }
+  if (req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
+  const authReason = deps.authReason?.(req);
+  if (!authReason || !DECISION_AUTH_REASONS.has(authReason)) {
+    debug.log('approvals.graph', 'refused', { reason: 'pairing-required', auth: authReason ?? null });
+    return jsonResponse({ error: 'pairing-required' }, 403);
+  }
+  let graphId: string;
+  let runId: string;
+  try { graphId = decodeURIComponent(match![1]!); runId = decodeURIComponent(match![2]!); }
+  catch { return jsonResponse({ error: 'not-found' }, 404); }
+  if (!validSegment(graphId) || !validSegment(runId)) return jsonResponse({ error: 'not-found' }, 404);
+  let body: unknown;
+  try { body = await req.json(); }
+  catch { return jsonResponse({ error: 'bad_request' }, 400); }
+  const decision = body && typeof body === 'object' && !Array.isArray(body) && 'decision' in body ? body.decision : undefined;
+  if (decision !== 'approved' && decision !== 'rejected') return jsonResponse({ error: 'bad_request' }, 400);
+  const root = deps.root ?? effectiveInstanceRoot();
+  const state = readRun(root, graphId, runId);
+  if (!state) return jsonResponse({ error: 'not-found' }, 404);
+  if (!undecided(state, root)) return jsonResponse({ error: 'already-decided' }, 409);
+  const nodeId = state.pending!.nodeId;
+  try {
+    decideGraphApproval(graphId, runId, decision, `pwa:${authReason}`, root);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return jsonResponse({ error: 'not-found' }, 404);
+    if (error instanceof Error && error.message.startsWith('run is not awaiting an undecided approval:')) return jsonResponse({ error: 'already-decided' }, 409);
+    throw error;
+  }
+  debug.log('approvals.graph', 'decided', { graphId, runId, nodeId, decision, by: `pwa:${authReason}` });
+  return jsonResponse({ graphId, runId, decision });
+}

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

@@ -17,6 +17,8 @@
 
 import type { TelegramEvent } from '../../workflow-runtime/triggers/telegram-source.js';
 import { spawnSync } from 'node:child_process';
+import { compareTokenConstTime } from '../../acp/transport/auth.js';
+import { ensureAuthToken } from '../../auth/acp-token.js';
 import type { NexusState } from '../state/state.js';
 import { DEFAULT_NEXUS_HTTP_PORT } from '../default-port.js';
 export { DEFAULT_NEXUS_HTTP_PORT } from '../default-port.js';
@@ -195,6 +197,7 @@ import { handleMcpResourceGet, MCP_RESOURCE_ROUTE_PATH } from './mcp-resource-ro
 // ⛔ 라우트 상수를 «디스패처»가 안 쓰고 문자열로 베끼고 있었다(16차 실측) — 잎에서 읽는다.
 import { APPROVALS_MERGES_PATH, DESIGN_DIRECTION_PATH, DESIGN_PREVIEW_PATH_PREFIX, DESIGN_PREVIEWS_PATH, DESIGN_SYSTEM_PATH, IPA_PATH_PREFIX, MANIFEST_PATH } from './rest-route-paths.js';
 import { handleMergeApprovals } from './merge-approvals.js';
+import { GRAPH_APPROVALS_PATH, handleGraphApprovals } from './graph-approvals.js';
 import { handleLiveDetail, LIVE_DETAIL_PATH } from './live-detail.js';
 import { handleLiveShipped, LIVE_SHIPPED_PATH } from './live-shipped.js';
 import { handleMcpWidgetCall, MCP_WIDGET_CALL_ROUTE_PATH, persistWidgetTurnToSessionStore } from './mcp-widget-call-route.js';
@@ -300,6 +303,7 @@ import {
   handleVoiceCost,
   handleVoiceTranscribe,
   checkAuth,
+  bearerCredential,
   registerAuthPeerAddress,
   type MetaApiOpts,
 } from './meta-api.js';
@@ -332,7 +336,10 @@ import { handleTriggersSnapshot } from './triggers.js';
 import { handleWorkflowTemplatesList } from './workflow-templates.js';
 import { handleGraphsGet, handleGraphsMutation } from './graphs-api.js';
 import { handleGraphKindsGet, handleGraphsValidatePost } from './graph-kinds.js';
-import { handlePluginsIndexGet, handlePluginsGet } from './plugins-market.js';
+import { syncInstalledPluginNodes } from '../../graph-kinds/installed-plugin-nodes.js';
+import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { handlePluginsIndexGet, handlePluginsGet, handlePluginsMarketRefresh, handlePluginsInstall, handlePluginsRemove } from './plugins-market.js';
+import { handlePluginsCredentialsGet, handlePluginsCredentialsPut } from './plugins-credentials-api.js';
 import {
   handleWorkflowsList,
 } from './workflows.js';
@@ -369,7 +376,7 @@ import {
   parseAgentCliSessionPath,
 } from './agent-cli.js';
 import { handleSessionTurnControl, SESSION_TURN_CONTROL_PATH } from '../../session/session-turn-control.js';
-import { authenticatePodCredential, handlePodGrokCredential, POD_CREDENTIAL_GROK_PATH } from './pod-credential-api.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 { handleSelfEvent } from './self-event.js';
 /** 매매 «실행»은 애드온이다(대표 09-20 결정 ③ · 별도 상용 저장소 · release/trading-export.yaml) — 공개 코어엔 없다.
@@ -436,6 +443,8 @@ export function probeNexusHttpPort(
 export type NexusWsBridgeInit = Omit<WsBridgeOpts, 'hostname' | 'port'>;
 
 export interface NexusHttpServerOpts {
+  /** Optional installer state root for isolated API consumers and tests. */
+  pluginStateRoot?: string;
   state: NexusState;
   registry: TabRegistry;
   eventBus: NexusEventBus;
@@ -822,19 +831,27 @@ export async function routeRequest(
   // Per-route checkAuth calls below stay in place.
   // OPTIONS is a CORS preflight and cannot carry Authorization; existing
   // handlers answer it themselves, so the gate does not swallow it.
+  // A runtime-less tab mutation still needs authentication before the
+  // dispatcher can return its 503. Do not enable this fallback for other paths.
+  const runtimeLessTabMutation = !opts.metaApi && method !== 'GET' && method !== 'OPTIONS'
+    && (pathname === '/v1/nexus/tabs' || pathname.startsWith('/v1/nexus/tabs/'));
   if (
     method !== 'OPTIONS'
     && pathname.startsWith('/v1/')
     && !isPublicRoute(method, pathname, { setupMode: false })
   ) {
-    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) {
+    const fallbackToken = runtimeLessTabMutation ? ensureAuthToken().token : undefined;
+    const offered = req.headers.get('authorization');
+    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
         ? matchIngestAuthorization(req)?.name
         : undefined;
       if (name === undefined) {
         debug.log('nexus.auth', 'default-deny', { method, pathname });
         // MCP 클라이언트(Claude Code)에게는 «할 일»을 말한다 — 안 그러면 OAuth 로 가서 /register 405 를 만난다.
-        if (pathname === '/v1/mcp') return mcpUnauthorizedResponse();
+        if (pathname === '/v1/mcp') return mcpUnauthorizedResponse(new URL(req.url).origin);
         return jsonResponse({ error: 'unauthorized' }, 401);
       }
       debug.log('nexus.auth', 'ingest-token', { name, pathname });
@@ -843,7 +860,7 @@ export async function routeRequest(
   // OAuth 동적 클라이언트 등록(RFC 7591) — Elanous 는 OAuth 를 쓰지 않는다. 405 대신 «이렇게 등록하라»를 돌려준다.
   if (method === 'POST' && pathname === '/register') {
     debug.log('nexus.auth', 'oauth-register-rejected', { pathname });
-    return oauthRegistrationRejected();
+    return oauthRegistrationRejected(new URL(req.url).origin);
   }
 
   // FU2 (2026-05-12) — root-level browser conveniences. The PWA serves
@@ -899,6 +916,12 @@ export async function routeRequest(
     });
   }
 
+  if (pathname === GRAPH_APPROVALS_PATH || pathname.startsWith(`${GRAPH_APPROVALS_PATH}/`)) {
+    return handleGraphApprovals(req, {
+      authorize: (request) => !!opts.metaApi && checkAuth(request, opts.metaApi),
+      authReason: (request) => (opts.metaApi ? bearerCredential(request, opts.metaApi) : undefined),
+    });
+  }
   if (pathname === APPROVALS_MERGES_PATH || pathname.startsWith(`${APPROVALS_MERGES_PATH}/`)) {
     return handleMergeApprovals(req, {
       authorize: (request) => !!opts.metaApi && checkAuth(request, opts.metaApi),
@@ -1189,6 +1212,25 @@ export async function routeRequest(
   // Templates POST handled here too (PR κ).
   // Config / secrets PUT/POST/DELETE here too (PR μ).
   if (method !== 'GET') {
+    if (method === 'POST' && pathname === '/v1/plugins/install') {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginsInstall(req, opts.metaApi, opts.pluginStateRoot);
+    }
+    const marketRefresh = /^\/v1\/plugins\/markets\/([^/]+)\/refresh$/.exec(pathname);
+    if (method === 'POST' && marketRefresh) {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginsMarketRefresh(req, marketRefresh[1]!, opts.metaApi, { root: opts.pluginStateRoot });
+    }
+    const pluginCredentials = /^\/v1\/plugins\/([^/]+)\/credentials$/.exec(pathname);
+    if (method === 'PUT' && pluginCredentials) {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginsCredentialsPut(req, pluginCredentials[1]!, opts.metaApi, opts.pluginStateRoot, opts.reloadMcpClients);
+    }
+    const pluginRemove = /^\/v1\/plugins\/([^/]+)$/.exec(pathname);
+    if (method === 'DELETE' && pluginRemove) {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginsRemove(req, pluginRemove[1]!, opts.metaApi, opts.pluginStateRoot);
+    }
     if ((method === 'PUT' || method === 'POST') && pathname.startsWith('/v1/graphs/')) {
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
       if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -1215,6 +1257,11 @@ export async function routeRequest(
       if (!gate.ok) return gate.response;
       return handlePodGrokCredential(req);
     }
+    if (pathname === POD_CREDENTIAL_GITHUB_PATH && method === 'POST') {
+      const gate = await authenticatePodCredential(req, {}, 'gh-credential');
+      if (!gate.ok) return gate.response;
+      return handlePodGithubCredential(req);
+    }
     if (pathname === '/v1/harness/ask' && method === 'POST') {
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-runtime-not-wired' }, 503);
       if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -2431,12 +2478,19 @@ export async function routeRequest(
   // surface (`/v1/workflows` · `~/.elanous/workflows-runs/`) covers the same
   // user need.
 
+  const pluginCredentialsGet = /^\/v1\/plugins\/([^/]+)\/credentials$/.exec(pathname);
+  if (method === 'GET' && pluginCredentialsGet) {
+    if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handlePluginsCredentialsGet(req, pluginCredentialsGet[1]!, opts.metaApi, opts.pluginStateRoot);
+  }
   if (method === 'GET' && (pathname === '/v1/plugins/index' || pathname === '/v1/plugins')) {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
-    return pathname === '/v1/plugins/index' ? handlePluginsIndexGet(req, opts.metaApi) : handlePluginsGet(req, opts.metaApi);
+    return pathname === '/v1/plugins/index' ? handlePluginsIndexGet(req, opts.metaApi, opts.pluginStateRoot) : handlePluginsGet(req, opts.metaApi, opts.pluginStateRoot);
   }
   if (method === 'GET' && pathname === '/v1/graph/kinds') {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    try { syncInstalledPluginNodes(opts.pluginStateRoot ?? elanousStateRoot()); }
+    catch (error) { debug.log('graph.kinds', 'installed-sync-failed', { reason: String(error) }); }
     return handleGraphKindsGet(req, opts.metaApi);
   }
   // F-M1 read + P-F1 raw YAML. Writes live in the mutation block and never touch core graphs/.

package/src/nexus/api/log-fabric.ts

@@ -301,6 +301,15 @@ export function activeStoreNames(deps: LogFabricDeps, nowMs = Date.now()): strin
   return names;
 }
 
+/** 등록된 로그 저장소 수(이 인스턴스 ⊕ logs.db 가 있는 우주) — `@active` 가 연 수의 «분모». 못 세면 `null`(0 으로 접지 않는다). */
+export function registeredLogStoreCount(deps: Pick<LogFabricDeps, 'instances'> = {}): number | null {
+  try {
+    const names = new Set((deps.instances ?? readLogInstances)().filter((view) => view.dbExists).map((view) => view.name));
+    names.add(resolveLogInstanceName());
+    return names.size;
+  } catch { return null; }
+}
+
 export function handleLogsQuery(req: Request, opts: MetaApiOpts, deps: LogFabricDeps = {}): Response {
   if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
   const url = new URL(req.url);
@@ -374,7 +383,7 @@ export function handleLogsQuery(req: Request, opts: MetaApiOpts, deps: LogFabric
     ts: new Date().toISOString(),
     ...(failedStores.length ? { failedStores } : {}),
     ...(selection.storeLimitReached ? { storeLimitReached: true } : {}),
-    ...(activeStores ? { stores: activeStores } : {}),
+    ...(activeStores ? { stores: activeStores, registeredStores: registeredLogStoreCount(deps) } : {}),
   }, 200);
 }