elanous 0.2.0 → 0.2.4

package/src/prompt/references.ts

@@ -1,39 +1,12 @@
-// Prompt reference expander — T2-P1.
-//
-// One entry point for every `@<kind>:<id>` reference in chat input.
-// Each registered expander handles a specific token family; the
-// overall pipeline composes them in order so new references can be
-// added without touching the call site in dashboard.ts.
-//
-// Supported kinds (T2-P1 landing):
-//
-//   @term:<id>            — TerminalSessionRegistry session snapshot
-//   @term:<id>#<N>        — last N bytes
-//   @term:<id>#all        — full render
-//
-// Planned (T2-P2):
-//
-//   @pane:<id>            — VirtualWindow pane capture
-//   @win:<N>/pane:<id>    — same but qualified
-//
-// Keeping the expander pipeline here (outside dashboard.ts) so the
-// wiring is testable in isolation and the chat submit path stays
-// three lines of plumbing.
+// Chat prompt reference expander. Only terminal session tokens are expanded;
+// other tokens pass through unchanged for the model to see.
 
 import { expandTerminalReferences } from './term-reference.js';
-import { expandVirtualWindowReferences } from './vw-reference.js';
 import type { TerminalSessionRegistry } from '../terminal/session-registry.js';
-import type { AddressBook } from '../virtual-windows/addressing.js';
-import type { WindowRegistry } from '../virtual-windows/window-registry.js';
 
 export interface PromptReferenceDeps {
   /** TerminalSessionRegistry — powers @term:<id>. Omitted = skip. */
   terminalRegistry?: TerminalSessionRegistry;
-  /** AddressBook — powers @pane:<id> + @win:<N>. Omitted = skip. */
-  addressBook?: AddressBook;
-  /** WindowRegistry — required for pane enumeration (@win:<N> /
-   *  @win:<N>#all) and for resolving the live PaneContent. */
-  windowRegistry?: WindowRegistry;
 }
 
 /** Expand every @<kind>:<id> token in `input` into its structured
@@ -44,28 +17,8 @@ export function expandPromptReferences(
   deps: PromptReferenceDeps,
 ): string {
   if (!input.includes('@')) return input;
-  let out = input;
   if (deps.terminalRegistry) {
-    out = expandTerminalReferences(out, deps.terminalRegistry);
+    return expandTerminalReferences(input, deps.terminalRegistry);
   }
-  if (deps.addressBook && deps.windowRegistry) {
-    const reg = deps.windowRegistry;
-    out = expandVirtualWindowReferences(out, {
-      addressBook: deps.addressBook,
-      paneLookup: (paneId) => {
-        const pane = deps.addressBook!.resolvePane(paneId);
-        if (!pane) return null;
-        const window = reg.get(pane.windowId);
-        const content = window?.getPane(paneId) ?? null;
-        if (!content) return null;
-        return { capture: () => content.capture(), kind: content.kind };
-      },
-      listPanes: (winId) => {
-        const window = reg.get(winId);
-        if (!window) return [];
-        return window.listPanes().map((p) => ({ id: p.id, kind: p.content.kind }));
-      },
-    });
-  }
-  return out;
+  return input;
 }

package/src/pty-shell/pty-control-ipc.ts

@@ -9,8 +9,10 @@ import { resetExternalWriteProvenanceForTesting } from './pty-write-provenance.j
 import { parsePtyWriteActor, resolveRemoteControlActor, type PtyWriteActor } from './pty-write-arbiter.js';
 import { isPtyAccessMode } from './pty-ref.js';
 import { debug } from '../debug/log.js';
+import { encodeSgrMouse, mouseModeOffReason, type PtyMouseInput } from './pty-mouse.js';
+import { startPtyRecording, stopPtyRecording } from './pty-recording.js';
 
-const OWNER_PTY_CONTROL_ACTIONS = ['takeover', 'release', 'input-text', 'input-key', 'resize', 'snapshot', 'rename', 'terminate', 'capabilities'] as const;
+const OWNER_PTY_CONTROL_ACTIONS = ['takeover', 'release', 'input-text', 'input-key', 'input-mouse', 'resize', 'snapshot', 'rename', 'terminate', 'capabilities', 'record-start', 'record-stop'] as const;
 export type PtyControlAction = typeof OWNER_PTY_CONTROL_ACTIONS[number];
 type PtyControlStatus = 'success' | 'unknown-pty' | 'denied' | 'failed' | 'write-failed' | 'owner-unreachable';
 
@@ -33,9 +35,11 @@ function isStringList(value: unknown): value is readonly string[] {
 
 export type PtyControlPayload =
   | { readonly chars: string }
+  | PtyMouseInput
   | { readonly cols: number; readonly rows: number }
   | { readonly ansi: boolean }
-  | { readonly nickname: string };
+  | { readonly nickname: string }
+  | { readonly cols: number; readonly rows: number; readonly title?: string };
 
 export interface PtyControlRequestOptions {
   /** 요청자가 주장하는 쓰기 주체. `'agent'` 는 run-identity 일치를 요구한다(`resolveRemoteControlActor`). */
