elanous 0.2.35 → 0.2.36

package/src/mss/logging/log-store.ts

@@ -30,6 +30,7 @@ import type { LogSink } from './sink.js';
 import { setInstanceName, resolveInstanceName } from '../../instance-identity.js';
 import * as nestDepth from '../../agent/nest-depth.js';
 import { debug } from '../../debug/log.js';
+import { DebugLogBatchQueue, defaultDebugBatchScheduler, type DebugBatchScheduler } from '../../debug/batch-queue.js';
 import { assertNotTestWritingOps } from '../../instance/test-write-guard.js';
 
 /** 스토어 경로 — `ELANOUS_STATE_DIR` 존중(격리 테스트/`nexus run --test` 의
@@ -822,6 +823,21 @@ export interface StoreSinkOpts {
   /** Register beforeExit / SIGINT / SIGTERM flush hooks lazily on first
    *  emit. Default true; tests/isolated fixtures can pass false. */
   installExitHandlers?: boolean;
+  /** TUI-TYPING-LAG — 임계 뒤 detach drain 이 한 틱에 넣는 최대 행 수. 기본 = `Infinity`(옛 동작 ·
+   *  한 틱에 전부 — CLI 는 그대로). TUI 는 `TUI_LOG_STORE_DRAIN_CHUNK_ROWS` 로 켠다: 남은 행은 «다음»
+   *  틱으로 넘겨 그 사이 stdin(키)이 배달된다. */
+  drainChunkSize?: number;
+  /** 시계 seam — 기본 setImmediate/setTimeout(unref). ux-sim 무대가 가짜 시계를 꽂는다. */
+  scheduler?: DebugBatchScheduler;
+}
+
+/** TUI-TYPING-LAG — TUI 프로세스의 StoreSink 가 한 틱에 넣는 최대 행 수(키 하나가 기다리는 상한). */
+export const TUI_LOG_STORE_DRAIN_CHUNK_ROWS = 64;
+
+/** 어느 surface 의 StoreSink 가 덩어리 drain 을 쓰나 — 키 입력을 받는 TUI 만. CLI·데몬은 옛 동작
+ *  (한 틱에 전부 · SQLITE_BUSY 때 막힘이 한 번으로 끝난다)을 그대로 둔다. */
+export function logStoreDrainChunkForSurface(surface: string): number | undefined {
+  return surface === 'tui' ? TUI_LOG_STORE_DRAIN_CHUNK_ROWS : undefined;
 }
 
 /** StoreSink가 버린 레코드의 누적 관측값. 스토어에 쓰지 않아 자기참조하지 않는다. */
