elanous 0.2.38 → 0.2.41

package/src/task-orchestrator/surfaces/self-implement.ts

@@ -123,6 +123,8 @@ export interface PodChildEvidence {
   /** Bounded, redacted diagnostics copied only from a failed child terminal result. */
   error?: string;
   detail?: string;
+  /** Tail of the child detail, retained separately so long reports keep their final diagnostic lines. */
+  detailTail?: string;
   stderr?: string;
   /** Bounded, redacted complete Pod log tail. Separate from child stderr to avoid replacing stronger child facts. */
   podLogTail?: string[];
@@ -130,6 +132,8 @@ export interface PodChildEvidence {
   podLogUnavailable?: string;
   exitCode?: number;
   classification?: string;
+  /** Why the child assigned its failure classification; independent from the label itself. */
+  classificationBasis?: string;
   scopeEscape?: true;
   outOfScopeEdits?: unknown;
   /** SCOPE-ESCAPE-AS-REFINE — why held out-of-scope edits stop the run (deletion · protected path · cap). Present only with scopeEscape. */
@@ -156,6 +160,14 @@ export interface PodChildEvidence {
   goalPlanRevision?: SelfDevJobResult['goalPlanRevision'];
 }
 
+function utf8Tail(value: string, maxBytes: number): string {
+  const bytes = Buffer.from(value, 'utf8');
+  let start = Math.max(0, bytes.length - maxBytes);
+  // Move past continuation bytes so decoding starts at a complete UTF-8 code point.
+  while (start < bytes.length && (bytes[start]! & 0xc0) === 0x80) start++;
+  return bytes.subarray(start).toString('utf8');
+}
+
 const SCOPE_STOP_REASON_ORDER: readonly ScopeStopReason[] = SCOPE_STOP_REASONS;
 
 /** Stop reasons for held out-of-scope edits: the child's own `scopeStopReasons` (orchestrator decideScopeExpansion) plus
@@ -218,12 +230,18 @@ export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChild
   const classification = scopeEscape ? 'scope-escape'
     : typeof abandoned?.classification === 'string' ? redactSecretText(abandoned.classification)
       : typeof o.failureClassification === 'string' ? redactSecretText(o.failureClassification) : undefined;
+  const rawClassificationBasis = abandoned?.classificationBasis ?? o.classificationBasis;
+  const classificationBasis = typeof rawClassificationBasis === 'string' && rawClassificationBasis.trim()
+    ? redactSecretText(rawClassificationBasis).slice(0, 200) : undefined;
   const evidence: PodChildEvidence = {
     ...(failedText(o.error) ? { error: failedText(o.error) } : {}),
     ...(failedText(o.detail) ? { detail: failedText(o.detail) } : {}),
+    ...(o.ok === false && typeof o.detail === 'string' && o.detail.trim()
+      ? { detailTail: utf8Tail(redactSecretText(o.detail), 4_096) } : {}),
     ...(failedText(o.stderr) ? { stderr: failedText(o.stderr) } : {}),
     ...(failureExitCode !== undefined ? { exitCode: failureExitCode } : {}),
     ...(classification ? { classification } : {}),
+    ...(classificationBasis ? { classificationBasis } : {}),
     ...(scopeEscape ? { scopeEscape: true, scopeStopReasons } : {}),
     ...(outOfScopeEdits !== undefined ? { outOfScopeEdits } : {}),
     ...(newScope ? { newScope } : {}),

package/src/tool-runtime/skill-exec-runtime.ts

@@ -7,6 +7,15 @@ import { getUserConfig } from '../user-config.js';
 import type { LLMToolSpec } from '../llm.js';
 import type { ToolRuntime } from './types.js';
 
+/** Whole nested-skill budget; the inner LLM idle timer only bounds one stream. */
+export const SKILL_EXEC_TIMEOUT_MS = 300_000;
+
+export interface SkillExecRunOptions {
+  signal?: AbortSignal;
+  /** Test seam for a short deterministic whole-skill deadline. */
+  timeoutMs?: number;
+}
+
 export interface SkillExecArgs {
   /** Exact name of the skill to execute. */
   skill: string;
@@ -19,6 +28,11 @@ export interface SkillExecResult extends Record<string, unknown> {
   output: string;
   ok: boolean;
   error?: string;
+  discoveryCard?: string;
+}
+
+export interface SkillExecDiscoveryDeps {
+  discoverPlugin?: (gap: string, deps?: { signal?: AbortSignal }) => Promise<{ card: string }>;
 }
 
 export type SkillExecIndexProvider = () => readonly SkillIndexEntry[];
@@ -76,7 +90,11 @@ export function buildSkillExecTool(): LLMToolSpec {
   };
 }
 
-export async function dispatchSkillExec(args: SkillExecArgs): Promise<SkillExecResult> {
+export async function dispatchSkillExec(
+  args: SkillExecArgs,
+  deps: SkillExecDiscoveryDeps = {},
+  options: SkillExecRunOptions = {},
+): Promise<SkillExecResult> {
   const { skill, task } = args;
   const extra = getUserConfig().skillRouter.harnessExecAllowlist;
   const index = obtainSkillIndex();
@@ -116,11 +134,83 @@ export async function dispatchSkillExec(args: SkillExecArgs): Promise<SkillExecR
     };
   }
 
-  const result = await invokeResearch(task, { skill });
+  if (options.signal?.aborted) {
+    return { skill, ok: false, error: 'skill-exec-cancelled', output: '스킬 실행이 취소됐습니다. 현재 근거로 다음 단계를 결정하세요.' };
+  }
+
+  // Race the whole invocation so even a provider that ignores abort gives the
+  // parent a failed tool result. Cooperative LLM and child tools get the same
+  // signal and stop their own work.
+  const child = new AbortController();
+  const timeoutMs = options.timeoutMs ?? SKILL_EXEC_TIMEOUT_MS;
+  let settled = false;
+  let finishEarly: ((reason: 'skill-exec-timeout' | 'skill-exec-cancelled') => void) | undefined;
+  const interrupted = new Promise<'skill-exec-timeout' | 'skill-exec-cancelled'>((resolve) => {
+    finishEarly = (reason) => {
+      if (settled) return;
+      settled = true;
+      resolve(reason);
+      child.abort();
+    };
+  });
+  const onParentAbort = () => finishEarly?.('skill-exec-cancelled');
+  options.signal?.addEventListener('abort', onParentAbort, { once: true });
+  const timer = setTimeout(() => finishEarly?.('skill-exec-timeout'), timeoutMs);
+  observe('started', { skill, timeoutMs });
+  let progressChunks = 0;
+  let progressBytes = 0;
+  let result: Awaited<ReturnType<typeof invokeResearch>> | undefined;
+  let interruption: 'skill-exec-timeout' | 'skill-exec-cancelled' | undefined;
+  try {
+    const outcome = await Promise.race([
+      invokeResearch(task, { skill, signal: child.signal, onProgress: (delta) => {
+        progressChunks += 1;
+        progressBytes += delta.length;
+        if (progressChunks === 1 || progressChunks % 32 === 0) {
+          observe('progress', { skill, progressChunks, progressBytes });
+        }
+      } }).then((value) => ({ result: value })),
+      interrupted.then((reason) => ({ interruption: reason })),
+    ]);
+    settled = true;
+    if ('interruption' in outcome) interruption = outcome.interruption;
+    else result = outcome.result;
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener('abort', onParentAbort);
+  }
+  if (interruption) {
+    observe('interrupted', { skill, reason: interruption, timeoutMs });
+    return {
+      skill,
+      ok: false,
+      error: interruption,
+      output: interruption === 'skill-exec-timeout'
+        ? `스킬 실행 시간이 초과됐습니다 (${timeoutMs}ms). 범위를 좁혀 다시 시도하거나 현재 근거로 답하세요.`
+        : '스킬 실행이 취소됐습니다. 현재 근거로 다음 단계를 결정하세요.',
+    };
+  }
+  if (!result) throw new Error('skill_exec completed without a result');
+  observe('completed', { skill, ok: result.ok, progressChunks, progressBytes, durationMs: result.durationMs });
+  // A low-quality research result is a capability gap. Keep the original failure,
+  // and attach a bounded discovery card rather than silently switching tools.
+  let discoveryCard: string | undefined;
+  if (!result.ok && /\b(?:no data|no evidence|missing|unavailable|not found|empty)\b|(?:자료가 없|데이터가 없|자료 부족|미확인|찾지 못)/i
+    .test(`${result.output} ${result.error ?? ''}`)) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error('plugin discovery time budget exhausted')), 10_000);
+    try {
+      const discovery = deps.discoverPlugin ?? (await import('../research/plugin-discovery.js')).discoverResearchPlugin;
+      const found = await discovery(task, { signal: controller.signal });
+      discoveryCard = found.card;
+    } catch { /* The skill failure remains the authoritative result. */ }
+    finally { clearTimeout(timer); }
+  }
   return {
     skill,
     ok: result.ok,
-    output: result.output,
+    output: discoveryCard ? `${result.output}\n\n${discoveryCard}` : result.output,
+    ...(discoveryCard ? { discoveryCard } : {}),
     ...(result.error ? { error: result.error } : {}),
   };
 }
