elanous 0.2.5 → 0.2.6

package/src/nexus/api/harness-api.ts

@@ -1,5 +1,7 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { relative } from 'node:path';
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { hasTerminalRunStatus, loadRunLedger, runLedgerDir, runLedgerPath, type RunLedgerEntry } from '../../self-implement/run-ledger.js';
+import { summarizeTerminalLedger } from '../../self-implement/run-ledger-compact.js';
 import { debug } from '../../debug/log.js';
 import { enqueueSoftStop } from '../../harness/control-inbox.js';
 import { listHarnessScreens, readHarnessScreenTail } from '../../harness/harness-screen.js';
@@ -103,6 +105,10 @@ export interface HarnessApiDeps {
   readonly createAcceptanceId?: () => string;
   readonly log?: (event: string, data: Record<string, unknown>) => void;
   readonly createFeedbackEmitter?: (acceptanceId: string) => (env: FeedbackEnvelope) => void | Promise<void>;
+  /** 시험 심 — `?finishedSince=` 가 읽는 원장 디렉터리(기본 `runLedgerDir()`). */
+  readonly ledgerDir?: string;
+  /** 시험 심 — `?finishedSince=` 의 `landed`(gh 실행기·저장소·시간 초과). */
+  readonly landed?: LandedPrsDeps;
 }
 
 function json(body: unknown, status = 200): Response {
@@ -338,10 +344,218 @@ export function handleHarnessAskStatusGet(req: Request, _metaApi: HarnessMetaApi
   });
 }
 
