elanous 0.2.29 → 0.2.32

package/src/decisions/decision-ledger.ts

@@ -7,6 +7,7 @@ import { createVersionResolver, type VersionOptions, type Versions } from '../di
 import { getUserConfig } from '../user-config.js';
 import { registeredSeats, resolveSeat } from '../seat-address/seat-address.js';
 import { isSeatId } from '../seat-dispatch/seat-questions.js';
+import { openMsgStore } from '../msg/msg-store.js';
 
 export type DecisionCategory = 'secret' | 'publish' | 'money' | 'security' | 'scope' | 'irreversible' | 'other';
 /** Old track letters (S·T·F·O) stay readable; seat names (OP·MK·TC·UX) are the current identities. */
@@ -42,10 +43,22 @@ export interface SeatDecisionRecord {
 }
 export type SeatDecisionInput = Pick<SeatDecisionRecord, 'title' | 'decision' | 'seat' | 'delegation' | 'refs'> & { decidedAt?: string };
 type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'seat-recorded'; entry: SeatDecisionRecord } | { type: 'options-added'; id: string; at: string; options: DecisionOption[]; by: string } | { type: 'decided'; id: string; at?: string; by: DecisionActor; choice?: string; version?: Versions; note?: string } | { type: 'withdrawn'; id: string; at: string; reason: string; version: Versions };
-export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer }
+export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer; postDecisionNotice?: (entry: DecisionEntry, stateDir: string, seat: string) => number }
 
 /** null = the decision resumes no run; otherwise whether the answer file was written (or already matched). */
 export type AnswerDelivery = null | { ok: true; questionId: string } | { ok: false; questionId: string; reason: string };
