elanous 0.2.28 → 0.2.31

package/src/dashboard/input/external-input-host.ts

@@ -0,0 +1,71 @@
+// 대시보드 ↔ 외부 주입 대기열(`input/external-input-queue`) 배선. `index.ts` 는 이 함수를 한 번 부르기만 한다.
+import type { TextInputExternalSubmitRequest } from '../../chat/index.js';
+import { pendingKeyCount } from '../../tui.js';
+import type { EscAbortGate } from '../../esc-abort-gate.js';
+import {
+  renderExternalInputQueueNotice,
+  type ExternalInputHost,
+} from '../../input/external-input-queue.js';
+
+export interface DashboardExternalInputHostDeps {
+  isTurnActive: () => boolean;
+  promptCtl: {
+    /** 합성 Enter 가 들어갔으면 true · 못 들어갔으면 false(옛 구현은 void). */
+    submit?: (request?: string | TextInputExternalSubmitRequest) => boolean | void;
+    getBufferText?: () => string;
+  };
+  /** 채팅 로그에 한 줄(표지)을 남기고 다시 그린다. */
+  pushNotice: (line: string) => void;
+  /** 지금 턴의 ESC 중단 경로(escGate) — 턴 밖이면 null. 외부 `/stop` 이 이것을 부른다. */
+  getTurnStop?: () => (() => void) | null;
+  /** 미소비 키 수 — 기본 tui.ts 키 큐. */
+  pendingKeyCount?: () => number;
+}
+
+export function createDashboardExternalInputHost(deps: DashboardExternalInputHostDeps): ExternalInputHost {
+  // ⚠️ submit/insertAtCursor 는 textInput 이 내려간 뒤에도 남아 있다 — «composer 가 떠 있나»는
+  //    getBufferText 유무로만 판단한다(내려가면 undefined).
+  const composerLive = (): boolean => typeof deps.promptCtl.getBufferText === 'function';
+  return {
+    isTurnActive: deps.isTurnActive,
+    composerText: () => deps.promptCtl.getBufferText?.(),
+    hasPendingKeys: () => (deps.pendingKeyCount ?? pendingKeyCount)() > 0,
+    submit: (text, source) => {
+      if (!composerLive() || !deps.promptCtl.submit) return false;
+      return deps.promptCtl.submit({ text, source }) !== false;
+    },
+    requestStop: () => {
+      const stop = deps.getTurnStop?.() ?? null;
+      if (!stop) return false;
+      stop();
+      return true;
+    },
+    onExternalStop: (result) => {
+      deps.pushNotice(result === 'stopped' ? '⏹ 외부 /stop — 대기열을 건너뛰고 이 턴에 중단을 요청했습니다'
+        : result === 'no-turn' ? '⏹ 외부 /stop — 도는 턴이 없어 무시했습니다'
+        : '⏹ 외부 /stop — 이 턴의 중단 경로에 닿지 못했습니다(Esc 로 멈춰 주세요)');
+    },
+    onQueueChange: (pending, event) => {
+      if (event === 'queued') {
+        const notice = renderExternalInputQueueNotice(pending);
+        if (notice) deps.pushNotice(notice);
+        return;
+      }
+      deps.pushNotice(pending.length > 0
+        ? `⤵ 외부 입력 1건 전송 · 남은 대기 ${pending.length}건`
+        : '⤵ 외부 입력 1건 전송');
+    },
+  };
+}
+
+/**
+ * 외부 `/stop` 을 지금 턴의 escGate 에 «Esc 와 같은 경로»로 넘긴다.
+ * 자식이 돌아 확인 모달이 뜨면 한 번 더 눌러 확정한다 — 바깥 `/stop` 은 «명시 의지»이고,
+ * escGate 자신도 두 번째 Esc 를 «철회가 아니라 의지의 반복»(A2)으로 읽는다.
+ */
+export function stopTurnViaEscGate(gate: Pick<EscAbortGate, 'handleEscape' | 'isGateOpen'>): void {
+  // 이미 확인 모달이 떠 있으면(사용자가 Esc 를 한 번 눌렀다) 한 번이 곧 확정이다.
+  const wasOpen = gate.isGateOpen();
+  gate.handleEscape();
+  if (!wasOpen && gate.isGateOpen()) gate.handleEscape();
+}