@@ -833,8 +849,11 @@ export interface StoreSinkDropCounts {
 
 export class StoreSink implements LogSink {
   readonly name = 'store';
-  private buf: Array<{ rec: LogRecord; surface: string }> = [];
-  private timer: ReturnType<typeof setTimeout> | null = null;
+  private readonly queue: DebugLogBatchQueue<{ rec: LogRecord; surface: string }>;
+  private timer: unknown = null;
+  private hasTimer = false;
+  /** 덩어리 insert 가 실패한 뒤 다음 성공까지 — 임계를 넘어도 덩어리 틱을 다시 걸지 않는다(주기 flush 만). */
+  private chunkingPaused = false;
   private exitHandlersInstalled = false;
   private onBeforeExit: (() => void) | null = null;
   private onSigInt: (() => void) | null = null;
@@ -843,6 +862,9 @@ export class StoreSink implements LogSink {
   private readonly flushBatchSize: number;
   private readonly bufferCap: number;
   private readonly installExit: boolean;
+  private readonly scheduler: DebugBatchScheduler;
+  /** 덩어리 drain 한 틱의 최대 행 수(`Infinity` = 옛 동작 · 한 틱에 전부). 등록 배선을 시험이 잠그는 관측 칸. */
+  readonly drainChunkSize: number;
   private readonly dropCounts: StoreSinkDropCounts = { total: 0, flushFailure: 0, bufferCap: 0 };
 
   constructor(
@@ -854,49 +876,79 @@ export class StoreSink implements LogSink {
     this.flushBatchSize = opts.flushBatchSize ?? 64;
     this.bufferCap = opts.bufferCap ?? 2048;
     this.installExit = opts.installExitHandlers ?? true;
+    this.scheduler = opts.scheduler ?? defaultDebugBatchScheduler;
+    this.drainChunkSize = opts.drainChunkSize ?? Number.POSITIVE_INFINITY;
+    this.queue = new DebugLogBatchQueue({
+      batchSize: this.drainChunkSize,
+      flushDelayMs: 0,
+      scheduler: this.scheduler,
+      drain: (batch) => this.insert(batch),
+    });
   }
 
   emit(rec: LogRecord): void {
     // 자기참조 가드 — 로그 평면 자신의 이벤트는 스토어 재진입 금지.
     if (rec.category.startsWith('logs.')) return;
-    this.buf.push({ rec, surface: this.surface });
-    if (this.buf.length > this.bufferCap) {
-      const dropped = this.buf.length - this.bufferCap;
-      this.buf.splice(0, dropped);
-      this.recordDrop('bufferCap', dropped);
+    this.queue.push({ rec, surface: this.surface });
+    if (this.queue.pending > this.bufferCap) {
+      this.recordDrop('bufferCap', this.queue.dropOldest(this.queue.pending - this.bufferCap));
     }
     if (this.installExit) this.installExitHandlersOnce();
-    if (this.buf.length >= this.flushBatchSize) {
-      // 핫 틱 비블록 — insert 는 다음 매크로태스크로(FileSink detach 동형).
-      if (this.timer) { clearTimeout(this.timer); this.timer = null; }
-      setImmediate(() => this.flush());
+    if (this.queue.pending >= this.flushBatchSize && !this.chunkingPaused) {
+      // 핫 틱 비블록 — insert 는 다음 매크로태스크로, 그것도 «덩어리 하나씩»(TUI-TYPING-LAG).
+      this.cancelTimer();
+      this.queue.schedule();
       return;
     }
-    if (this.timer === null) {
-      this.timer = setTimeout(() => this.flush(), this.flushIntervalMs);
-      (this.timer as unknown as { unref?: () => void }).unref?.();
-    }
+    if (!this.queue.scheduled) this.armIntervalFlush();
   }
 
   flush(): void {
-    if (this.timer) { clearTimeout(this.timer); this.timer = null; }
-    if (this.buf.length === 0) return;
-    const batch = this.buf;
-    this.buf = [];
+    this.cancelTimer();
+    this.queue.flushAll();
+  }
+
+  private cancelTimer(): void {
+    if (!this.hasTimer) return;
+    this.scheduler.cancel(this.timer);
+    this.timer = null;
+    this.hasTimer = false;
+  }
+
+  private insert(batch: Array<{ rec: LogRecord; surface: string }>): boolean {
     try {
       // insertBatch retries SQLITE_BUSY batches on the next write; this sink remains fail-soft on final failure.
       this.store.insertBatch(batch);
+      this.chunkingPaused = false;
+      return true;
     } catch {
       /* fail-soft — 파일 트레일이 진실원. 배치는 버린다(재시도 루프 금지 —
          디스크 장애 시 무한 적체 방지). */
       this.recordDrop('flushFailure', batch.length);
+      // 덩어리 drain 중 실패(예: SQLITE_BUSY 는 busy_timeout 만큼 막는다)면 남은 덩어리를 틱마다 또
+      // 막게 두지 않는다 — 잘게 쪼개기를 멈추고(다음 성공까지 · 새 emit 도 덩어리 틱을 다시 걸지 않는다)
+      // 나머지는 다음 주기 flush 한 번으로 넘긴다.
+      this.chunkingPaused = true;
+      this.queue.cancelScheduled();
+      this.armIntervalFlush();
+      return false;
     }
   }
 
+  private armIntervalFlush(): void {
+    if (this.hasTimer) return;
+    this.hasTimer = true;
+    this.timer = this.scheduler.schedule(() => {
+      this.timer = null;
+      this.hasTimer = false;
+      this.flush();
+    }, this.flushIntervalMs);
+  }
+
   /** 누적 유실 관측값의 복사본. 로그 스토어에 쓰지 않아 자기참조하지 않는다. */
   get dropped(): StoreSinkDropCounts { return { ...this.dropCounts }; }
 
-  get pending(): number { return this.buf.length; }
+  get pending(): number { return this.queue.pending; }
 
   /** Flush the buffer and drop only this sink's exit/signal listeners. */
   close(): void {
@@ -1313,11 +1365,16 @@ export function registerLogStoreSink(
   registerSink: (sink: LogSink) => () => void,
   surface: string,
   retention: LogStoreRetention = LOG_RETENTION_DEFAULTS,
-  opts: { retentionOwner?: boolean } = {},
+  opts: { retentionOwner?: boolean; drainChunkSize?: number } = {},
 ): (() => void) | null {
   const store = getDefaultLogStore();
   if (!store) return null;
-  const sink = new StoreSink(store, surface, { installExitHandlers: true });
+  // 덩어리 크기 기본값은 surface 로 여기서 정한다 — 어느 등록 경로(standalone·nexus·직접 호출)든 TUI 면 덩어리 drain.
+  const drainChunkSize = opts.drainChunkSize ?? logStoreDrainChunkForSurface(surface);
+  const sink = new StoreSink(store, surface, {
+    installExitHandlers: true,
+    ...(drainChunkSize !== undefined ? { drainChunkSize } : {}),
+  });
   const off = registerSink(sink);
   try { nestDepth.observeNestAtBoot(); } catch { /* fail-soft — 관측 실패가 싱크 등록을 막지 않는다. */ }
   const owner = opts.retentionOwner ?? surface === 'nexus';

package/src/nexus/api/decisions-route.ts

@@ -24,24 +24,44 @@ export async function handleDecisions(req: Request, deps: DecisionsRouteDeps = {
       debug.log('decisions.api', 'rejected', { reason: 'invalid-status' });
       return jsonResponse({ error: 'bad_request' }, 400);
     }
-    const decisions = ledger.list({ status: 'open' }).map(entry => ({
-      id: entry.id,
-      title: entry.title,
-      situation: entry.scqa.s.slice(0, 200),
-      options: entry.options.map(option => ({ id: option.key, label: option.label, consequence: option.consequence })),
-      recommendation: entry.recommendation,
-      raisedAt: entry.raisedAt,
-      dueAt: entry.dueAt,
-      scqa: entry.scqa,
-      category: entry.category,
-      irreversible: isIrreversible(entry),
-      raisedBy: { agent: entry.raisedBy.agent, ...(entry.raisedBy.track ? { track: entry.raisedBy.track } : {}) },
-      alternative: entry.alternative,
-      dissent: entry.dissent,
-      crossCheck: entry.crossCheck,
-      crossCheckSkipped: entry.crossCheckSkipped,
-      pendingQuestion: entry.pendingQuestion,
-    }));
+    const decided = ledger.list({ status: 'decided' });
+    const decisions = ledger.list({ status: 'open' }).map(entry => {
+      const precedent = decided
+        .filter(other => other.id !== entry.id && other.category === entry.category && other.choice)
+        .sort((a, b) => (b.decidedAt ?? '').localeCompare(a.decidedAt ?? ''))[0];
+      return {
+        id: entry.id,
+        title: entry.title,
+        situation: entry.scqa.s.slice(0, 200),
+        options: entry.options.map(option => ({ id: option.key, label: option.label, consequence: option.consequence })),
+        recommendation: entry.recommendation,
+        raisedAt: entry.raisedAt,
+        dueAt: entry.dueAt,
+        scqa: entry.scqa,
+        category: entry.category,
+        irreversible: isIrreversible(entry),
+        raisedBy: { agent: entry.raisedBy.agent, ...(entry.raisedBy.track ? { track: entry.raisedBy.track } : {}) },
+        alternative: entry.alternative,
+        dissent: entry.dissent,
+        crossCheck: entry.crossCheck,
+        crossCheckSkipped: entry.crossCheckSkipped,
+        pendingQuestion: entry.pendingQuestion,
+        history: entry.history.map(event => ({
+          type: event.type,
+          ...(event.at ? { at: event.at } : {}),
+          by: event.by,
+          ...(event.choice ? { choice: event.choice } : {}),
+          ...(event.reason ? { reason: event.reason } : {}),
+        })),
+        precedent: precedent ? {
+          id: precedent.id,
+          title: precedent.title,
+          choice: precedent.options.find(option => option.key === precedent.choice)?.label ?? precedent.choice ?? '',
+          ...(precedent.decidedAt ? { decidedAt: precedent.decidedAt } : {}),
+          ...(precedent.decidedBy ? { decidedBy: precedent.decidedBy.kind } : {}),
+        } : null,
+      };
+    });
     debug.log('decisions.api', 'listed', { count: decisions.length });
     return jsonResponse({ decisions });
   }

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

@@ -1,5 +1,7 @@
 import { debug } from '../../debug/log.js';
-import { GraphWizardInputError, generateGraphFromPrompt, wizardInstalledPacks, type GraphWizardDeps, type GraphWizardTurn } from '../../graph-wizard/generate.js';
+import { GraphWizardInputError, designGraphVariantPlan, generateGraphFromPrompt, wizardInstalledPacks, type GraphWizardDeps, type GraphWizardTurn } from '../../graph-wizard/generate.js';
+import { defaultGraphsDir } from '../../self-implement/graph-templates.js';
+import { loadGraphTemplates } from '../../self-implement/graph-yaml.js';
 import { jsonResponse } from './json-response.js';
 
 export function handleGraphWizardPacksGet(deps: GraphWizardDeps = {}): Response {
@@ -10,7 +12,8 @@ const MAX_PROMPT = 4000;
 const MAX_YAML = 200_000;
 
 /**
- * POST /v1/graphs/wizard {prompt, kind?, currentYaml?, history?}
+ * POST /v1/graphs/wizard {prompt, kind?, currentYaml?, history?} or
+ * {mode:'variant', prompt, goal, templateId} for one validated L2 plan (no YAML generation).
  * → 200 {ok:true, id, yaml, base, baseReason, issues:[], attempts, summary, labels, steps, recipes, dryRun} · 422 {ok:false, …} · 400 빈 prompt.
  * (labels·steps·recipes·dryRun·baseReason 는 v2 추가 필드 — 기존 필드는 그대로.)
  * currentYaml 이 빈 문자열이면 «빈 캔버스»로 보고 새 그래프를 짓는다(의도) · 내용이 있는데 id 가 없거나 형식 밖이면 400.
@@ -26,6 +29,9 @@ export async function handleGraphWizardPost(req: Request, deps: GraphWizardDeps
   const prompt = typeof body.prompt === 'string' ? body.prompt.trim() : '';
   if (!prompt) return jsonResponse({ error: 'bad_request', reason: 'prompt required' }, 400);
   if (prompt.length > MAX_PROMPT) return jsonResponse({ error: 'bad_request', reason: `prompt longer than ${MAX_PROMPT}` }, 400);
+  if (body.mode !== undefined && body.mode !== 'variant') {
+    return jsonResponse({ error: 'bad_request', reason: 'mode must be variant when supplied' }, 400);
+  }
   if (body.kind !== undefined && body.kind !== 'harness' && body.kind !== 'workflow') {
     return jsonResponse({ error: 'bad_request', reason: 'kind must be harness or workflow' }, 400);
   }
@@ -44,6 +50,18 @@ export async function handleGraphWizardPost(req: Request, deps: GraphWizardDeps
     history = body.history as GraphWizardTurn[];
   }
   try {
+    if (body.mode === 'variant') {
+      if (typeof body.goal !== 'string' || !/^g_[a-z0-9_-]+$/i.test(body.goal) ||
+          typeof body.templateId !== 'string' || !/^[a-z0-9-]+$/.test(body.templateId) ||
+          body.kind === 'workflow' || body.currentYaml !== undefined || body.packId !== undefined || history !== undefined) {
+        return jsonResponse({ error: 'bad_request', reason: 'variant requires goal and templateId; YAML, workflow, pack and history are unsupported' }, 400);
+      }
+      // Resolve the base on the server. Client-supplied graph YAML never becomes variant authority.
+      const template = loadGraphTemplates(deps.graphsDir ?? defaultGraphsDir()).templates[body.templateId];
+      if (!template) return jsonResponse({ error: 'bad_request', reason: `unknown templateId: ${body.templateId}` }, 400);
+      const result = await designGraphVariantPlan({ goal: body.goal, prompt, template }, deps);
+      return jsonResponse({ mode: 'variant', ...result });
+    }
     const result = await generateGraphFromPrompt({
       prompt,
       ...(body.kind ? { kind: body.kind as 'harness' | 'workflow' } : {}),