-/** Return the structured shared running-runs observation without human rendering. */
-export function handleHarnessRunsGet(_req: Request, _metaApi: HarnessMetaApi, deps: HarnessApiDeps = {}): Response {
+/** One terminated run for `GET /v1/harness/runs?finishedSince=` (iPhone «오늘 끝난 일» · 2026-09-30). */
+export interface HarnessFinishedRun {
+  runId: string;
+  status: string;
+  endedAt: string;
+  /** 마지막 `run-status` 의 `stage`(예: `merged`·`pr-declined`) — 칩을 더 정확히 고를 때. */
+  stage?: string;
+  objective?: string;
+  prUrl?: string;
+  /** `merged` 이벤트의 값 — 이벤트가 없으면 칸이 없다(«병합 안 됨»으로 접지 않는다). */
+  merged?: boolean;
+  /** 마지막 `merge-decision` 의 `decision`(`auto`·`hitl`) — 병합 «결정»이지 병합 «사실»이 아니다. */
+  mergeDecision?: string;
+}
+
+export const FINISHED_RUNS_LIMIT = 20;
+export const FINISHED_RUNS_MAX_FILES = 300;
+export const FINISHED_RUNS_MAX_FILE_BYTES = 5 * 1024 * 1024;
+const FINISHED_OBJECTIVE_MAX_CHARS = 160;
+
+/**
+ * 원장 디렉터리에서 `sinceMs` 이후에 쓰인 «끝난» 런을 요약한다. 읽기는 묶여 있다 —
+ * mtime 최신 {@link FINISHED_RUNS_MAX_FILES} 개만 보고, {@link FINISHED_RUNS_MAX_FILE_BYTES} 를 넘는 파일은 건너뛴다.
+ */
+export function collectFinishedRuns(dir: string, sinceMs: number): { runs: HarnessFinishedRun[]; scannedFiles: number; skippedFiles: number } {
+  let names: string[];
+  try { names = readdirSync(dir); }
+  catch { return { runs: [], scannedFiles: 0, skippedFiles: 0 }; }
+  const candidates: Array<{ runId: string; mtimeMs: number; size: number }> = [];
+  for (const name of names) {
+    if (!name.endsWith('.jsonl')) continue;
+    try {
+      const st = statSync(join(dir, name));
+      if (st.isFile() && st.mtimeMs >= sinceMs) candidates.push({ runId: name.slice(0, -'.jsonl'.length), mtimeMs: st.mtimeMs, size: st.size });
+    } catch { /* 사이에 지워졌다 */ }
+  }
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const scanned = candidates.slice(0, FINISHED_RUNS_MAX_FILES);
+  let skippedFiles = candidates.length - scanned.length;
+  const runs: HarnessFinishedRun[] = [];
+  for (const file of scanned) {
+    if (file.size > FINISHED_RUNS_MAX_FILE_BYTES) { skippedFiles += 1; continue; }
+    let entries: RunLedgerEntry[] | null;
+    try { entries = loadRunLedger(file.runId, dir); }
+    catch { skippedFiles += 1; continue; }
+    if (!entries?.length || !hasTerminalRunStatus(entries)) continue;
+    let summary: ReturnType<typeof summarizeTerminalLedger>;
+    try { summary = summarizeTerminalLedger(file.runId, entries); }
+    catch { skippedFiles += 1; continue; }
+    if (!(Date.parse(summary.endedAt) >= sinceMs)) continue;
+    const feature = entries.find((entry) => entry.event === 'start' && typeof entry.data.feature === 'string')?.data.feature as string | undefined;
+    const objective = feature?.trim().slice(0, FINISHED_OBJECTIVE_MAX_CHARS);
+    const mergedEvent = [...entries].reverse().find((entry) => entry.event === 'merged' && typeof entry.data.merged === 'boolean');
+    const decision = [...entries].reverse().find((entry) => entry.event === 'merge-decision' && typeof entry.data.decision === 'string');
+    const statusEntry = [...entries].reverse().find((entry) => entry.event === 'run-status' && typeof entry.data.stage === 'string');
+    runs.push({
+      runId: summary.runId,
+      status: summary.status,
+      endedAt: summary.endedAt,
+      ...(statusEntry ? { stage: statusEntry.data.stage as string } : {}),
+      ...(objective ? { objective } : {}),
+      ...(summary.prUrl ? { prUrl: summary.prUrl } : {}),
+      ...(mergedEvent ? { merged: mergedEvent.data.merged as boolean } : {}),
+      ...(decision ? { mergeDecision: decision.data.decision as string } : {}),
+    });
+  }
+  runs.sort((a, b) => Date.parse(b.endedAt) - Date.parse(a.endedAt));
+  return { runs: runs.slice(0, FINISHED_RUNS_LIMIT), scannedFiles: scanned.length, skippedFiles };
+}
+
+/** 도는 런의 목표 — 그 런 원장의 첫 `start.data.feature`(≤160자). 원장 경로는 그 항목이 준 디렉터리들만 본다(런 수만큼만 읽는다). */
+export function runObjectiveFromLedgers(runId: string, directories: readonly string[]): string | undefined {
+  for (const dir of directories) {
+    try {
+      if (statSync(runLedgerPath(runId, dir)).size > FINISHED_RUNS_MAX_FILE_BYTES) continue;
+      const feature = loadRunLedger(runId, dir)?.find((entry) => entry.event === 'start' && typeof entry.data.feature === 'string')?.data.feature;
+      const objective = typeof feature === 'string' ? feature.trim().slice(0, FINISHED_OBJECTIVE_MAX_CHARS) : '';
+      if (objective) return objective;
+    } catch { /* 없거나 못 읽음 — 다음 디렉터리 */ }
+  }
+  return undefined;
+}
+
+// ── 오늘 착지(= main 에 병합된 PR) — 원장은 Pod·시험 우주의 런을 못 보므로 GitHub 이 정본이다 ──
+
+/** `landed` 한 줄 — `gh pr list --json number,title,url,mergedAt` 모양 그대로. */
+export interface HarnessLandedPr {
+  number: number;
+  title: string;
+  url: string;
+  mergedAt: string;
+}
+
+export const LANDED_PRS_LIMIT = 30;
+export const LANDED_PRS_TIMEOUT_MS = 4_000;
+const LANDED_CACHE_MS = 60_000;
+const landedCache = new Map<string, { at: number; prs: HarnessLandedPr[]; truncated: boolean }>();
+let cachedRepoSlug: string | null | undefined;
+
+export function _resetLandedPrsCacheForTest(): void {
+  landedCache.clear();
+  cachedRepoSlug = undefined;
+}
+
+export interface LandedPrsDeps {
+  /** gh 실행기(기본 = `git-fs/gh-cli` 의 재시도 게이트웨이 · 비동기). */
+  readonly runGh?: (args: string[]) => Promise<{ ok: boolean; exitCode: number; stdout: Buffer | string; stderr: Buffer | string }>;
+  /** 저장소 `owner/name` — 기본은 데몬이 아는 저장소 뿌리(`harness.defaultRepo` → cwd)의 origin. */
+  readonly repoSlug?: () => Promise<string | null>;
+  readonly timeoutMs?: number;
+  readonly now?: () => number;
+}
+
+async function defaultRepoSlug(): Promise<string | null> {
+  if (cachedRepoSlug !== undefined) return cachedRepoSlug;
+  const [{ resolveWorktreesRepoRoot }, { slugFromRemote }] = await Promise.all([import('./worktrees.js'), import('./live-shipped.js')]);
+  const root = resolveWorktreesRepoRoot();
+  if (!root) return (cachedRepoSlug = null);
+  const proc = Bun.spawn(['git', '-C', root, 'remote', 'get-url', 'origin'], { stdout: 'pipe', stderr: 'ignore' });
+  const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+  return (cachedRepoSlug = code === 0 ? slugFromRemote(out) : null);
+}
+
+async function defaultRunGh(args: string[]) {
+  const { runGhCliWithResultAsync } = await import('../../git-fs/gh-cli.js');
+  return runGhCliWithResultAsync(args);
+}
+
+function isLandedPr(value: unknown): value is HarnessLandedPr {
+  const v = value as Partial<HarnessLandedPr> | null;
+  return !!v && typeof v.number === 'number' && typeof v.title === 'string' && typeof v.url === 'string' && typeof v.mergedAt === 'string';
+}
+
+/** `sinceMs` 이후 main 에 병합된 PR(최신순 ≤30). 실패·시간 초과는 던지지 않고 `error` 로 돌려준다. 성공만 60초 캐시한다. */
+export async function listLandedPrs(sinceMs: number, deps: LandedPrsDeps = {}): Promise<{ prs: HarnessLandedPr[]; error?: string; cached?: boolean; truncated?: boolean }> {
+  const now = deps.now?.() ?? Date.now();
+  const sinceIso = new Date(Math.floor(sinceMs / 60_000) * 60_000).toISOString().replace(/\.\d{3}Z$/, 'Z');
+  const hit = landedCache.get(sinceIso);
+  if (hit && now - hit.at < LANDED_CACHE_MS) return { prs: hit.prs, cached: true, ...(hit.truncated ? { truncated: true } : {}) };
+  const timeoutMs = deps.timeoutMs ?? LANDED_PRS_TIMEOUT_MS;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<{ prs: HarnessLandedPr[]; error: string }>((resolve) => {
+    timer = setTimeout(() => resolve({ prs: [], error: `timeout ${timeoutMs}ms` }), timeoutMs);
+  });
+  const work = (async (): Promise<{ prs: HarnessLandedPr[]; error?: string; truncated?: boolean }> => {
+    try {
+      const slug = await (deps.repoSlug ?? defaultRepoSlug)();
+      if (!slug) return { prs: [], error: 'no-repository' };
+      const result = await (deps.runGh ?? defaultRunGh)([
+        'pr', 'list', '--repo', slug, '--state', 'merged', '--base', 'main',
+        '--search', `merged:>=${sinceIso}`,
+        '--json', 'number,title,url,mergedAt', '--limit', String(LANDED_PRS_LIMIT),
+      ]);
+      if (!result.ok) {
+        const stderr = String(result.stderr).trim().split('\n')[0] ?? '';
+        return { prs: [], error: `gh failed rc=${result.exitCode}${stderr ? `: ${redactSecretText(stderr).slice(0, 120)}` : ''}` };
+      }
+      const parsed: unknown = JSON.parse(String(result.stdout));
+      if (!Array.isArray(parsed)) return { prs: [], error: 'gh returned non-array' };
+      const prs = parsed.filter(isLandedPr)
+        .filter((pr) => Date.parse(pr.mergedAt) >= sinceMs)
+        .sort((a, b) => Date.parse(b.mergedAt) - Date.parse(a.mergedAt));
+      // gh 가 상한만큼 줬으면 더 있을 수 있다 — «전부»라고 말하지 않는다.
+      const truncated = parsed.length >= LANDED_PRS_LIMIT;
+      landedCache.set(sinceIso, { at: now, prs, truncated });
+      return { prs, ...(truncated ? { truncated: true } : {}) };
+    } catch (error) {
+      return { prs: [], error: message(error).slice(0, 120) };
+    }
+  })();
+  try {
+    return await Promise.race([work, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+/** Return the structured shared running-runs observation without human rendering.
+ *  `?finishedSince=<epoch ms>` 가 있으면(iPhone «오늘» · 2026-09-30) 셋을 더한다 —
+ *  `finished`(이 우주 원장의 끝난 런 · 최신순 ≤20) · `landed`(그 시각 뒤 main 에 병합된 PR · ≤30 · 실패면 `[]` ⊕ `landedError`) ·
+ *  도는 항목마다 `objective`(그 런 원장의 `start.feature`). 없으면 응답은 종전 그대로다(동기 응답). */
+export function handleHarnessRunsGet(req: Request, _metaApi: HarnessMetaApi, deps: HarnessApiDeps = {}): Response | Promise<Response> {
   const runs: RunningRunsResult = (deps.queryRunningRuns ?? queryRunningRuns)({ includeTest: false });
-  return json(runs);
+  const raw = new URL(req.url).searchParams.get('finishedSince');
+  if (raw === null) return json(runs);
+  const sinceMs = Number(raw);
+  if (!raw.trim() || !Number.isFinite(sinceMs) || sinceMs < 0) {
+    return json({ error: 'usage: GET /v1/harness/runs?finishedSince=<epoch ms>' }, 400);
+  }
+  return (async () => {
+    const landedWork = listLandedPrs(sinceMs, deps.landed ?? {});
+    const dir = deps.ledgerDir ?? runLedgerDir();
+    const finished = collectFinishedRuns(dir, sinceMs);
+    const entries = runs.entries.map((entry) => {
+      const objective = runObjectiveFromLedgers(entry.runId, entry.ledgerDirectories?.length ? entry.ledgerDirectories : [dir]);
+      return objective ? { ...entry, objective } : entry;
+    });
+    const landed = await landedWork;
+    debug.log('harness-http', 'runs-finished', {
+      sinceMs, count: finished.runs.length, scannedFiles: finished.scannedFiles, skippedFiles: finished.skippedFiles,
+      landed: landed.prs.length, landedCached: landed.cached === true, ...(landed.error ? { landedError: landed.error } : {}),
+    });
+    return json({
+      ...runs,
+      entries,
+      finished: finished.runs,
+      finishedObservation: { sinceMs, scannedFiles: finished.scannedFiles, skippedFiles: finished.skippedFiles, limit: FINISHED_RUNS_LIMIT },
+      landed: landed.prs,
+      ...(landed.truncated ? { landedTruncated: true } : {}),
+      ...(landed.error ? { landedError: landed.error } : {}),
+    });
+  })();
 }
 
 /** Return the human-readable skeleton events persisted for one harness run. */

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

@@ -198,6 +198,7 @@ import { handleMcpResourceGet, MCP_RESOURCE_ROUTE_PATH } from './mcp-resource-ro
 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 { FIELD_SERVER_MAX_BODY_BYTES, FIELD_UPLOADS_PATH, handleFieldUploads } from './field-uploads.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';
@@ -739,6 +740,8 @@ export function startNexusHttpServer(opts: NexusHttpServerOpts): NexusHttpServer
         port,
         hostname,
         idleTimeout: 255,
+        // Bun 기본 128 MB 로는 현장 업로드(파일 200 MB · 요청 500 MB · JSON base64)가 못 들어온다.
+        maxRequestBodySize: FIELD_SERVER_MAX_BODY_BYTES,
         fetch: async (req: Request, srv: unknown) =>
           (await routeRequest(req, opts, srv as BunServerLike, bridge, devProxyRef, { hostname, port })) ??
           new Response(null, { status: 101 }),
@@ -922,6 +925,12 @@ export async function routeRequest(
       authReason: (request) => (opts.metaApi ? bearerCredential(request, opts.metaApi) : undefined),
     });
   }
+  // 현장 업로드(owner 전용) — GET 목록 · POST 저장. 저장 규칙 정본 = src/field/field-media.ts.
+  if (pathname === FIELD_UPLOADS_PATH && (method === 'GET' || method === 'POST')) {
+    return handleFieldUploads(req, {
+      authorize: (request) => !!opts.metaApi && checkAuth(request, opts.metaApi),
+    });
+  }
   if (pathname === APPROVALS_MERGES_PATH || pathname.startsWith(`${APPROVALS_MERGES_PATH}/`)) {
     return handleMergeApprovals(req, {
       authorize: (request) => !!opts.metaApi && checkAuth(request, opts.metaApi),

package/src/notify/llm-budget-alert.ts

@@ -0,0 +1,119 @@
+// NT1 — LLM 예산 알림 «모양» (UX · 대표 2026-09-30 22:30 재요청 · OP 결정 B6 ⊕ NT1).
+// 숫자·정책은 TC 의 B6 로더가 채운다(`내부 문서 `RFC-llm-policy-single-file-2026-09-30``) — 이 파일은 문구만 정한다.
+//
+// 규칙 셋(대표 가 받은 알림이 어긴 것들):
+//   ① 한 알림 = 한 결정·한 행동 — 맨 윗줄이 «무엇이 바뀌었나», 마지막 줄이 «할 일».
+//   ② 바뀐 게 없으면 침묵 — 같은 상태(key)면 send=false.
+//   ③ 모순 금지 — «한도 참»과 «크레딧으로 진행 중»을 한 알림에 같이 쓰지 않는다. 상태 하나만 고른다.
+//   ⊕ 내부 낱말 0 — «자»·«판정»·계정 내부 이름 나열을 쓰지 않는다(계정은 «계정 N개»로 센다).
+
+export interface LlmBudgetAccount {
+  name: string;
+  /** 구독 잔량 %(0~100). 모르면 undefined. */
+  subscriptionRemainingPct?: number;
+  /** 이 계정의 크레딧 잔액. */
+  credits?: number;
+  resetInHours?: number;
+}
+
+export interface LlmBudgetSnapshot {
+  /** ISO 시각(Asia/Seoul 로 날짜를 자른다). */
+  at: string;
+  credits: {
+    total: number;
+    usedToday: number;
+    /** 하루 목표 소진량(정책 `credits.pace`). */
+    paceTarget: number;
+    /** ISO 날짜 — 크레딧이 사라지는 날. */
+    expiresAt?: string;
+    /** 정책이 «크레딧 먼저»인가(`until` 전). */
+    useFirst?: boolean;
+  };
+  accounts: LlmBudgetAccount[];
+  selected: { account?: string; reason: 'subscription' | 'credits' | 'fallback' | 'none' };
+  fallback?: { provider: string; remainingPct?: number };
+}
+
+export interface LlmBudgetAlert {
+  send: boolean;
+  /** 상태 열쇠 — 다음 호출의 prevKey 로 넘긴다. */
+  key: string;
+  text: string;
+}
+
+const EXPIRY_WARN_DAYS = 7;
+/** 이 시각(서울) 뒤에야 «오늘 페이스가 느리다»를 말한다 — 아침에 0 인 건 정상이다. */
+const PACE_CHECK_HOUR = 18;
+
+const n = (v: number) => Math.round(v).toLocaleString('ko-KR');
+
+function seoulParts(iso: string): { date: string; hour: number } {
+  const d = new Date(iso);
+  const f = new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', hourCycle: 'h23' });
+  const p = Object.fromEntries(f.formatToParts(d).map((x) => [x.type, x.value]));
+  return { date: `${p.year}-${p.month}-${p.day}`, hour: Number(p.hour) };
+}
+
+function daysBetween(fromIso: string, toIso: string): number {
+  const a = Date.parse(seoulParts(fromIso).date);
+  const b = Date.parse(seoulParts(toIso).date);
+  return Math.round((b - a) / 86_400_000);
+}
+
+function mmdd(iso: string): string {
+  const { date } = seoulParts(iso);
+  return `${date.slice(5, 7)}-${date.slice(8, 10)}`;
+}
+
+function creditsLine(s: LlmBudgetSnapshot): string {
+  const parts = [`오늘 ${n(s.credits.usedToday)} / 목표 ${n(s.credits.paceTarget)}`, `남은 크레딧 ${n(s.credits.total)}`];
+  if (s.credits.expiresAt) parts.push(`${mmdd(s.credits.expiresAt)} 만료`);
+  return parts.join(' · ');
+}
+
+/** 지금 상태 하나를 고른다(위에서부터 먼저 맞는 것). 아무것도 아니면 침묵. */
+export function buildLlmBudgetAlert(now: LlmBudgetSnapshot, prevKey?: string): LlmBudgetAlert {
+  const { date, hour } = seoulParts(now.at);
+  const accounts = now.accounts.length;
+  let key = 'ok';
+  let lines: string[] = [];
+
+  const expiryDays = now.credits.expiresAt ? daysBetween(now.at, now.credits.expiresAt) : undefined;
+
+  if (now.selected.reason === 'none') {
+    key = 'blocked';
+    lines = [
+      '⛔ LLM 을 쓸 곳이 없어 작업이 멈췄습니다.',
+      `구독 계정 ${accounts}개 한도 · 크레딧·대체 모델도 못 씁니다.`,
+      '할 일: 크레딧 사용을 허락하거나 대체 모델 키를 확인해 주세요.',
+    ];
+  } else if (now.selected.reason === 'fallback' && now.fallback) {
+    const soonest = now.accounts.map((a) => a.resetInHours).filter((h): h is number => typeof h === 'number').sort((a, b) => a - b)[0];
+    key = `fallback:${now.fallback.provider}`;
+    lines = [
+      `⚠️ codex 를 못 써서 ${now.fallback.provider} 로 일하고 있습니다${typeof now.fallback.remainingPct === 'number' ? `(남은 ${Math.round(now.fallback.remainingPct)}%)` : ''}.`,
+      soonest !== undefined ? `codex 는 ${Math.ceil(soonest)}시간 뒤 돌아옵니다.` : 'codex 가 언제 돌아오는지 아직 모릅니다.',
+      '할 일: 없음 — 참고만 하세요.',
+    ];
+  } else if (expiryDays !== undefined && expiryDays <= EXPIRY_WARN_DAYS && now.credits.total > 0) {
+    key = `expiry:${Math.max(0, expiryDays)}`;
+    lines = [
+      `💳 크레딧 ${n(now.credits.total)} 이 ${expiryDays <= 0 ? '오늘' : `${expiryDays}일 뒤`} 사라집니다.`,
+      creditsLine(now),
+      '할 일: 무거운 작업을 지금 맡기면 크레딧으로 돕니다.',
+    ];
+  } else if (now.credits.useFirst && now.credits.total > 0 && hour >= PACE_CHECK_HOUR && now.credits.usedToday < now.credits.paceTarget * 0.5) {
+    // 하루 한 번만 — 날짜를 열쇠에 넣는다.
+    key = `pace-behind:${date}`;
+    lines = [
+      now.selected.reason === 'credits'
+        ? '💳 크레딧을 먼저 쓰는 중인데 오늘 쓴 양이 목표의 절반이 안 됩니다.'
+        : '💳 크레딧을 먼저 쓰라는 방침인데 오늘은 구독 계정이 먼저 쓰였습니다.',
+      creditsLine(now),
+      now.selected.reason === 'credits' ? '할 일: 없음 — 맡긴 일이 적었던 날입니다.' : '할 일: 없음 — 기술 담당이 순서를 고치는 중입니다.',
+    ];
+  }
+
+  const send = key !== 'ok' && key !== prevKey;
+  return { send, key, text: lines.join('\n') };
+}

package/src/plugins/maker/plugin-maker.ts

@@ -0,0 +1,208 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { debug } from '../../debug/log.js';
+import { runGraph } from '../../graph-runner/runner.js';
+import { parseGraphTemplateYaml } from '../../self-implement/graph-yaml.js';
+import { installPlugin } from '../install/plugin-install.js';
+
+const CAPABILITIES = ['fs:workdir', 'proc:bun', 'proc:elanous'];
+const isRecord = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+export interface MakePluginDeps {
+  codex: (dir: string, prompt: string) => Promise<void>;
+  install?: typeof installPlugin;
+  runGraph?: typeof runGraph;
+}
+export interface MakePluginOptions {
+  request: string;
+  name?: string;
+  parentDir?: string;
+  run?: boolean;
+  input?: unknown;
+  deps?: MakePluginDeps;
+}
+export interface MakePluginResult {
+  status: 'installed' | 'ran' | 'failed';
+  dir: string;
+  plugin: string;
+  graph: string;
+  errors: string[];
+  runStatus?: Awaited<ReturnType<typeof runGraph>>['status'];
+  timings: { scaffold: number; write: number; validate: number; repair?: number; install: number; run?: number };
+}
+
+export async function codexWrite(dir: string, prompt: string): Promise<void> {
+  const child = Bun.spawn(['codex', 'exec', '-C', dir, '-s', 'workspace-write', '--skip-git-repo-check', '-o', join(dir, '.codex-last-message.txt'), prompt], {
+    cwd: dir, stdin: 'ignore', stdout: 'ignore', stderr: 'pipe',
+  });
+  const [code, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+  if (code !== 0) throw new Error(`codex exec failed (${code}): ${stderr.trim().slice(0, 500)}`);
+}
+
+function scaffold(dir: string, slug: string, request: string): void {
+  mkdirSync(join(dir, 'graphs'));
+  mkdirSync(join(dir, 'examples'));
+  writeFileSync(join(dir, 'plugin.json'), JSON.stringify({ name: slug, version: '0.1.0', description: request,
+    extensions: { 'ai.elanous': { graphs: [`./graphs/${slug}.yaml`], capabilities: CAPABILITIES } } }, null, 2) + '\n');
+  writeFileSync(join(dir, 'graphs', `${slug}.yaml`), `graph_id: ${slug}\nversion: 1\nentry_node: main\nterminal_nodes: [done, failed]\nnodes:\n  - { node_id: main, kind: agent, recipe: 'cmd:main', max_visits: 1 }\n  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }\n  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }\nedges:\n  - { from: main, on: outcome, map: { ok: done, fail: failed } }\n`);
+  writeFileSync(join(dir, 'graphs', 'recipes.yaml'), `main:\n  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" main'\n  timeout_ms: 120000\n`);
+  writeFileSync(join(dir, 'graphs', 'run-step.ts'), `import { readFileSync } from 'node:fs';\nconst context = JSON.parse(readFileSync(process.env.ELANOUS_GRAPH_CONTEXT!, 'utf8'));\nconsole.log(JSON.stringify({ outcome: 'ok', input: context.input }));\n`);
+  writeFileSync(join(dir, 'examples', 'input.json'), '{}\n');
+  writeFileSync(join(dir, 'README.md'), `# ${slug}\n\n${request}\n\nRun the installed graph with examples/input.json as input. No messages are sent.\n`);
+}
+
+function inside(dir: string, path: string): string | undefined {
+  const full = resolve(dir, path);
+  return full.startsWith(`${dir}${sep}`) ? full : undefined;
+}
+
+function realTarget(path: string): string {
+  let ancestor = path;
+  while (!existsSync(ancestor)) {
+    const next = dirname(ancestor);
+    if (next === ancestor) throw new Error(`cannot resolve plugin directory: ${path}`);
+    ancestor = next;
+  }
+  return resolve(realpathSync(ancestor), relative(ancestor, path));
+}
+
+function assertLocalParent(parent: string): void {
+  const repoPlugins = realpathSync(resolve(import.meta.dir, '../../../plugins'));
+  const target = realTarget(parent);
+  if (target === repoPlugins || target.startsWith(`${repoPlugins}${sep}`)) {
+    throw new Error('repository plugins/ is not a local plugin directory');
+  }
+}
+
+export async function validatePluginDir(dir: string): Promise<string[]> {
+  const errors: string[] = [];
+  let manifest: unknown;
+  try {
+    const file = join(dir, 'plugin.json');
+    if (lstatSync(file).isSymbolicLink()) errors.push('안전하지 않은 plugin.json 링크');
+    else manifest = JSON.parse(readFileSync(file, 'utf8'));
+  }
+  catch (error) { errors.push(`plugin.json 파싱 실패: ${String(error)}`); }
+  const extension = isRecord(manifest) && isRecord(manifest.extensions) ? manifest.extensions['ai.elanous'] : undefined;
+  const graphs = isRecord(extension) ? extension.graphs : undefined;
+  if (isRecord(extension) && extension.contributes !== undefined) errors.push('extension contributes 덮어쓰기 금지');
+  if (!isRecord(manifest) || typeof manifest.name !== 'string' || !/^[a-z0-9][a-z0-9-]{1,39}$/.test(manifest.name) || typeof manifest.version !== 'string') errors.push('plugin.json 이름/버전 오류');
+  if (isRecord(manifest) && (manifest.capabilities !== undefined || manifest.contributes !== undefined || manifest.main !== undefined)) errors.push('plugin.json 최상위 권한/기여/main 덮어쓰기 금지');
+  if (!isRecord(extension) || !Array.isArray(extension.capabilities) || JSON.stringify(extension.capabilities) !== JSON.stringify(CAPABILITIES)) {
+    errors.push('capabilities 는 ["fs:workdir","proc:bun","proc:elanous"] 이어야 한다');
+  }
+  if (!Array.isArray(graphs) || graphs.length === 0 || !graphs.every(g => typeof g === 'string')) errors.push('plugin.json graphs 경로 없음');
+  let recipes: unknown;
+  try {
+    const file = join(dir, 'graphs', 'recipes.yaml');
+    if (lstatSync(file).isSymbolicLink()) errors.push('안전하지 않은 recipes.yaml 링크');
+    else recipes = parseYaml(readFileSync(file, 'utf8'));
+  }
+  catch (error) { errors.push(`recipes.yaml 파싱 실패: ${String(error)}`); }
+  if (!isRecord(recipes)) errors.push('recipes.yaml 은 맵이어야 한다');
+  else for (const [id, recipe] of Object.entries(recipes)) {
+    if (!isRecord(recipe) || typeof recipe.command !== 'string' || !recipe.command.trim() ||
+      (recipe.timeout_ms !== undefined && (!Number.isSafeInteger(recipe.timeout_ms) || Number(recipe.timeout_ms) <= 0))) errors.push(`잘못된 recipe: ${id}`);
+  }
+  for (const graph of Array.isArray(graphs) ? graphs : []) {
+    if (typeof graph !== 'string') continue;
+    const file = inside(dir, graph);
+    if (!file || !/^\.\/graphs\/[a-zA-Z0-9_-]+\.ya?ml$/.test(graph)) { errors.push(`안전하지 않은 graph 경로: ${graph}`); continue; }
+    try {
+      if (lstatSync(file).isSymbolicLink()) { errors.push(`안전하지 않은 graph 링크: ${graph}`); continue; }
+      const parsed = parseGraphTemplateYaml(readFileSync(file, 'utf8'), file);
+      errors.push(...parsed.errors.map(issue => `${issue.path}: ${issue.message}`));
+      const template = parsed.template;
+      if (!template) continue;
+      if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(template.graphId)) errors.push(`잘못된 graph_id: ${template.graphId}`);
+      if (template.terminalNodes.length !== 2 || !template.terminalNodes.includes('done') || !template.terminalNodes.includes('failed')) errors.push('terminal_nodes 는 done, failed 이어야 한다');
+      const executionNodes = template.nodes.filter(node => !template.terminalNodes.includes(node.nodeId));
+      if (executionNodes.length < 2 || executionNodes.length > 6) errors.push(`실행 노드는 2~6개여야 한다: ${executionNodes.length}개`);
+      for (const node of template.nodes) {
+        if (node.recipe.startsWith('cmd:')) {
+          const id = node.recipe.slice(4);
+          if (!isRecord(recipes) || !isRecord(recipes[id]) || typeof recipes[id].command !== 'string' || !recipes[id].command) errors.push(`recipe ${id} 없음`);
+        } else if (node.recipe !== 'none') errors.push(`지원하지 않는 recipe: ${node.recipe}`);
+      }
+    } catch (error) { errors.push(`${graph} 파싱 실패: ${String(error)}`); }
+  }
+  const visit = (path: string): void => {
+    for (const entry of readdirSync(path, { withFileTypes: true })) {
+      const file = join(path, entry.name);
+      if (entry.isSymbolicLink() || (!entry.isDirectory() && !entry.isFile())) { errors.push(`안전하지 않은 파일: ${file}`); continue; }
+      if (entry.isDirectory()) visit(file);
+      else if (/\.[cm]?[jt]sx?$/.test(entry.name)) {
+        const source = readFileSync(file, 'utf8');
+        for (const match of source.matchAll(/\b(?:import|export)\s*(?:[\s\S]*?\s+from\s*)?["']([^"']+)["']|\b(?:import|require)\s*\(\s*["']([^"']+)["']/g)) {
+          const target = match[1] ?? match[2]!;
+          if (/(?:^|\/)src\//.test(target) && (target.startsWith('/') || target.startsWith('.'))) errors.push(`src import 금지: ${file}: ${target}`);
+        }
+      }
+    }
+  };
+  try { visit(dir); } catch (error) { errors.push(`파일 검사 실패: ${String(error)}`); }
+  try {
+    const example = join(dir, 'examples', 'input.json');
+    if (lstatSync(example).isSymbolicLink()) errors.push('안전하지 않은 examples/input.json 링크');
+    else JSON.parse(readFileSync(example, 'utf8'));
+  } catch (error) { errors.push(`examples/input.json 파싱 실패: ${String(error)}`); }
+  const step = join(dir, 'graphs', 'run-step.ts');
+  try {
+    if (!existsSync(step)) errors.push('run-step.ts 없음');
+    else if (errors.some(error => error.startsWith('안전하지 않은 파일:'))) return errors;
+    else {
+      const build = await Bun.build({ entrypoints: [step], target: 'bun' });
+      if (!build.success) errors.push(...build.logs.map(log => `run-step.ts 문법 오류: ${log.message}`));
+    }
+  } catch (error) { errors.push(`run-step.ts 문법 오류: ${String(error)}`); }
+  return errors;
+}
+
+export async function makePlugin({ request, name, parentDir, run, input, deps }: MakePluginOptions): Promise<MakePluginResult> {
+  const slug = (name ?? request).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 32).replace(/-$/, '') || `plugin-${Date.now()}`;
+  if (!request.trim() || !/^[a-z0-9][a-z0-9-]{1,39}$/.test(slug)) throw new Error(`invalid plugin request or name: ${slug}`);
+  if (name !== undefined && !/^[a-z0-9][a-z0-9-]{1,31}$/.test(name)) throw new Error(`invalid --name slug: ${name}`);
+  const root = elanousStateRoot();
+  const parent = resolve(parentDir ?? join(root, 'plugins-local'));
+  assertLocalParent(parent);
+  const dir = join(parent, slug);
+  if (existsSync(dir)) throw new Error(`plugin directory already exists: ${dir}`);
+  const timings: MakePluginResult['timings'] = { scaffold: 0, write: 0, validate: 0, install: 0 };
+  const result: MakePluginResult = { status: 'failed', dir, plugin: slug, graph: join(dir, 'graphs', `${slug}.yaml`), errors: [], timings };
+  const step = async (stage: keyof MakePluginResult['timings'], action: () => void | Promise<void>): Promise<void> => {
+    const start = performance.now();
+    try { await action(); }
+    finally { const ms = Math.round(performance.now() - start); timings[stage] = ms; debug.log('plugin.maker', stage, { ms, errors: result.errors }); }
+  };
+  try {
+    await step('scaffold', () => { mkdirSync(parent, { recursive: true }); mkdirSync(dir); scaffold(dir, slug, request); });
+    const codex = deps?.codex ?? codexWrite;
+    const prompt = `요청 원문:\n${request}\n\n이 폴더의 뼈대를 수정해 작동하는 로컬 그래프 플러그인을 작성하라. plugin.json extensions["ai.elanous"].graphs 와 capabilities 는 유지하고, graphs/<id>.yaml 은 entry_node, terminal_nodes: [done, failed], nodes 의 recipe: 'cmd:<id>', edges 의 on: outcome, map: { ok, fail } 을 써라. graphs/recipes.yaml 에 모든 cmd:<id> 의 command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" <id>' 와 timeout_ms 를 선언하라. graphs/run-step.ts 의 각 단계 stdout 마지막 줄은 JSON {outcome, ...} 이며 이전 출력은 ELANOUS_GRAPH_CONTEXT JSON 의 outputs 에 있다. src/ import 금지. 엘라누스 기능은 CLI elanous ask --json 또는 elanous research --json 로만 사용. 아무것도 보내지 말 것. 실행 노드는 2~6개. examples/input.json 에 실제로 돌릴 입력을 넣을 것. 폴더 밖에는 쓰지 말 것.`;
+    await step('write', () => codex(dir, prompt));
+    await step('validate', async () => { result.errors = await validatePluginDir(dir); });
+    if (result.errors.length) {
+      await step('repair', () => codex(dir, `${prompt}\n\n아래 오류를 모두 수리하라:\n${result.errors.join('\n')}`));
+      await step('validate', async () => { result.errors = await validatePluginDir(dir); });
+    }
+    if (result.errors.length) return result;
+    let installedPath = '';
+    await step('install', async () => { installedPath = (await (deps?.install ?? installPlugin)(dir, { yes: true, root })).path; });
+    result.status = 'installed';
+    const graph = JSON.parse(readFileSync(join(dir, 'plugin.json'), 'utf8')).extensions['ai.elanous'].graphs[0] as string;
+    result.graph = resolve(installedPath, graph);
+    if (run) {
+      await step('run', async () => {
+        const value = input === undefined ? JSON.parse(readFileSync(join(dir, 'examples', 'input.json'), 'utf8')) : input;
+        result.runStatus = (await (deps?.runGraph ?? runGraph)(result.graph, { input: value })).status;
+      });
+      result.status = result.runStatus === 'done' ? 'ran' : 'failed';
+      if (result.status === 'failed') result.errors.push(`graph run: ${result.runStatus}`);
+    }
+  } catch (error) {
+    result.status = 'failed';
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}