@@ -128,7 +218,7 @@ export async function dispatchSkillExec(args: SkillExecArgs): Promise<SkillExecR
 export const skillExecRuntime: ToolRuntime<SkillExecArgs, SkillExecResult> = {
   id: 'skill_exec',
   spec: buildSkillExecTool(),
-  async run(req) {
-    return dispatchSkillExec(req);
+  async run(req, ctx) {
+    return dispatchSkillExec(req, {}, { signal: ctx.signal });
   },
 };

package/src/tui/entry.ts

@@ -7,7 +7,7 @@ import { createInlineEditorState, type InlineEditorState } from '../input-core/i
 import { isNewSessionCommand, nextTuiTitle, requestNewTuiSession } from './slash/new-session.js';
 import { COMPACT_BUSY_STATUS, COMPACT_NO_SESSION_STATUS, isCompactCommand } from './slash/compact-command.js';
 import { RESUME_BUSY_STATUS, parseResumeCommand } from './slash/resume-command.js';
-import { reportTuiTurn } from '../pty-shell/tui-run-state.js';
+import { reportTuiProgress, reportTuiTurn } from '../pty-shell/tui-run-state.js';
 import { createPasteFold } from '../chat/paste-fold.js';
 import { createTurnTypeaheadState, dequeueTurnTypeaheadHandoff, drainTurnTypeaheadOnce, restoreTurnTypeaheadSubmission } from '../chat/turn-typeahead.js';
 import { debug } from '../debug/log.js';
@@ -100,7 +100,8 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
   let sidetabRemoteFrame: string | null = null;
   let sidetabRows: import('./sidetab/list.js').SidetabRow[] = [];
   let sidetabApi: typeof import('./sidetab/list.js') | null = null;
-  let sidetabAttachments: import('./sidetab/attach.js').SidetabAttachmentController | null = null;
+  // ⚠️ `as` 단언은 «null 로 좁혀지는» 흐름 분석을 푸는 것 — 값은 클로저(ensureSidetabAttachments) 안에서만 바뀐다.
+  let sidetabAttachments: import('./sidetab/attach.js').SidetabAttachmentController | null = null as import('./sidetab/attach.js').SidetabAttachmentController | null;
   let pendingSidetabSwitch: string | null = null;
   let sidetabRefreshTimer: ReturnType<typeof setInterval> | null = null;
   let paintingCoordinatorFrame = false;
@@ -345,9 +346,11 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
     const sidetabLines = sidetabOpen
       ? sidetabApi!.formatSidetabLines(sidetabRows, sidetabSelected, sidetabWidth, Math.max(1, rows - 1), sidetabMode)
       : [];
-    const screenLines = sidetabOpen
-      ? lines.map((line, index) => `${sidetabLines[index] ?? ' '.repeat(sidetabWidth)}│${line}`)
-      : lines;
+    const screenLineCount = sidetabOpen ? Math.max(lines.length, sidetabLines.length) : lines.length;
+    const screenLines = Array.from({ length: screenLineCount }, (_, index) => {
+      const line = lines[index] ?? '';
+      return sidetabOpen ? `${sidetabLines[index] ?? ' '.repeat(sidetabWidth)}│${line}` : line;
+    });
     process.stdout.write(`\x1b[H\x1b[2J${screenLines.join('\n')}\x1b[${promptRow};${prompt.cursorCol + (sidetabOpen ? sidetabWidth + 1 : 0)}H\x1b[?25h`);
     if (sidetabAttachments?.hasModal() && !paintingCoordinatorFrame) sidetabAttachments.refresh();
   };