package/src/dashboard/input/internal-turn.ts

@@ -0,0 +1,261 @@
+// ── 내부 턴 문 `startTurnIfIdle` (TUI-H2-INTERNAL-TURN · 0.2.31 · 2026-10-16) ──────────────
+//
+// 🚨 무엇을 푸는가: TUI 는 «사람이 Enter 를 쳐야만» 턴이 열린다. 자율 재개(H3 턴 끝 재개 · H4 우편 ·
+//   H5 자기 예약)가 지나갈 «문»이 없어서, 지금까지 바깥 깨움은 입력칸 버퍼를 바꿔치고 합성 Enter 를
+//   넣는 길(`hostControl.submit`)뿐이었다 — 대표 비침투(입력칸 주입 0)에 못 쓴다.
+// ⭐ 이 모듈은 «문» 하나다: 한가할 때만 내부 턴을 연다. 거부는 에러가 아니라 «사유 값»이다(codex
+//   `start_turn_if_idle` 꼴). 판정·상태는 여기, 대시보드(index.ts)는 얇은 배선만 한다.
+// ⛔ 입력칸 버퍼·`injectKey`·`hostControl.submit` 을 만지지 않는다. 입력 루프에는 «비켜 달라»만 청한다
+//   (`TextInputInternalTurnYieldPort` — 버퍼가 비었을 때만 textInput 이 스스로 물러난다).
+// ⛔ 이번 조각은 문만 — H3/H4/H5 호출자는 붙이지 않는다.
+//
+// 세 얼굴:
+//   관측 = debug.log('tui.autoturn', 'opened' | 'rejected', { origin, reason, turnId })
+//   인지 = NotIdle · HumanTyping · Superseded · Disabled · Cap
+//   힐링 = 열리면 같은 턴 실행 경로로 한 턴(화면엔 «↻ 자동 재개(<origin>): <이유>» 한 줄) ·
+//          거부되면 호출자가 사유를 보고 다음 idle 에 다시 부른다 · 실패 시 사유 로그(TF 가 본다)
+
+import type { InputResult, TextInputInternalTurnYieldPort } from '../../chat/index.js';
+import { debug } from '../../debug/log.js';
+import type { SubmitTurnIntent } from '../../input/input-intent.js';
+import { lastHumanKeyAt as tuiLastHumanKeyAt, pendingKeyCount as tuiPendingKeyCount } from '../../tui.js';
+
+/** 내부 턴의 출처 — 화면 한 줄·관측·정책이 이 값으로 갈린다. 새 출처는 여기에 더한다. */
+export type InternalTurnOrigin =
+  | 'autowake'
+  | 'msg-wake'
+  | 'scheduled'
+  | 'child-complete'
+  | 'goal-continue'
+  | 'test';
+
+/** 거부 사유 — 에러가 아니라 값이다. 호출자는 이 값을 보고 다음 idle 에 다시 부를지 정한다. */
+export type InternalTurnRejectReason =
+  /** 턴이 도는 중이거나, 입력칸이 안 떠 있거나(다른 창·모달), 앞 내부 턴이 아직 안 시작됐다. */
+  | 'NotIdle'
+  /** 입력칸에 글자 · 안 읽힌 키 · 턴 중 쳐 둔 글 · 마지막 사람 입력 뒤 조용창 안. */
+  | 'HumanTyping'
+  /** `expectedPrevTurnId` 가 지금의 마지막 턴과 다르다 = 그 사이 사람이 턴을 열었다. */
+  | 'Superseded'
+  /** 켜짐 스위치가 꺼져 있다. */
+  | 'Disabled'
+  /** 호출자가 넘긴 상한 판정(상한 값 자체는 H3 몫 — 여기선 존중만 한다). */
+  | 'Cap';
+
+export interface StartTurnIfIdleOptions {
+  origin: InternalTurnOrigin;
+  /** 화면 «↻ 자동 재개(<origin>): <이유>» 의 이유 한 줄. 없으면 origin 만 그린다. */
+  reason?: string;
+  /** 호출자가 «이 턴 다음에 이어 간다»고 본 직전 턴 id. 다르면 Superseded. */
+  expectedPrevTurnId?: string;
+  /** 호출자가 이미 상한에 닿았다고 판정했으면 true — 문은 Cap 으로 거부한다. */
+  capReached?: boolean;
+}
+
+export type StartTurnIfIdleResult =
+  | { opened: true; turnId: string }
+  | { opened: false; reason: InternalTurnRejectReason; detail?: string };
+
+/** 대시보드가 입력 루프에서 꺼내 실행할 내부 턴 한 건. */
+export interface InternalTurnRequest {
+  turnId: string;
+  input: string;
+  origin: InternalTurnOrigin;
+  reason?: string;
+}
+
+export interface InternalTurnGateDeps {
+  /** 켜짐 스위치. 기본: `ELANOUS_TUI_AUTOTURN` 이 '0'/'off'/'false' 가 아니면 켜짐. */
+  isEnabled?: () => boolean;
+  /** 모델 턴이 도는 중인가(대시보드 `streamingInFlight`). */
+  isTurnRunning: () => boolean;
+  /** 입력칸이 앞에 있나(chat-main 이 입력 소유 ∧ 막는 모달 없음). 없으면 늘 앞이라고 본다. */
+  isInputForeground?: () => boolean;
+  /** 입력칸의 살아 있는 버퍼(마운트 안 됐으면 undefined). */
+  getBufferText: () => string | undefined;
+  /** 턴 중 쳐 둔 글(typeahead 버퍼 ⊕ 대기 제출) 수. */
+  getTypeaheadCount: () => number;
+  /** 아직 readKey 가 안 읽은 키 수. 기본: tui `pendingKeyCount`. */
+  pendingKeyCount?: () => number;
+  /** 마지막 사람 키 시각(ms · 0 = 없음). 기본: tui `lastHumanKeyAt`. */
+  lastHumanKeyAt?: () => number;
+  now?: () => number;
+  /** 마지막 사람 입력 뒤 이 시간 안이면 HumanTyping. 기본 10초. */
+  humanQuietMs?: number;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export interface InternalTurnGate {
+  /** 모든 자율 재개가 지나는 문. 동기 판정 — 열리면 입력 루프에 «비켜 달라»를 청한다. */
+  startTurnIfIdle(input: string, opts: StartTurnIfIdleOptions): StartTurnIfIdleResult;
+  /** textInput 에 넘기는 자리 — 마운트되면 attach, 내려가면 detach. */
+  readonly port: TextInputInternalTurnYieldPort;
+  /** 입력 루프가 «비켜 줬다»고 돌아왔을 때 실행할 요청을 꺼낸다(정확히 한 번). */
+  takePending(): InternalTurnRequest | null;
+  /** 사람이 턴을 열었다(제출이 받아들여졌다) — Superseded 의 기준이 바뀐다. */
+  noteHumanTurn(): string;
+  /** 턴이 끝나 입력 루프로 돌아왔다 — 내부 턴 «진행 중» 표지를 내린다. */
+  noteTurnSettled(): void;
+  /** 지금 도는 턴이 내부 턴인가 — 사람 후속 입력을 그 턴에 끼워 넣지(steer) 않는 데 쓴다. */
+  isInternalTurnActive(): boolean;
+  /** 마지막으로 열린 턴 id(사람·내부) — 호출자가 `expectedPrevTurnId` 로 쓴다. */
+  lastTurnId(): string | null;
+}
+
+export const DEFAULT_HUMAN_QUIET_MS = 10_000;
+
+export function isInternalTurnEnabledByEnv(env: NodeJS.ProcessEnv = process.env): boolean {
+  const v = (env.ELANOUS_TUI_AUTOTURN ?? '').trim().toLowerCase();
+  return !(v === '0' || v === 'off' || v === 'false');
+}
+
+export function createInternalTurnGate(deps: InternalTurnGateDeps): InternalTurnGate {
+  const isEnabled = deps.isEnabled ?? (() => isInternalTurnEnabledByEnv());
+  const pendingKeys = deps.pendingKeyCount ?? tuiPendingKeyCount;
+  const lastHumanKeyAt = deps.lastHumanKeyAt ?? tuiLastHumanKeyAt;
+  const now = deps.now ?? Date.now;
+  const quietMs = deps.humanQuietMs ?? DEFAULT_HUMAN_QUIET_MS;
+  const log = deps.log ?? ((c, e, d) => debug.log(c, e, d));
+
+  let requestYield: (() => boolean) | null = null;
+  let pending: InternalTurnRequest | null = null;
+  let internalActive = false;
+  let lastId: string | null = null;
+  /** 열린(아직 안 꺼낸) 내부 턴 «직전»의 lastId — 거둘 때 되돌린다(실행 안 된 턴이 Superseded 기준이 되지 않게). */
+  let idBeforePending: string | null = null;
+  let seq = 0;
+
+  /** 열었지만 실행되지 않은 내부 턴을 거둔다 — 사람이 먼저다. */
+  const withdrawPending = (detail: string): void => {
+    if (!pending) return;
+    const { origin, turnId } = pending;
+    pending = null;
+    lastId = idBeforePending;
+    log('tui.autoturn', 'rejected', { origin, reason: 'HumanTyping', turnId, detail: `late:${detail}` });
+  };
+
+  const reject = (
+    origin: InternalTurnOrigin,
+    reason: InternalTurnRejectReason,
+    detail?: string,
+  ): StartTurnIfIdleResult => {
+    log('tui.autoturn', 'rejected', { origin, reason, turnId: null, ...(detail ? { detail } : {}) });
+    return detail ? { opened: false, reason, detail } : { opened: false, reason };
+  };
+
+  const humanTypingDetail = (): string | null => {
+    const buffer = deps.getBufferText();
+    if (buffer !== undefined && buffer.length > 0) return 'buffer';
+    if (pendingKeys() > 0) return 'unread-keys';
+    if (deps.getTypeaheadCount() > 0) return 'typeahead';
+    const last = lastHumanKeyAt();
+    if (last > 0 && now() - last < quietMs) return 'quiet-window';
+    return null;
+  };
+
+  const port: TextInputInternalTurnYieldPort = {
+    attach(fn) { requestYield = fn; },
+    detach(opts) {
+      requestYield = null;
+      // 물러나지 않고 내려갔다(사람이 먼저 Enter·Esc 등으로 끝냈다) — 연 턴을 거둔다.
+      if (!opts?.yielded) withdrawPending('input-closed');
+    },
+    declined(detail) {
+      // 판정과 물러남 사이에 사람이 글자를 넣었다 — 연 턴을 거둔다(사람이 먼저다).
+      withdrawPending(detail);
+    },
+  };
+
+  return {
+    port,
+    startTurnIfIdle(input, opts) {
+      const { origin } = opts;
+      if (!isEnabled()) return reject(origin, 'Disabled');
+      if (opts.capReached) return reject(origin, 'Cap');
+      if (deps.isTurnRunning()) return reject(origin, 'NotIdle', 'turn-running');
+      if (pending) return reject(origin, 'NotIdle', 'internal-turn-pending');
+      if (!requestYield) return reject(origin, 'NotIdle', 'input-not-mounted');
+      if (deps.isInputForeground && !deps.isInputForeground()) return reject(origin, 'NotIdle', 'input-not-foreground');
+      if (opts.expectedPrevTurnId !== undefined && opts.expectedPrevTurnId !== lastId) {
+        return reject(origin, 'Superseded', `expected=${opts.expectedPrevTurnId} last=${lastId ?? 'none'}`);
+      }
+      const typing = humanTypingDetail();
+      if (typing) return reject(origin, 'HumanTyping', typing);
+      const text = input.trim();
+      if (!text) return reject(origin, 'NotIdle', 'empty-input');
+
+      const turnId = `auto-${++seq}`;
+      idBeforePending = lastId;
+      pending = { turnId, input: text, origin, ...(opts.reason ? { reason: opts.reason } : {}) };
+      // ⭐ 물러남은 textInput 의 몫 — 버퍼가 비었을 때만 true 를 낸다(입력칸 무접촉).
+      let yielded = false;
+      try { yielded = requestYield(); } catch { yielded = false; }
+      if (!yielded) {
+        pending = null;
+        return reject(origin, 'HumanTyping', 'input-declined');
+      }
+      lastId = turnId;
+      log('tui.autoturn', 'opened', { origin, reason: opts.reason ?? null, turnId });
+      return { opened: true, turnId };
+    },
+    takePending() {
+      const req = pending;
+      pending = null;
+      if (req) internalActive = true;
+      return req;
+    },
+    noteHumanTurn() {
+      const id = `human-${++seq}`;
+      lastId = id;
+      internalActive = false;
+      return id;
+    },
+    noteTurnSettled() {
+      internalActive = false;
+    },
+    isInternalTurnActive: () => internalActive,
+    lastTurnId: () => lastId,
+  };
+}
+
+// ── 입력 정책 (grok-build `InputPolicy` 꼴) ────────────────────────────────────────────
+// 내부 턴은 ① 슬래시를 해석하지 않는다(늘 plain) ② 입력 히스토리에 넣지 않는다
+// ③ 화면엔 사람 발화 에코 대신 «↻ 자동 재개» 한 줄만 ④ 사람 후속 입력은 그 턴에 끼워 넣지 않는다.
+
+/** 내부 턴의 제출 의도 — 슬래시·sticky·exit 해석 없이 늘 plain 턴이다. */
+export function resolveInternalTurnSubmitIntent(
+  req: InternalTurnRequest,
+  sessionId?: string | null,
+): SubmitTurnIntent {
+  return {
+    kind: 'submit-turn',
+    // 닫힌 sourceKind 어휘를 늘리지 않는다 — 자동화 계열 'scheduled' 에 출처를 싣는다.
+    source: { kind: 'scheduled', jobId: `internal-turn:${req.origin}:${req.turnId}` },
+    text: req.input,
+    route: 'plain',
+    ...(sessionId ? { sessionId } : {}),
+  };
+}
+
+/** 화면 한 줄 — 사람 발화처럼 보이지 않게 «↻ 자동 재개(<origin>): <이유>». */
+export function formatInternalTurnBanner(req: Pick<InternalTurnRequest, 'origin' | 'reason'>): string {
+  const why = (req.reason ?? '').replace(/\s+/g, ' ').trim();
+  return why ? `↻ 자동 재개(${req.origin}): ${why}` : `↻ 자동 재개(${req.origin})`;
+}
+
+/** 입력 루프가 돌아온 직후의 분기 — 대시보드는 «이 함수»를 부른다(시험이 같은 함수를 문다).
+ *  - `human`    : 사람 입력 그대로(물러남 아님). 아직 열린 내부 턴이 있으면 거둔다.
+ *  - `reenter`  : 물러났는데 꺼낼 게 없다(이미 거둬짐) — 입력으로 되돌아간다.
+ *  - `internal` : 꺼낸 요청 ⊕ 같은 턴 실행 경로에 넣을 제출 결과(텍스트 = 내부 입력 · 출처 없음). */
+export type InternalTurnConsumeResult =
+  | { kind: 'human'; input: InputResult }
+  | { kind: 'reenter' }
+  | { kind: 'internal'; request: InternalTurnRequest; input: InputResult };
+
+export function consumeInternalTurnYield(gate: InternalTurnGate, input: InputResult): InternalTurnConsumeResult {
+  gate.port.detach({ yielded: input.yieldedToInternalTurn === true });
+  if (!input.yieldedToInternalTurn) return { kind: 'human', input };
+  const request = gate.takePending();
+  if (!request) return { kind: 'reenter' };
+  return { kind: 'internal', request, input: { text: request.input, submitted: true } };
+}

package/src/dashboard/input/log-fold-binding.ts

@@ -0,0 +1,18 @@
+import { addDefaultBinding, registerAction } from '../../input-core/index.js';
+
+export const LOG_FOLD_TOGGLE_ALL_ACTION = 'log.fold.toggle-all';
+
+/**
+ * #19 — `Ctrl+X f` from the input. Input focus never reaches the main-loop
+ * chord (`matchDashboardChordAction`); the textarea arms the input-core
+ * `ctrl+x` leader instead, so the binding lives here next to `ctrl+x s/c/g`.
+ */
+export function registerLogFoldInputBinding(toggleAll: () => void): void {
+  registerAction({
+    id: LOG_FOLD_TOGGLE_ALL_ACTION,
+    description: 'Toggle every folded log block (same as log-pane F).',
+    handler: () => { toggleAll(); },
+    allowOverwrite: true,
+  });
+  addDefaultBinding({ matcher: 'ctrl+x f', actionId: LOG_FOLD_TOGGLE_ALL_ACTION });
+}

package/src/dashboard/input/mouse-wiring.ts

@@ -77,6 +77,7 @@ import {
   modeSegment,
   ptyShellCountSegment,
   runningAgentsSegment,
+  runningBuildSegment,
   controllerSegment,
   shellRollupSegment,
   sshSegment,
@@ -85,11 +86,12 @@ import {
   vwSegment,
   voiceSegment,
   type GitSegmentState,
+  type RunningBuildState,
   type ShellRollupSummary,
   type StatusBarRenderOptions,
   type VwSummary,
 } from '../../status/bar.js';
-import type { ActiveProviderInfo } from '../../provider-summary.js';
+import type { StatusProviderInfo } from '../../status/status-provider-info.js';
 import { modelDisplayForRotationEntry, type RotationEntry } from '../../user-config.js';
 import {
   createWdPickerRecipe,
@@ -137,6 +139,12 @@ export type DashboardPaneHitTarget = Extract<
   HitTarget,
   { kind: 'pane-body' | 'pane-title' | 'pane-nav-tab' }
 >;
+/** Tag the git pill with an axis label (`트리`) without touching the caller's state. */
+function labelGitState(state: GitSegmentState | string | null | undefined, label: string | undefined): GitSegmentState | string | undefined {
+  if (!label || state === null || state === undefined) return state ?? undefined;
+  return typeof state === 'string' ? { branch: state, label } : { ...state, label };
+}
+
 export type DashboardMousePreflightInputClassifier = (
   row: number,
   col: number,
@@ -153,7 +161,7 @@ export type DashboardMousePreflightPaneClassifier = (
 export interface DashboardStatusInput {
   swd: string;
   gitState?: GitSegmentState | string | null;
-  providerInfo: ActiveProviderInfo;
+  providerInfo: StatusProviderInfo;
   contextUsedTokens?: number;
   tmuxLabel?: string | null;
   sshLabel?: string | null;
@@ -179,6 +187,9 @@ export interface DashboardStatusInput {
    *  passes the latest label through here; null/empty means the voice
    *  segment is hidden (idle). */
   voiceLabel?: string | null;
+  /** The code this TUI process booted with. Present → a `▶ 실행` pill
+   *  follows the git pill, which is then labelled `트리`. Omit to hide. */
+  runningBuild?: RunningBuildState | null;
   theme?: ThemeTokens;
 }
 
@@ -870,9 +881,11 @@ export function createDashboardMouseWiring(deps: DashboardMouseWiringDeps): Dash
     const opts: StatusBarRenderOptions = { theme: input.theme, compact: cols < 100 };
     const segments: Array<{ name: PillName | null; render: string }> = [
       { name: 'workingDir', render: sessionCwdSegment(input.swd, opts) },
-      { name: null,         render: gitSegment(input.swd, input.gitState ?? undefined, opts) },
-      { name: 'model',      render: modelSegment(input.providerInfo, opts) },
+      { name: null,         render: gitSegment(input.swd, labelGitState(input.gitState, input.runningBuild ? '트리' : undefined), opts) },
     ];
+    const runningBuildRender = runningBuildSegment(input.runningBuild, opts);
+    if (runningBuildRender) segments.push({ name: null, render: runningBuildRender });
+    segments.push({ name: 'model', render: modelSegment(input.providerInfo, opts) });
     const runningAgentsRender = runningAgentsSegment(input.runningAgents ?? 0, opts);
     if (runningAgentsRender) segments.push({ name: null, render: runningAgentsRender });
     const controllerRender = controllerSegment(input.controller, opts);