+export type DecisionNotice = { status: 'skipped' } | { status: 'sent'; seat: string; messageId: number } | { status: 'failed'; seat: string; reason: string };
+
+function postDecisionNotice(entry: DecisionEntry, stateDir: string, seat: string): number {
+  const selected = entry.options.find(option => option.key === entry.choice);
+  if (!selected || !entry.choice) throw new Error('recorded choice not found');
+  const recommendedWhy = 'option' in entry.recommendation && entry.recommendation.option === entry.choice ? entry.recommendation.why : undefined;
+  const rationale = (entry.note ?? recommendedWhy ?? entry.scqa.c).replace(/\s+/g, ' ').trim();
+  const body = `**[OP]** 결정 ${entry.id} · ${entry.title} · 선택 ${entry.choice}: ${selected.label} · 근거 ${rationale}`;
+  const store = openMsgStore(join(stateDir, 'msg', 'messages.db'));
+  try { return store.appendWithProvenance({ from: 'OP', to: seat, kind: 'info', body }, `decision:${entry.id}:${seat}`).id; }
+  finally { store.close(); }
+}
 
 /** The decision is durable even when delivery fails; retryAnswer(id) only retries delivery. */
 export class DecisionAnswerDeliveryError extends Error {
@@ -144,6 +157,7 @@ export class DecisionLedger {
   private readonly lockPath: string;
   private readonly now: () => Date;
   private readonly writeAnswer: typeof writePendingQuestionAnswer;
+  private readonly postDecisionNotice: NonNullable<DecisionLedgerOptions['postDecisionNotice']>;
   private readonly stateDir: string;
   private versionResolver?: (at: string) => Versions;
   private readonly versionOptions: DecisionLedgerOptions;
@@ -153,6 +167,7 @@ export class DecisionLedger {
     this.lockPath = `${this.path}.lock`;
     this.now = options.now ?? (() => new Date());
     this.writeAnswer = options.writeAnswer ?? writePendingQuestionAnswer;
+    this.postDecisionNotice = options.postDecisionNotice ?? postDecisionNotice;
     this.versionOptions = options;
     this.versionResolver = options.resolveVersion;
   }
@@ -300,13 +315,13 @@ export class DecisionLedger {
     return entry;
   }
   /** Record the decision and say whether its answer reached the waiting run (null = the decision resumes nothing). */
-  decideWithDelivery(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {
+  decideWithDelivery(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery; notice: DecisionNotice } {
     return this.decideLocked(id, choice, by, note, decidedAt);
   }
   decide(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): DecisionEntry {
     return this.decideLocked(id, choice, by, note, decidedAt).entry;
   }
-  private decideLocked(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {
+  private decideLocked(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery; notice: DecisionNotice } {
     if (!by || (by.kind !== 'human' && by.kind !== 'auto')) throw new Error('decidedBy is required');
     if (by.kind === 'auto') {
       single(by.delegation, 'delegation'); single(by.agent, 'agent');
@@ -322,9 +337,35 @@ export class DecisionLedger {
       this.append({ type: 'decided', id, at, by, choice, version: this.version(at), ...(note ? { note: safe(single(note, 'note')) } : {}) });
       debug.log('decisions', 'decided', { id, category: old.category, by: by.kind });
       const decided = this.show(id);
-      return { entry: decided, delivery: this.deliverAnswer(decided) };
+      return { entry: decided, delivery: this.deliverAnswer(decided), notice: this.notifyDecided(decided) };
+    });
+  }
+  /** Retry only the seat notice; the message provenance key prevents duplicate delivery. */
+  retryNotice(id: string): DecisionNotice {
+    return this.locked(() => {
+      const entry = this.show(id);
+      if (entry.status !== 'decided') throw new Error(`decision is not decided: ${id}`);
+      return this.notifyDecided(entry);
     });
   }
+  private notifyDecided(entry: DecisionEntry): DecisionNotice {
+    const track = entry.raisedBy.track;
+    if (!track) return { status: 'skipped' };
+    const seat = resolveSeat(track)?.id;
+    if (!seat) {
+      debug.log('decisions', 'decided-notify-unknown-seat', { id: entry.id, track });
+      return { status: 'failed', seat: track, reason: '올린 자리 미상' };
+    }
+    try {
+      const messageId = this.postDecisionNotice(entry, this.stateDir, seat);
+      debug.log('decisions', 'decided-notify-sent', { id: entry.id, seat, messageId });
+      return { status: 'sent', seat, messageId };
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      debug.log('decisions', 'decided-notify-failed', { id: entry.id, seat, reason });
+      return { status: 'failed', seat, reason };
+    }
+  }
   /** Retry delivery of the recorded choice without adding another decided event or changing its actor/note. */
   retryAnswer(id: string): DecisionEntry {
     return this.locked(() => {

package/src/discord-self-message.ts

@@ -66,7 +66,7 @@ import { localOcrText } from './telegram-card-followup.js';
 import type { runGraph } from './graph-runner/runner.js';
 import { readSlashContextNow, renderContextFirstNow, renderTelegramNow } from './context-bus/context-now-surfaces.js';
 import { contextNow, type ContextNowDeps } from './context-bus/context-now.js';
-import { createContextFirstGate, renderContextFirst } from './context-bus/context-first.js';
+import { createContextFirstGate, renderContextFirst, takeContextFirstOpening } from './context-bus/context-first.js';
 import { telegramLoopsStatus, type LoopsSources } from './telegram-loops-command.js';
 import { botUnavailableSlashReply, deriveTuiSlashAvailability, type TuiSlashAvailability } from './maturity/tui-slash-availability.js';
 
@@ -157,8 +157,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
   const log = deps.log ?? ((): void => {});
   const cfg = deps.userConfig;
   const contextFirstGate = createContextFirstGate({ now: deps.contextFirstNow ?? Date.now });
-  const maybeSendContextFirst = async (channelId: string): Promise<void> => {
-    if (!contextFirstGate.take(channelId) || cfg.discord?.contextFirst === false) return;
+  const maybeSendContextFirst = async (channelId: string, text?: string): Promise<void> => {
+    if (!takeContextFirstOpening({ gate: contextFirstGate, key: channelId, text, enabled: cfg.discord?.contextFirst !== false })) return;
     try {
       await deps.getBot()?.sendMessage(channelId, renderContextFirst(contextNow, deps.nowDeps, renderContextFirstNow));
     } catch (err) {
@@ -426,7 +426,7 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       if (unavailable) return unavailable;
     }
     const cmd = parseDiscordAcpCommand(ctx.text);
-    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId);
+    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId, ctx.text);
     log(`◀ ${ctx.userName ?? ctx.userId}: ${ctx.text.slice(0, 80)}${ctx.attachments.length ? ` (+첨부 ${ctx.attachments.length})` : ''}`);
     debug.log('discord.self.turn', 'inbound', { channelId: ctx.channelId, chars: ctx.text.length, attachments: ctx.attachments.length });
     // C2+ — 첨부 기억(사진만 먼저 올리는 패턴 지원). 명령 여부와 무관.

package/src/display/prompt-row-owner.ts

@@ -0,0 +1,146 @@
+/** 대기 중 프롬프트 띠의 «주인 하나» (TUI-PROMPT-SINGLE-OWNER · 2026-10-17).
+ *
+ *  종전엔 띠를 둘이 그렸다 — frame 렌더러 zone 은 `❯ ` 를, textInput `drawInput` 은
+ *  실제 버퍼를 직접 stdout 에 썼다. 직접 쓰기가 행 캐시를 무효화하므로 대기 중 매 draw
+ *  (2Hz 상태줄 틱 포함)가 «zone 이 `❯ ` 로 지움 → afterRender 덧칠이 버퍼로 다시 씀»을
+ *  되풀이했고, 프롬프트·구분선·상태줄이 매 프레임 `\x1b[2K` 로 다시 나갔다.
+ *
+ *  ⭐ 이제 textInput 은 그릴 줄을 여기 **올리기만** 하고(publish), 실제 쓰기는 frame
+ *  렌더러 zone 하나가 한다. 행 캐시 diff 가 바뀐 줄만 내보내므로 대기 중 재출력은 0 이다. */
+import { debug } from '../debug/log.js';
+import type { LayoutZone } from '../layout/composer.js';
+import type { CursorState } from './cursor-state.js';
+
+export interface PromptRowPaint {
+  /** 위→아래 순서의 보이는 프롬프트 줄(접두·패딩 포함 · 행 지움 없음). */
+  rows: string[];
+  /** 프롬프트 아래 둘째 줄의 일시 힌트(Ctrl+C 등). 없으면 null. */
+  hint: string | null;
+  caret: CursorState | null;
+  source: 'text-input' | 'reverse-search';
+}
+
+export interface PromptRowOwner {
+  /** 같은 그림이면 false(프레임 요청 없음) — 대기 중 외부 repaint 가 no-op 이 되는 자리. */
+  publish(paint: PromptRowPaint): boolean;
+  clear(): void;
+  current(): PromptRowPaint | null;
+}
+
+export type PromptRowOwnerLog = (category: string, event: string, data: Record<string, unknown>) => void;
+
+const CATEGORY = 'dashboard.prompt-owner';
+
+const paintKey = (paint: PromptRowPaint): string => JSON.stringify(paint);
+
+export function createPromptRowOwner(deps: {
+  requestFrame: () => void;
+  isDebugEnabled?: () => boolean;
+  log?: PromptRowOwnerLog;
+}): PromptRowOwner {
+  let paint: PromptRowPaint | null = null;
+  let key = '';
+  const enabled = (): boolean => (deps.isDebugEnabled ? deps.isDebugEnabled() : debug.enabled);
+  const log: PromptRowOwnerLog = deps.log ?? ((c, e, d) => debug.log(c, e, d));
+  return {
+    publish(next) {
+      const nextKey = paintKey(next);
+      if (nextKey === key) return false;
+      paint = next;
+      key = nextKey;
+      if (enabled()) {
+        log(CATEGORY, 'publish', {
+          source: next.source,
+          rows: next.rows.length,
+          hint: next.hint !== null,
+          caretRow: next.caret?.row ?? null,
+          caretCol: next.caret?.col ?? null,
+        });
+      }
+      deps.requestFrame();
+      return true;
+    },
+    clear() {
+      if (!paint) return;
+      paint = null;
+      key = '';
+      if (enabled()) log(CATEGORY, 'clear', {});
+      deps.requestFrame();
+    },
+    current: () => paint,
+  };
+}
+
+/** 바닥 기준으로 `height` 줄에 맞춘다 — 입력 줄이 늘면 위로 자란다(textInput 과 같은 앵커). */
+export function renderPromptOwnerRows(paint: PromptRowPaint, height: number): string[] {
+  // ⚠️ `slice(-0)` is the whole array — a zero-height zone must paint nothing.
+  if (height <= 0) return [];
+  const visible = paint.rows.slice(-height);
+  return [...Array.from({ length: height - visible.length }, () => ''), ...visible];
+}
+
+export type PromptBandOwner = 'text-input' | 'turn-typeahead' | 'suppressed';
+
+/** 누가 띠를 그렸나 — 주인·그림(줄·힌트·caret)이 바뀔 때 한 줄, 같은 상태(대기)는 10초에 한 줄로 샘플링. */
+export function createPromptBandRenderObserver(deps: {
+  isDebugEnabled?: () => boolean;
+  log?: PromptRowOwnerLog;
+  now?: () => number;
+  sampleMs?: number;
+} = {}): (owner: PromptBandOwner, frameKey: string) => void {
+  const now = deps.now ?? Date.now;
+  const sampleMs = deps.sampleMs ?? 10_000;
+  let lastOwner: PromptBandOwner | null = null;
+  let lastFrameKey = '';
+  let lastLoggedAt = 0;
+  let renders = 0;
+  return (owner, frameKey) => {
+    renders++;
+    const enabled = deps.isDebugEnabled ? deps.isDebugEnabled() : debug.enabled;
+    if (!enabled) return;
+    const changed = owner !== lastOwner || frameKey !== lastFrameKey;
+    const at = now();
+    if (!changed && at - lastLoggedAt < sampleMs) return;
+    (deps.log ?? ((c, e, d) => debug.log(c, e, d)))(CATEGORY, 'frame-render', {
+      owner,
+      changed,
+      rendersSinceLast: renders,
+    });
+    lastOwner = owner;
+    lastFrameKey = frameKey;
+    lastLoggedAt = at;
+    renders = 0;
+  };
+}
+
+/** 프롬프트 zone 을 주인 하나로 감싼다 — textInput 이 그림을 올렸으면 그것을, 아니면(턴 중)
+ *  `inner`(turn-typeahead 에코·placeholder)를 그린다. caret 도 같은 그림에서 나온다. */
+export function withPromptRowOwner(inner: LayoutZone, owner: PromptRowOwner, opts: {
+  suppressPromptArea: boolean;
+  onCaret?: (caret: CursorState | null) => void;
+  /** `frameKey` covers everything the band paints — rows, hint and caret. */
+  observe?: (owner: PromptBandOwner, frameKey: string) => void;
+}): LayoutZone {
+  return {
+    ...inner,
+    render: (height, width) => {
+      const paint = opts.suppressPromptArea ? null : owner.current();
+      if (!paint) {
+        const rows = inner.render(height, width);
+        opts.observe?.(opts.suppressPromptArea ? 'suppressed' : 'turn-typeahead', rows.join('\n'));
+        return rows;
+      }
+      const rows = renderPromptOwnerRows(paint, height);
+      opts.onCaret?.(paint.caret);
+      opts.observe?.('text-input', JSON.stringify({ rows, hint: paint.hint, caret: paint.caret }));
+      return rows;
+    },
+  };
+}
+
+/** 프롬프트 아래 둘째 줄(status-gap-top) — textInput 힌트가 있으면 그것, 아니면 빈 줄.
+ *  프롬프트가 억제된 프레임(전면 모달 등)에는 힌트도 내지 않는다. */
+export function renderPromptOwnerHintRow(owner: PromptRowOwner, opts: { suppressPromptArea: boolean }): string {
+  if (opts.suppressPromptArea) return '';
+  return owner.current()?.hint ?? '';
+}

package/src/display/resize-listener.ts

@@ -10,14 +10,31 @@
 // overlays catch up too. Both calls are wrapped in try/catch so a
 // transient paint error doesn't kill the listener.
 //
+// (3) TUI-PICKER-RESIZE-SHRINK (#76 · 2026-10-17) — then ask the
+// coordinator for one FORCED frame. Steps (1)+(2) bypass the
+// coordinator flush, so the prompt chrome repaint in (2) writes the
+// input divider straight over the bottom row of an open overlay (the
+// slash picker's `╰` sits on the divider row) and nothing re-emits the
+// overlay afterwards — the picker lost its bottom border until it was
+// closed and reopened. A coordinator frame runs onRender → afterRender
+// (chrome) → flushOverlay (modals on top), so the overlay lands last.
+// `force` matters: the overlay byte-equality cache would otherwise
+// skip a re-emit whose bytes match the last coordinator frame
+// (e.g. 80 → 120 → 80 with no coordinator flush in between).
+//
 // Non-goals (stay out of IDX-1 territory):
-//   - Do NOT touch coordinator.flushOverlay cache state.
-//   - Do NOT recompute modal bounds (mount-time snapshot preserved).
+//   - Do NOT touch coordinator.flushOverlay cache state directly.
 //   - Do NOT reach into chat.ts textInput loop internals.
 
+import { debug } from '../debug/log.js';
+
 export interface ResizeListenerDeps {
   draw: (opts?: { force?: boolean }) => void;
   promptCtl: { repaint: () => void };
+  /** Request one forced coordinator frame so modal overlays are
+   *  re-emitted on top of the chrome the prompt repaint just wrote.
+   *  Optional: hosts without a coordinator keep the legacy two-step. */
+  requestOverlayFrame?: () => void;
 }
 
 /** Registers the resize listener and returns a dispose fn that
@@ -28,6 +45,20 @@ export function installResizeListener(deps: ResizeListenerDeps): () => void {
   const handler = (): void => {
     try { deps.draw({ force: true }); } catch { /* swallow — paint errors shouldn't break resize */ }
     try { deps.promptCtl.repaint(); } catch { /* swallow */ }
+    let overlayFrame: 'requested' | 'absent' | 'failed' = 'absent';
+    if (deps.requestOverlayFrame) {
+      try {
+        deps.requestOverlayFrame();
+        overlayFrame = 'requested';
+      } catch {
+        overlayFrame = 'failed';
+      }
+    }
+    debug.log('display.resize', 'repaint', {
+      cols: process.stdout.columns ?? null,
+      rows: process.stdout.rows ?? null,
+      overlayFrame,
+    });
   };
   process.stdout.on('resize', handler);
   return (): void => {

package/src/domains/release-tool.ts

@@ -122,7 +122,24 @@ function cellView(item: ChecklistItem) {
     owner: item.owner ?? null, priority: item.priority ?? null, evidence: item.evidence ? firstLine(item.evidence) : null };
 }
 
-export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
+export function dispatchReleaseStatus(rawArgs: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
+  // A blank topic/action ("" · spaces) means «not sent» — models fill unused enum slots with "" and then hit the
+  // simultaneous-topic-and-action rejection over and over (TUI defect #70 · 10-15: 10+ identical retries, then gave up).
+  const args = { ...rawArgs };
+  for (const key of Object.keys(args)) if (typeof args[key] === 'string' && !(args[key] as string).trim()) delete args[key];
+  // topic=status is the default read — beside an action it adds nothing, so the action wins (#70 · 10-15 실측:
+  // models send {topic:"status", action:"landed"} and looped on the simultaneous-topic-and-action rejection).
+  if (args.topic === 'status' && args.action !== undefined) delete args.topic;
+  // Any other non-features topic beside an action: the action wins too, with one warning line in front (#70b · 10-15
+  // 실측: {topic:"ops", action:"schedule"} rejected over and over). topic=features ⊕ action stays rejected below —
+  // a feature list and a short summary are different answers.
+  if (args.action !== undefined && typeof args.topic === 'string'
+    && ['cell', 'schedule', 'ops'].includes(args.topic)) {
+    const { topic: ignoredTopic, ...rest } = args;
+    debug.log('release.tool', 'topic-ignored-for-action', { topic: ignoredTopic, action: args.action });
+    const result = dispatchReleaseStatus(rest, deps);
+    return { text: `topic(${ignoredTopic}) 은 무시하고 action 으로 답함\n${result.text}`, structured: { ...result.structured, ignoredTopic } };
+  }
   const topic = args.topic === undefined ? 'status' : args.topic;
   if (typeof topic !== 'string' || !['status', 'features', 'cell', 'schedule', 'ops'].includes(topic)) throw new Error('topic 은 status, features, cell, schedule, ops 중 하나');
   if (args.topic !== undefined && args.action !== undefined) {

package/src/field-note/transcribe.ts

@@ -1,4 +1,5 @@
 import type { TranscriptEntry } from './index';
+import type { STTProvider } from '../voice/stt-provider.js';
 
 /** Mono, normalized PCM. The capture instant is required for NOTE1's absolute photo alignment. */
 export interface FieldAudio {
@@ -70,6 +71,22 @@ export function createCloudSttEngine(client: CloudSttClient): TranscriptionEngin
   };
 }
 
+export function createBatchSttEngine(provider: STTProvider): TranscriptionEngine {
+  return {
+    async transcribe(chunk, request) {
+      if (chunk.sampleRate !== 16000) throw new RangeError('Batch STT requires 16 kHz mono PCM');
+      const pcm = Buffer.alloc(chunk.samples.length * 2);
+      for (let i = 0; i < chunk.samples.length; i++) {
+        const sample = chunk.samples[i]!;
+        if (!Number.isFinite(sample)) throw new RangeError('Audio samples must be finite');
+        pcm.writeInt16LE(Math.round(Math.max(-1, Math.min(1, sample)) * (sample < 0 ? 32768 : 32767)), i * 2);
+      }
+      const { text } = await provider.transcribeBatch(pcm, { language: request.language });
+      return text.trim() ? [{ startSeconds: 0, endSeconds: chunk.samples.length / chunk.sampleRate, text }] : [];
+    },
+  };
+}
+
 export interface TranscriptionOptions {
   /** Default: ko. */
   language?: string;

package/src/fold-stack.ts

@@ -216,8 +216,9 @@ export class FoldStack {
   /** Toggle the latest-pushed static target whose range contains
    *  `lineIndex`. Returns true when a target was toggled, false
    *  when none contained the line (live targets are never chosen).
-   *  Reuses the single-target splice/cascade path. */
-  toggleAtLine(lineIndex: number): boolean {
+   *  Reuses the single-target splice/cascade path. `logContext` (the
+   *  click's screen frame) is merged into the expanded/recollapsed line. */
+  toggleAtLine(lineIndex: number, logContext: Record<string, unknown> = {}): boolean {
     const t = this.findLatestStaticContaining(lineIndex);
     if (!t) {
       this.logToggleAtLineMiss(lineIndex);
@@ -236,6 +237,7 @@ export class FoldStack {
         lineIndex,
         lineStart,
         lineEnd,
+        ...logContext,
       });
     }
     return toggled;