@@ -479,6 +482,7 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
   };
 
   let restoreCliStderrSink: (() => void) | null = null;
+  let restoreTuiStderrOwner: (() => void) | null = null;
 
   const refreshAtPicker = async (): Promise<void> => {
     const query = editor.text.slice(0, editor.cursor).match(/(?:^|\s)@([\p{L}\p{N}_./~\\-]*)$/u);
@@ -550,6 +554,8 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
     // herdr pane 이면 턴 시작·끝을 working → idle 로 신고한다(`eln herdr prompt --wait` 가 이것을 기다린다).
     // 녹음기는 startTuiSelfReport 가 이미 열었다 — 없으면 아무것도 안 한다.
     reportTuiTurn('busy');
+    // 턴 시작도 진전이다(SURVIVAL-PROGRESS-CLOCK) — 마지막 진전 시각의 0초를 잡는다.
+    reportTuiProgress();
     // An internal turn says where it came from (classic «↻ 자동 재개(<origin>): <이유>») instead of looking typed.
     // TUI-GOAL-INTERIM-QUIET — the log draws a recognized internal input in place («↻ 자동 재개(<origin>)»), so the
     // notice list would only repeat it under the last reply; the status line still names it while the turn runs.
@@ -570,6 +576,8 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
         observeSession(turnSessionId, onLocalChatBackgroundStatus, onLocalChatSelfHealthStatus);
         let firstResponseSeen = false;
         return runLocalChatTurn(turnSessionId, turnText, abort.signal, undefined, undefined, (delta) => {
+          // 스트림 텍스트 = 진전 신호 — 마지막 진전 시각을 올린다(녹음기 없으면 아무 일도 안 한다).
+          reportTuiProgress();
           // 첫 응답 경계: 첫 스트림 델타에서 턴 시작 트레이스를 닫는다(endedBy=stream-open).
           if (!firstResponseSeen) {
             firstResponseSeen = true;
@@ -659,6 +667,11 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
     }, 1_000);
   }
   initTui();
+  const { installTuiStderrOwner } = await import('../surface/tui-stderr-owner.js');
+  restoreTuiStderrOwner = installTuiStderrOwner((line) => {
+    pushNotice(`[stderr] ${line}`);
+    render();
+  });
   restoreCliStderrSink = setCliStderrSink(({ source, exitCode, raw }) => {
     // Keep the exact bytes in the normal debug log while rendering only failures through the
     // TUI-owned notice area. Writing the CLI stream to process.stderr would overwrite the prompt.
@@ -1247,10 +1260,15 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
         }
         if (submitted === '/help' || submitted === '/help next') {
           activity.push(
+            'Commands',
             'Next TUI: /side · /sidetab — 세션/PTY 목록',
             '사이드탭: Ctrl+\\ 토글 · ↑↓ 선택 · 빈 prompt Enter=attach · /side new · /side kill',
             '새 PTY: s shell · e elanous · c codex 구독 · l claude code 구독',
             'PTY 분리: Ctrl+\\ 후 d · /term help 는 읽기 전용 목록 명령',
+            '',
+            'Keys',
+            'Enter 전송 · Esc 취소 · PgUp/PgDn 대화 스크롤 · Ctrl+Q 종료',
+            'Ctrl+\\ 사이드탭 토글 · ↑/↓ 목록 이동 · Esc 입력으로 돌아오기',
           );
           status = 'Enter 전송';
           render();
@@ -1358,6 +1376,8 @@ export async function showNextTui(options: NextTuiOptions = {}): Promise<void> {
     sidetabAttachments?.close();
     restoreCliStderrSink?.();
     restoreCliStderrSink = null;
+    restoreTuiStderrOwner?.();
+    restoreTuiStderrOwner = null;
     if (residueTimer !== null) clearTimeout(residueTimer);
     loopCommand?.dispose();
     missionWatchesClosed = true;

package/src/tui/inline-choice.ts

@@ -0,0 +1,188 @@
+import { debug } from '../debug/log.js';
+
+/**
+ * Non-modal, chat-input choice prompt. The caller renders `lines` in the chat
+ * transcript and forwards submitted input to `handleInput`; this keeps the
+ * normal input row visible and allows external PTY text injection to answer.
+ */
+export interface InlineChoiceOption {
+  readonly value: string;
+  readonly label: string;
+  readonly description?: string;
+}
+
+export interface InlineChoiceSpec {
+  readonly id: string;
+  readonly question: string;
+  readonly options: readonly InlineChoiceOption[];
+  readonly multiSelect?: boolean;
+  readonly includeOther?: boolean;
+  /** Omit for an interactive prompt with no deadline. */
+  readonly timeoutMs?: number;
+}
+
+export type InlineChoiceResult =
+  | { readonly selected: readonly string[]; readonly otherText?: string }
+  | { readonly selected: readonly []; readonly cancelled: true; readonly reason: 'cancelled' | 'timeout' };
+
+export type InlineChoiceEvent =
+  | { readonly id: string; readonly outcome: 'answered'; readonly selectedCount: number; readonly elapsedMs: number }
+  | { readonly id: string; readonly outcome: 'cancelled' | 'timeout'; readonly elapsedMs: number };
+
+export interface InlineChoiceDeps {
+  readonly appendLines: (lines: readonly string[]) => void;
+  readonly observe?: (event: InlineChoiceEvent) => void;
+  readonly now?: () => number;
+  readonly schedule?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+  readonly cancelSchedule?: (timer: ReturnType<typeof setTimeout>) => void;
+}
+
+export interface InlineChoiceHandle {
+  readonly promise: Promise<InlineChoiceResult>;
+  /** Returns true only when this input was consumed by the prompt. */
+  handleInput(input: string): boolean;
+  cancel(): void;
+}
+
+export interface InlineChoiceBrokerDeps extends InlineChoiceDeps {}
+
+/** One prompt slot shared by clarification and confirmation requests in a TUI turn. */
+export class InlineChoiceBroker {
+  private active: InlineChoiceHandle | null = null;
+  private activeIdValue: string | null = null;
+
+  constructor(private readonly deps: InlineChoiceBrokerDeps) {}
+
+  get activeId(): string | null { return this.activeIdValue; }
+
+  ask(spec: InlineChoiceSpec): Promise<InlineChoiceResult> {
+    if (this.active) throw new Error('another inline choice is already active');
+    const handle = createInlineChoice(spec, this.deps);
+    this.active = handle;
+    this.activeIdValue = spec.id;
+    void handle.promise.finally(() => {
+      if (this.active !== handle) return;
+      this.active = null;
+      this.activeIdValue = null;
+    });
+    return handle.promise;
+  }
+
+  /** Feed submitted text (including numeric replies injected through a PTY) to the active prompt. */
+  handleInput(input: string): boolean {
+    return this.active?.handleInput(input) ?? false;
+  }
+
+  cancel(): void { this.active?.cancel(); }
+}
+
+/** Cancel the prompt owned by a turn when that turn's streaming UI tears down. */
+export function createInlineChoiceTurnEndCleanup(broker: InlineChoiceBroker): () => void {
+  return () => broker.cancel();
+}
+
+export function formatInlineChoiceLines(spec: InlineChoiceSpec): string[] {
+  const lines = ['', `  ${spec.question}`];
+  spec.options.forEach((option, index) => {
+    lines.push(`  ${index + 1}. ${option.label}${option.description ? ` — ${option.description}` : ''}`);
+  });
+  if (spec.includeOther !== false) lines.push(`  ${spec.options.length + 1}. Other`);
+  lines.push(spec.multiSelect ? '  여러 선택은 번호를 쉼표로 입력하세요. 취소: cancel' : '  번호 또는 Other 답을 입력하세요. 취소: cancel');
+  return lines;
+}
+
+/** Start one inline prompt. A timed-out prompt resolves as cancelled, never as a guessed answer. */
+export function createInlineChoice(
+  spec: InlineChoiceSpec,
+  deps: InlineChoiceDeps,
+): InlineChoiceHandle {
+  if (!spec.id.trim() || !spec.question.trim() || spec.options.length === 0) {
+    throw new Error('inline choice requires an id, question, and at least one option');
+  }
+  const now = deps.now ?? Date.now;
+  const observe = deps.observe ?? ((event: InlineChoiceEvent) => {
+    debug.log('tui.inline-choice', 'settled', event);
+  });
+  const schedule = deps.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const cancelSchedule = deps.cancelSchedule ?? clearTimeout;
+  const startedAt = now();
+  let settled = false;
+  let awaitingOtherText = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let resolvePromise!: (result: InlineChoiceResult) => void;
+  const promise = new Promise<InlineChoiceResult>((resolve) => { resolvePromise = resolve; });
+
+  const finish = (result: InlineChoiceResult, outcome: InlineChoiceEvent['outcome']): void => {
+    if (settled) return;
+    settled = true;
+    if (timer !== null) cancelSchedule(timer);
+    timer = null;
+    const elapsedMs = Math.max(0, now() - startedAt);
+    try {
+      if (outcome === 'answered') {
+        const hasOtherText = 'otherText' in result && Boolean(result.otherText);
+        observe({ id: spec.id, outcome, selectedCount: result.selected.length + (hasOtherText ? 1 : 0), elapsedMs });
+      } else {
+        observe({ id: spec.id, outcome, elapsedMs });
+      }
+    } catch { /* logging must never strand an interactive turn */ }
+    resolvePromise(result);
+  };
+
+  deps.appendLines(formatInlineChoiceLines(spec));
+  if (typeof spec.timeoutMs === 'number' && Number.isFinite(spec.timeoutMs) && spec.timeoutMs > 0) {
+    timer = schedule(() => finish({ selected: [], cancelled: true, reason: 'timeout' }, 'timeout'), spec.timeoutMs);
+  }
+
+  return {
+    promise,
+    handleInput(input) {
+      if (settled) return false;
+      const value = input.trim();
+      if (!value) return true;
+      if (awaitingOtherText) {
+        finish({ selected: [], otherText: value }, 'answered');
+        return true;
+      }
+      if (/^(?:cancel|esc|escape)$/i.test(value)) {
+        finish({ selected: [], cancelled: true, reason: 'cancelled' }, 'cancelled');
+        return true;
+      }
+
+      const selectedIndexes = value.split(',').map((part) => part.trim());
+      const numeric = selectedIndexes.every((part) => /^\d+$/.test(part));
+      if (numeric) {
+        const indexes = selectedIndexes.map(Number);
+        const otherIndex = spec.options.length + 1;
+        if (indexes.some((index) => index < 1 || index > otherIndex)
+          || (!spec.multiSelect && indexes.length !== 1)) {
+          deps.appendLines(['  선택한 번호를 확인해 다시 입력하세요.']);
+          return true;
+        }
+        if (indexes.includes(otherIndex)) {
+          if (indexes.length !== 1 || spec.includeOther === false) {
+            deps.appendLines(['  Other는 단독으로 선택해야 합니다.']);
+            return true;
+          }
+          awaitingOtherText = true;
+          deps.appendLines(['  기타 답을 입력하세요.']);
+          return true;
+        }
+        const selected = [...new Set(indexes)].map((index) => spec.options[index - 1]!.value);
+        finish({ selected }, 'answered');
+        return true;
+      }
+
+      if (spec.includeOther !== false) {
+        finish({ selected: [], otherText: value }, 'answered');
+        return true;
+      }
+      deps.appendLines(['  번호로 답하세요.']);
+      return true;
+    },
+    cancel() {
+      finish({ selected: [], cancelled: true, reason: 'cancelled' }, 'cancelled');
+    },
+  };
+}
+