@@ -57,6 +61,10 @@ export interface PtyControlResult {
   readonly diagnostic?: 'owner-unavailable' | 'render-unavailable';
   readonly frameUnavailable?: boolean;
   readonly actions?: readonly string[];
+  readonly path?: string;
+  readonly recordingId?: string;
+  readonly bytes?: number;
+  readonly durationMs?: number;
 }
 
 interface ControlRow {
@@ -294,7 +302,41 @@ async function processPtyControlRequestsOnce(getHandle: (id: string) => PtyContr
       else if (!isOwnerPtyControlAction(row.action)) result = { status: 'denied', reason: 'unsupported-action' };
       else if (row.action === 'capabilities') result = { status: 'success', actions: OWNER_PTY_CONTROL_ACTIONS };
       else if (row.action === 'terminate') result = await terminatePty(handle);
-      else if (row.action === 'snapshot') {
+      else if (row.action === 'record-start' || row.action === 'record-stop') {
+        if (requested === null) result = { status: 'denied', reason: 'invalid-actor' };
+        else if (row.action === 'record-stop') {
+          const stopped = stopPtyRecording(row.pty_id);
+          result = stopped.ok
+            ? { status: 'success', path: stopped.path, bytes: stopped.bytes, durationMs: stopped.durationMs }
+            : { status: 'denied', reason: stopped.reason };
+        } else {
+          const payload = parsePayload(row);
+          if (payload !== null && (typeof payload !== 'object' || Array.isArray(payload)
+            || !('cols' in payload) || !('rows' in payload)
+            || !Number.isSafeInteger(payload.cols) || payload.cols < 1
+            || !Number.isSafeInteger(payload.rows) || payload.rows < 1
+            || ('title' in payload && payload.title !== undefined && typeof payload.title !== 'string'))) {
+            result = { status: 'denied', reason: 'invalid-record-payload' };
+          } else {
+            // The cast header must carry the PTY's real size, and only the owner knows it:
+            // a caller's cols/rows are never trusted, and an unknown size is refused, never guessed.
+            const cols = handle.cols;
+            const rows = handle.rows;
+            if (cols === undefined || rows === undefined) {
+              result = { status: 'denied', reason: 'dimensions-unknown' };
+            } else {
+              const started = startPtyRecording(row.pty_id, {
+                cols,
+                rows,
+                ...(payload && 'title' in payload && typeof payload.title === 'string' ? { title: payload.title } : {}),
+              });
+              result = started.ok
+                ? { status: 'success', recordingId: started.recordingId, path: started.path }
+                : { status: 'denied', reason: started.reason };
+            }
+          }
+        }
+      } else if (row.action === 'snapshot') {
         if (!handle.renderScreen) {
           result = { status: 'failed', reason: 'screen-unavailable' };
         }
@@ -355,6 +397,18 @@ async function processPtyControlRequestsOnce(getHandle: (id: string) => PtyContr
             : outcome === 'denied'
               ? { status: 'denied', reason: 'write-arbiter' }
               : { status: 'failed', reason: 'resize-error' };
+        } else if (row.action === 'input-mouse' && 'kind' in payload && 'x' in payload && 'y' in payload) {
+          let chars: string | undefined;
+          try { chars = encodeSgrMouse(payload); }
+          catch { result = { status: 'denied', reason: 'invalid-mouse-payload' }; }
+          if (chars !== undefined) {
+            const off = mouseModeOffReason(handle);
+            if (off) result = { status: 'denied', reason: off };
+            else {
+              const outcome = writePtyWithOutcome(handle, chars, authorized.actor);
+              result = outcome === 'success' ? { status: 'success' } : outcome === 'denied' ? { status: 'denied', reason: 'write-arbiter' } : { status: 'write-failed', reason: 'adapter-write' };
+            }
+          }
         } else if ((row.action === 'input-text' || row.action === 'input-key') && 'chars' in payload) {
           // ⛔⭐ 여기서 세지 «않는다» — 계기는 `registry.write`(진짜 초크포인트)에 있다.
           //   여기서도 세면 크로스-프로세스 쓰기가 **두 번** 세어진다(`[S]` 리뷰 후 이동).

package/src/pty-shell/pty-mouse.ts

@@ -0,0 +1,75 @@
+/** Bound named-key expansion before allocating its repeated PTY escape sequence. */
+export const MAX_PTY_KEY_REPEAT = 100;
+
+export interface PtyMouseInput {
+  readonly x: number;
+  readonly y: number;
+  readonly button?: 'left' | 'middle' | 'right';
+  readonly kind: 'click' | 'scroll-up' | 'scroll-down';
+}
+
+export function encodeSgrMouse(input: PtyMouseInput): string {
+  const { x, y, kind, button = 'left' } = input;
+  if (!Number.isSafeInteger(x) || x < 1 || !Number.isSafeInteger(y) || y < 1) {
+    throw new Error('mouse coordinates must be positive 1-based integers');
+  }
+  if (!['left', 'middle', 'right'].includes(button) || !['click', 'scroll-up', 'scroll-down'].includes(kind)) {
+    throw new Error('invalid mouse button or kind');
+  }
+  const code = kind === 'scroll-up' ? 64 : kind === 'scroll-down' ? 65 : ['left', 'middle', 'right'].indexOf(button);
+  const press = `\x1b[<${code};${x};${y}M`;
+  return kind === 'click' ? `${press}\x1b[<${code};${x};${y}m` : press;
+}
+
+/** DEC private modes are independent; SGR coordinates require ?1006 as well as an event mode. */
+export function detectMouseMode(outputChunk: string): { readonly enabled: boolean; feed: (chunk: string) => boolean } {
+  const modes = new Set<number>();
+  let pending = '';
+  const isEnabled = (): boolean => modes.has(1006) && (modes.has(1000) || modes.has(1002) || modes.has(1003));
+
+  const feed = (chunk: string): boolean => {
+    const combined = pending + chunk;
+    // eslint-disable-next-line no-control-regex
+    const sequence = /\x1b\[\?([0-9;]+)([hl])/g;
+    for (const match of combined.matchAll(sequence)) {
+      for (const token of match[1]!.split(';')) {
+        const mode = Number(token);
+        if (mode === 1000 || mode === 1002 || mode === 1003 || mode === 1006) {
+          if (match[2] === 'h') modes.add(mode);
+          else modes.delete(mode);
+        }
+      }
+    }
+    // Retain only an incomplete CSI suffix; never replay completed transitions.
+    // eslint-disable-next-line no-control-regex
+    const start = combined.lastIndexOf('\x1b');
+    const suffix = start >= 0 ? combined.slice(start) : '';
+    pending = /^\x1b(?:\[(?:\?(?:[0-9;]*)?)?)?$/.test(suffix) && suffix.length < 64 ? suffix : '';
+    return isEnabled();
+  };
+  feed(outputChunk);
+  return {
+    get enabled() { return isEnabled(); },
+    feed,
+  };
+}
+
+const trackers = new Map<string, ReturnType<typeof detectMouseMode>>();
+export const MOUSE_MODE_OFF_REASON = 'PTY mouse mode is off or SGR ?1006 is not enabled';
+
+/** Called by the existing registry output/exit path, before screen rendering strips DEC mode sequences. */
+export function trackPtyMouseOutput(id: string, chunk: string): void {
+  const tracker = trackers.get(id) ?? detectMouseMode('');
+  tracker.feed(chunk);
+  trackers.set(id, tracker);
+}
+
+export function forgetPtyMouseMode(id: string): void { trackers.delete(id); }
+
+export function mouseModeForPty(handle: { readonly id: string }): boolean {
+  return trackers.get(handle.id)?.enabled ?? false;
+}
+
+export function mouseModeOffReason(handle: { readonly id: string }): string | undefined {
+  return mouseModeForPty(handle) ? undefined : MOUSE_MODE_OFF_REASON;
+}

package/src/pty-shell/pty-recording.ts

@@ -0,0 +1,108 @@
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { createRecorder } from '../capture/recorder.js';
+import { getRecordingStore } from '../capture/recording-store.js';
+import type { RecorderHandle } from '../capture/types.js';
+import { debug } from '../debug/log.js';
+
+interface ActiveRecording {
+  readonly recordingId: string;
+  readonly path: string;
+  readonly handle: RecorderHandle;
+  readonly startedAt: number;
+}
+
+const active = new Map<string, ActiveRecording>();
+
+export type StartPtyRecordingResult =
+  | { readonly ok: true; readonly recordingId: string; readonly path: string }
+  | { readonly ok: false; readonly reason: 'already-recording' };
+export type StopPtyRecordingResult =
+  | { readonly ok: true; readonly path: string; readonly bytes: number; readonly durationMs: number }
+  | { readonly ok: false; readonly reason: 'not-recording' };
+
+/** A process-local output tap; the capture store is shared with other recording hosts. */
+export function startPtyRecording(ptyId: string, opts: { cols: number; rows: number; title?: string }): StartPtyRecordingResult {
+  if (active.has(ptyId)) return { ok: false, reason: 'already-recording' };
+  if (!Number.isSafeInteger(opts.cols) || opts.cols < 1 || !Number.isSafeInteger(opts.rows) || opts.rows < 1) {
+    throw new Error('invalid PTY recording dimensions');
+  }
+  const startedAt = Date.now();
+  const directory = join(elanousStateRoot(), 'recordings');
+  const safeId = ptyId.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64);
+  let timestamp = startedAt;
+  let path = join(directory, `pty-${safeId}-${timestamp}.cast`);
+  while (existsSync(path) || [...active.values()].some((entry) => entry.path === path)) {
+    path = join(directory, `pty-${safeId}-${++timestamp}.cast`);
+  }
+  const handle = createRecorder({ dims: { cols: opts.cols, rows: opts.rows }, ...(opts.title === undefined ? {} : { title: opts.title }) });
+  handle.start();
+  const entry = getRecordingStore().start({ handle, encoder: 'asciicast', source: { surfaceLabel: `pty:${ptyId}` } });
+  active.set(ptyId, { recordingId: entry.id, path, handle, startedAt });
+  debug.log('pty.record', 'start', { ptyId, path, bytes: 0 });
+  return { ok: true, recordingId: entry.id, path };
+}
+
+export function tapPtyOutput(ptyId: string, chunk: string): void {
+  active.get(ptyId)?.handle.write(chunk, 'o');
+}
+
+function finish(ptyId: string, event: 'stop' | 'auto-stop' | 'auto-stop-recovered', path?: string): StopPtyRecordingResult {
+  const entry = active.get(ptyId);
+  if (!entry) return { ok: false, reason: 'not-recording' };
+  const target = path ?? entry.path;
+  const body = entry.handle.serialize();
+  mkdirSync(dirname(target), { recursive: true });
+  // Atomic save: write a temp file, then rename. A failed write leaves no partial cast at the
+  // target path and keeps the recording active, so the caller can retry the stop.
+  const temp = `${target}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temp, body, { encoding: 'utf8', flag: 'w' });
+    renameSync(temp, target);
+  } catch (error) {
+    try { rmSync(temp, { force: true }); } catch { /* best effort */ }
+    debug.log('pty.record', 'save-error', { ptyId, path: target, error: String(error) });
+    throw error;
+  }
+  // The cast is on disk from here: the recording is finished whatever the bookkeeping below does,
+  // otherwise a retry would find nothing to stop and the store would keep an active row forever.
+  active.delete(ptyId);
+  const bytes = Buffer.byteLength(body, 'utf8');
+  const durationMs = Date.now() - entry.startedAt;
+  closeBookkeeping(ptyId, entry, target);
+  debug.log('pty.record', event, { ptyId, path: target, bytes });
+  return { ok: true, path: target, bytes, durationMs };
+}
+
+function closeBookkeeping(ptyId: string, entry: ActiveRecording, artifactPath: string | undefined): void {
+  try { entry.handle.stop(); }
+  catch (error) { debug.log('pty.record', 'handle-stop-error', { ptyId, error: String(error) }); }
+  try { getRecordingStore().markStopped(entry.recordingId, artifactPath ? { artifactPath } : {}); }
+  catch (error) { debug.log('pty.record', 'mark-stopped-error', { ptyId, error: String(error) }); }
+}
+
+export function stopPtyRecording(ptyId: string): StopPtyRecordingResult {
+  return finish(ptyId, 'stop');
+}
+
+/** Called on PTY exit (and on unregister when exit was never delivered). Nothing can call
+ *  `--stop` on a PTY that is gone, so a failed save is retried once at a recovery path through the
+ *  same atomic save and close-out; if that fails too the recording is closed with the loss on record
+ *  — it never stays active with no way out. */
+export function autoStopPtyRecording(ptyId: string): StopPtyRecordingResult {
+  try {
+    return finish(ptyId, 'auto-stop');
+  } catch (error) {
+    const entry = active.get(ptyId);
+    if (!entry) throw error;
+    try {
+      return finish(ptyId, 'auto-stop-recovered', `${entry.path}.recovered`);
+    } catch (retryError) {
+      active.delete(ptyId);
+      closeBookkeeping(ptyId, entry, undefined);
+      debug.log('pty.record', 'auto-stop-save-failed', { ptyId, path: entry.path, error: String(error), retryError: String(retryError) });
+      throw retryError;
+    }
+  }
+}

package/src/pty-shell/registry.ts

@@ -17,6 +17,7 @@ import { existsSync } from 'node:fs';
 import { requirePosixShell } from '../platform/default-shell.js';
 import { randomBytes } from 'node:crypto';
 import { Terminal as XtermHeadless } from '@xterm/headless';
+import { trackPtyMouseOutput, forgetPtyMouseMode } from './pty-mouse.js';
 import { getGlobalElementRegistry, publishElementEvent } from '../element-registry/index.js';
 import { getSessionCwd } from '../session/working-dir.js';
 import { buildPtyEnv } from '../agent/identity-env.js';
@@ -26,6 +27,7 @@ import { resolvePtyRef, canTransitionAccessMode, ptyIdSeparatorIndex, type PtyAc
 import { resolveWriteDecision, resolveTakeover, type PtyWriteActor } from './pty-write-arbiter.js';
 import { addPtyManifestOutputBytes, upsertPtyManifest, updatePtyManifestSnapshot, updatePtyManifestNickname, markPtyManifestClosed, removePtyManifest, touchLivePtyManifest } from './pty-manifest.js';
 import { processPtyControlRequests } from './pty-control-ipc.js';
+import { tapPtyOutput, autoStopPtyRecording } from './pty-recording.js';
 import { forgetExternalWriteProvenance, noteExternalWrite } from './pty-write-provenance.js';
 import { resolveRunIdentity } from '../harness/harness-space.js';
 import { addSelfDevRunParticipant, selfDevRunsDir } from '../self-dev/run-store.js';
@@ -168,6 +170,8 @@ function renderAnsiLine(line: { length: number; getCell(x: number): XtermCell |
 
 export interface PtyControlTarget {
   readonly id: string;
+  readonly cols?: number;
+  readonly rows?: number;
   accessMode: PtyAccessMode;
   transitionPolicy: PtyTransitionPolicy;
   setAccessMode(mode: PtyAccessMode): boolean;
@@ -211,6 +215,8 @@ export interface PtyHandle extends PtyControlTarget {
   readonly pid: number;
   readonly workdir: string | undefined;
   readonly startedAt: number;
+  readonly cols: number;
+  readonly rows: number;
   /** Last time the PTY produced output OR was driven (write/drain). Used
    *  for LRU eviction when the concurrency cap is hit — recently-driven
    *  PTYs (a session the user may still resume) are protected; only the
@@ -329,6 +335,7 @@ export function emitPtyEvent(ev: PtyEvent): void {
       publishElementEvent('pty', ev.id, 'output', { bytes: ev.chunk.length });
       break;
     case 'exit':
+      forgetPtyMouseMode(ev.id);
       publishElementEvent('pty', ev.id, 'exit', { exitCode: ev.exitCode, signal: ev.signal });
       break;
     case 'stalled':
@@ -337,6 +344,7 @@ export function emitPtyEvent(ev: PtyEvent): void {
     case 'write-denied':
       break;
     case 'unregistered':
+      forgetPtyMouseMode(ev.id);
       publishElementEvent('pty', ev.id, 'delete');
       break;
   }
@@ -469,6 +477,8 @@ export function startPty(opts: StartOpts): PtyHandle {
    *  the alternative was a dead PTY reporting itself alive forever. Splitting
    *  the two lets `exitCode: null` honestly mean "죽었지만 모름". */
   let exited = false;
+  let currentCols = opts.cols ?? 80;
+  let currentRows = opts.rows ?? 24;
   let lastActivityAt = Date.now();
 
   // Screen emulator (@xterm/headless) — parses the same byte stream the
@@ -514,6 +524,8 @@ export function startPty(opts: StartOpts): PtyHandle {
     pid: adapter.pid,
     workdir: opts.workdir,
     startedAt: Date.now(),
+    get cols() { return currentCols; },
+    get rows() { return currentRows; },
     get lastActivityAt() { return lastActivityAt; },
     detach: opts.detach ?? false,
     get exitCode() { return exitCode; },
@@ -526,6 +538,7 @@ export function startPty(opts: StartOpts): PtyHandle {
     appendOutput(chunk: string): void {
       lastActivityAt = Date.now();
       delta += chunk;
+      trackPtyMouseOutput(id, chunk);
       // Feed the screen emulator so renderScreen() reflects live state.
       if (term) { try { term.write(chunk); } catch { /* parser hiccup — buffer still ok */ } }
       // Head: fill until cap.
@@ -634,7 +647,10 @@ export function startPty(opts: StartOpts): PtyHandle {
     resize(cols: number, rows: number): void {
       const c = Math.max(2, Math.floor(cols));
       const r = Math.max(2, Math.floor(rows));
-      try { adapter.resize?.(c, r); } catch { /* ignore */ }
+      // The reported size (recording headers) follows the PTY only once the adapter took it.
+      try {
+        if (adapter.resize) { adapter.resize(c, r); currentCols = c; currentRows = r; }
+      } catch { /* ignore */ }
       if (term) { try { term.resize(c, r); } catch { /* ignore */ } }
     },
   };
@@ -692,6 +708,8 @@ export function startPty(opts: StartOpts): PtyHandle {
 
   adapter.onData(chunk => {
     handle.appendOutput(chunk);
+    try { tapPtyOutput(id, chunk); }
+    catch (error) { debug.log('pty.record', 'tap-error', { ptyId: id, error: String(error) }); }
     emitPtyEvent({ type: 'output', id, chunk });
     // ★ 크로스-프로세스 관측(2026-07-23) — throttled 스냅샷을 공유 매니페스트에(데몬 PWA 유니온). getter 라 throttle 통과 시에만 snapshot().
     if (PTY_MANIFEST_ENABLED) {
@@ -714,6 +732,8 @@ export function startPty(opts: StartOpts): PtyHandle {
     killEscalationTimer = null;
     exitCode = code;
     exitSignal = signal;
+    try { autoStopPtyRecording(id); }
+    catch (error) { debug.log('pty.record', 'auto-stop-error', { ptyId: id, error: String(error) }); }
     emitPtyEvent({ type: 'exit', id, exitCode: code, signal });
     if (PTY_MANIFEST_ENABLED) {
       const now = Date.now();
@@ -802,7 +822,31 @@ function ensurePtyManifestHeartbeat(): void {
  * deliberately separate from spawned PTYs: it has no child lifecycle. */
 export function registerPtyControlTarget(handle: PtyControlTarget): () => void {
   controlTargets.set(handle.id, handle);
-  return () => { if (controlTargets.get(handle.id) === handle) controlTargets.delete(handle.id); };
+  // The self-reporting foreground TUI owns its stdout. The mirror installed later
+  // delegates through this tap, preserving its existing output and overlay path.
+  const stream = process.stdout;
+  const previousWrite = stream.write;
+  let tappedWrite: typeof stream.write | undefined;
+  if (handle.id.startsWith('tui:')) {
+    // Streaming decode: a multibyte character split across two Buffer writes stays intact.
+    const decoder = new TextDecoder('utf-8');
+    tappedWrite = function (this: typeof stream, ...args: Parameters<typeof stream.write>) {
+      const chunk = args[0];
+      if (chunk !== undefined) {
+        try { tapPtyOutput(handle.id, typeof chunk === 'string' ? chunk : decoder.decode(chunk as Uint8Array, { stream: true })); }
+        catch (error) { debug.log('pty.record', 'tap-error', { ptyId: handle.id, error: String(error) }); }
+      }
+      return previousWrite.apply(this, args);
+    } as typeof stream.write;
+    stream.write = tappedWrite;
+  }
+  return () => {
+    if (controlTargets.get(handle.id) !== handle) return;
+    try { autoStopPtyRecording(handle.id); }
+    catch (error) { debug.log('pty.record', 'auto-stop-error', { ptyId: handle.id, error: String(error) }); }
+    controlTargets.delete(handle.id);
+    if (tappedWrite && stream.write === tappedWrite) stream.write = previousWrite;
+  };
 }
 
 /** Run the existing cross-process control protocol for live targets. This
@@ -896,6 +940,8 @@ export function requestPtyTakeover(id: string, actor: PtyWriteActor): boolean {
 export function unregisterPty(id: string): boolean {
   const existed = processes.delete(id);
   if (existed) {
+    try { autoStopPtyRecording(id); }
+    catch (error) { debug.log('pty.record', 'auto-stop-error', { ptyId: id, error: String(error) }); }
     const outputFlush = pendingManifestOutputFlushers.get(id);
     outputFlush?.flush(Date.now());
     outputFlush?.cancel();
@@ -939,7 +985,8 @@ export function killNonDetached(): number {
     if (handle.isAlive()) {
       try { handle.kill('SIGTERM'); killed++; } catch { /* ignore */ }
     }
-    // The adapter's later onExit owns closure. Keep a failed trailing-output flush retryable until then.
+    // The adapter's later onExit owns recording closure (including trailing bytes).
+    // Keep a failed trailing-output flush retryable until then.
     pendingManifestOutputFlushers.get(id)?.flush(Date.now());
     processes.delete(id);
     getGlobalElementRegistry().unregister('pty', id);
@@ -1111,6 +1158,9 @@ export function resetForTesting(): void {
   const registry = getGlobalElementRegistry();
   for (const handle of processes.values()) {
     if (handle.isAlive()) try { handle.kill('SIGKILL'); } catch { /* ignore */ }
+    try { autoStopPtyRecording(handle.id); }
+    catch (error) { debug.log('pty.record', 'auto-stop-error', { ptyId: handle.id, error: String(error) }); }
+    forgetPtyMouseMode(handle.id);
     const outputFlush = pendingManifestOutputFlushers.get(handle.id);
     outputFlush?.flush(Date.now());
     outputFlush?.cancel();

package/src/python/resolve-python.ts

@@ -202,7 +202,7 @@ export function evaluatePythonEnv(input: {
   if (!versionAtLeast(probe.version, floor)) {
     const remedy = windows
       ? windowsPythonRemedy(resolution.source)
-      : `pyenv install ${pin} (build deps per distro: RFC-doctor-fix-build-toolchain-and-python-by-distro A2) · then: elanous python setup --yes`;
+      : `pyenv install ${pin} (install your distribution's Python build dependencies first) · then: elanous python setup --yes`;
     return { status: 'manual', evidence: `${resolution.source} python ${v} is older than the minimum ${floor}`, remedy, resolution };
   }
   if (!venvExists) return { status: 'fixable', evidence: `python ${v} (${resolution.source}) · elanous venv missing`, remedy: 'elanous python setup --yes', resolution };

package/src/release-loop/manifest.ts

@@ -0,0 +1,65 @@
+import type { ReleaseNoteFragment } from './release-note.js';
+
+export interface ReleaseLanding {
+  sha: string;
+  title: string;
+  prNumber?: number;
+  changedFiles: string[];
+  goalPath?: string;
+  releaseTarget?: 'next' | 'later';
+}
+
+export interface ReleaseManifestInput {
+  version: string;
+  baseline: { ref: string; sha: string };
+  cutoff: { sha: string };
+  landings: ReleaseLanding[];
+  notes?: Map<number, ReleaseNoteFragment>;
+  runningGoalPaths: string[];
+  publicCommandsBefore: string[];
+  publicCommandsAfter: string[];
+}
+
+export interface ReleaseManifest {
+  version: string;
+  baseline: ReleaseManifestInput['baseline'];
+  cutoff: ReleaseManifestInput['cutoff'];
+  in: Array<{ sha: string; title: string; prNumber?: number; docs: 'present' | 'missing' | 'n/a'; line?: string; kind?: ReleaseNoteFragment['kind'] | 'unknown'; note?: 'missing' }>;
+  deferred: Array<{ sha: string; reason: 'release-target-later' | 'run-in-flight' }>;
+  escalate: Array<{ kind: 'command-removed'; command: string }>;
+}
+
+/** Classify the already-observed landings without reading git, run ledgers or the filesystem. */
+export function buildReleaseManifest(input: ReleaseManifestInput): ReleaseManifest {
+  const running = new Set(input.runningGoalPaths);
+  const after = new Set(input.publicCommandsAfter);
+  const result: ReleaseManifest = {
+    version: input.version,
+    baseline: { ...input.baseline },
+    cutoff: { ...input.cutoff },
+    in: [],
+    deferred: [],
+    escalate: [],
+  };
+  for (const landing of input.landings) {
+    const fragment = landing.prNumber === undefined ? undefined : input.notes?.get(landing.prNumber);
+    if (landing.goalPath && running.has(landing.goalPath)) {
+      result.deferred.push({ sha: landing.sha, reason: 'run-in-flight' });
+    // ⭐ 줄이 없으면 IN — 명시 `release-target: later` 만 미룬다(METHOD v115 ④ · 흡수 골은 머리에 later 를 «명시»한다).
+    } else if (fragment?.target === 'later' || (!fragment && landing.releaseTarget === 'later')) {
+      result.deferred.push({ sha: landing.sha, reason: 'release-target-later' });
+    } else {
+      const docs = fragment ? ('path' in fragment.docs ? 'present' : 'n/a')
+        : landing.changedFiles.some((file) => file.startsWith('release/public/docs/')) ? 'present'
+        : landing.changedFiles.some((file) => file.startsWith('src/cli/') || file === 'src/index.ts') ? 'missing'
+        : 'n/a';
+      result.in.push({ sha: landing.sha, title: landing.title, ...(landing.prNumber === undefined ? {} : { prNumber: landing.prNumber }), docs,
+        ...(fragment ? { line: fragment.line, kind: fragment.kind } : input.notes ? { line: landing.title, kind: 'unknown', note: 'missing' as const } : {}),
+      });
+    }
+  }
+  for (const command of input.publicCommandsBefore) {
+    if (!after.has(command)) result.escalate.push({ kind: 'command-removed', command });
+  }
+  return result;
+}