@adhdev/daemon-core 0.9.82-rc.207 → 0.9.82-rc.209

package/dist/providers/spec/adapter.d.ts

@@ -1,23 +1,15 @@
-import { type PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+export type { PtyTransportFactory };
 export interface TerminalAdapterOpts {
     binary: string;
     args?: string[];
-    cwd: string;
+    cwd?: string;
     env?: Record<string, string>;
     cols?: number;
     rows?: number;
     /** Coalesce screen snapshots: emit on_screen_changed at most this often. */
     screenChangeDebounceMs?: number;
-    /** tick() period. 0 disables ticks. */
     tickIntervalMs?: number;
-    /**
-     * Optional PTY transport factory. When the daemon supplies a
-     * SessionHostPtyTransportFactory (standalone runs the PTY inside the
-     * session-host so the runtime/<sid>/snapshot endpoint can serve it),
-     * forward it here. Without it the PTY spawns locally inside the
-     * daemon process and the dashboard's terminal pane reports
-     * "Runtime terminal unavailable: Unknown session".
-     */
     transportFactory?: PtyTransportFactory;
 }
 export interface TerminalAdapterHandlers {
@@ -26,33 +18,33 @@ export interface TerminalAdapterHandlers {
     }): void;
     on_pty_data?(chunk: string): void;
     on_screen_changed?(snapshot: string): void;
-    tick?(): void;
     on_exit?(info: {
         exitCode: number;
     }): void;
+    tick?(): void;
 }
 export declare class TerminalAdapter {
     private readonly opts;
     private readonly handlers;
-    private term;
-    private pty;
-    private factory;
-    private cols;
     private rows;
-    private screenDebounceMs;
-    private tickIntervalMs;
+    private cols;
+    private readonly screenDebounceMs;
+    private readonly tickIntervalMs;
+    private readonly factory;
+    private screen;
+    private pty;
     private screenTimer;
     private tickTimer;
     private lastScreen;
     constructor(opts: TerminalAdapterOpts, handlers: TerminalAdapterHandlers);
     start(): void;
-    send_keys(s: string): void;
     resize(cols: number, rows: number): void;
     snapshot(): string;
     getCursorPosition(): {
         row: number;
         col: number;
     };
+    send_keys(text: string): void;
     kill(): void;
     private onChunk;
     private computeScreen;

package/dist/providers/spec/driver.d.ts

@@ -128,6 +128,14 @@ export declare class SpecDriver {
      *  because the evaluator already moved past busy by the time the hold
      *  kicks in. */
     private lastBusyState;
+    /** Timestamp of the last time we entered a modal state (approval/picker or
+     *  any non-busy non-idle state). Used to suppress brief busy blips that
+     *  appear while the modal is still on screen — Claude Code streams body
+     *  text that transiently shows a spinner even while an approval modal is
+     *  visible, causing rapid approval→busy→approval flicker on the dashboard. */
+    private lastModalAt;
+    /** The modal state snapshot held across busy blips. */
+    private lastModalState;
     private completionIdleFirstSeenAt;
     private completionIdleKey;
     /** Timer that re-runs evaluate() once the hold window expires. Needed
@@ -174,6 +182,12 @@ export declare class SpecDriver {
     getLastBusyAt(): number;
     hasIdleHoldPending(): boolean;
     getSpecPath(): string;
+    getCompletionIdleDebounceState(): {
+        active: boolean;
+        ageMs: number;
+        holdMs: number;
+        forceAfterMs: number;
+    } | null;
     getScreen(): string;
     getSections(): Array<{
         id: string;

package/dist/providers/spec/schema.gen.d.ts

@@ -312,7 +312,12 @@ export declare const SCHEMA: {
                 readonly modal_buttons: {
                     readonly type: "object";
                     readonly additionalProperties: false;
-                    readonly required: readonly ["pattern", "key_for_index"];
+                    readonly required: readonly ["key_for_index"];
+                    readonly oneOf: readonly [{
+                        readonly required: readonly ["pattern"];
+                    }, {
+                        readonly required: readonly ["patterns"];
+                    }];
                     readonly properties: {
                         readonly section: {
                             readonly type: "string";
@@ -324,6 +329,24 @@ export declare const SCHEMA: {
                         readonly flags: {
                             readonly type: "string";
                         };
+                        readonly patterns: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly items: {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly required: readonly ["pattern"];
+                                readonly properties: {
+                                    readonly pattern: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                    };
+                                    readonly flags: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                        };
                         readonly key_for_index: {
                             readonly type: "string";
                             readonly minLength: 1;

package/dist/providers/spec/types.d.ts

@@ -61,8 +61,15 @@ export interface SectionPattern {
 }
 export interface ModalButtonsRule {
     section?: string;
-    pattern: string;
+    /** Single pattern (original). Use `patterns` for multi-format fallback. */
+    pattern?: string;
     flags?: string;
+    /** Ordered list of pattern alternatives. Evaluated in order; first that
+     *  yields >= min_count buttons wins. Mutually exclusive with `pattern`. */
+    patterns?: Array<{
+        pattern: string;
+        flags?: string;
+    }>;
     key_for_index: string;
     min_count?: number;
     continuation_lines?: boolean;

package/dist/shared-types-extra.d.ts

@@ -23,7 +23,5 @@ export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'waitin
 export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
 /** Terminal backend status */
 export interface TerminalBackendStatus {
-    backend: 'xterm' | 'ghostty-vt';
-    preference: 'auto' | 'xterm' | 'ghostty-vt';
-    ghosttyAvailable: boolean;
+    backend: 'ghostty-vt';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.207",
+  "version": "0.9.82-rc.209",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,8 +48,6 @@
   "dependencies": {
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
-    "@xterm/headless": "^6.0.0",
-    "@xterm/xterm": "^6.0.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "better-sqlite3": "^12.10.0",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -20,6 +20,7 @@ import type { InteractivePromptResponse } from '../providers/types/interactive-p
 import { LOG } from '../logging/logger.js';
 import { getDebugRuntimeConfig } from '../logging/debug-config.js';
 import { TerminalScreen } from './terminal-screen.js';
+import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from '@adhdev/session-host-core';
 import {
     NodePtyTransportFactory,
     type PtyRuntimeMetadata,
@@ -212,7 +213,7 @@ export class ProviderCliAdapter implements CliAdapter {
     /** Full accumulated raw PTY output (with ANSI) */
     private accumulatedRawBuffer: string = '';
     /** Current visible terminal screen snapshot */
-    private terminalScreen = new TerminalScreen(24, 80);
+    private terminalScreen = new TerminalScreen(DEFAULT_SESSION_HOST_ROWS, DEFAULT_SESSION_HOST_COLS);
     private static readonly MAX_RESPONSE_BUFFER = 8000;
     private static readonly MAX_RECENT_OUTPUT_BUFFER = 1000;
     private responseBufferDroppedChars = 0;
@@ -563,7 +564,7 @@ export class ProviderCliAdapter implements CliAdapter {
         this.startupBuffer = '';
         this.startupFirstOutputAt = 0;
         if (this.startupSettleTimer) { clearTimeout(this.startupSettleTimer); this.startupSettleTimer = null; }
-        this.resetTerminalScreen(24, 80);
+        this.resetTerminalScreen(DEFAULT_SESSION_HOST_ROWS, DEFAULT_SESSION_HOST_COLS);
         this.pendingTerminalQueryTail = '';
         this.ready = false;
         await this.ptyProcess.ready;

package/src/cli-adapters/terminal-backends/ghostty-vt-backend.ts

@@ -1,7 +1,6 @@
 import type {
     TerminalViewportBackend,
     TerminalViewportBackendOptions,
-    TerminalViewportBackendPreference,
 } from './types.js';
 
 type GhosttyVtTerminal = {
@@ -49,12 +48,10 @@ function getBindingCandidates(): string[] {
     return explicit ? [explicit] : DEFAULT_BINDING_CANDIDATES;
 }
 
-function loadGhosttyVtBinding(required: boolean): GhosttyVtBinding | null {
+function loadGhosttyVtBinding(): GhosttyVtBinding {
     if (cachedBinding !== undefined) {
-        if (!cachedBinding && required && cachedBindingError) {
-            throw cachedBindingError;
-        }
-        return cachedBinding;
+        if (!cachedBinding && cachedBindingError) throw cachedBindingError;
+        return cachedBinding!;
     }
 
     const errors: string[] = [];
@@ -65,7 +62,7 @@ function loadGhosttyVtBinding(required: boolean): GhosttyVtBinding | null {
             const mod = require(ref);
             cachedBinding = normalizeBinding(mod, ref);
             cachedBindingError = null;
-            return cachedBinding;
+            return cachedBinding!;
         } catch (error) {
             if (isModuleNotFoundError(error, ref)) {
                 errors.push(`${ref}: module not found`);
@@ -78,21 +75,9 @@ function loadGhosttyVtBinding(required: boolean): GhosttyVtBinding | null {
 
     cachedBinding = null;
     cachedBindingError = new Error(
-        `ghostty-vt backend requested but no binding is available (${errors.join('; ') || 'no candidates tried'})`,
+        `ghostty-vt binding unavailable (${errors.join('; ') || 'no candidates tried'})`,
     );
-
-    if (required) throw cachedBindingError;
-    return null;
-}
-
-export function resolveTerminalBackendPreference(): TerminalViewportBackendPreference {
-    const raw = process.env.ADHDEV_TERMINAL_BACKEND?.trim().toLowerCase();
-    if (raw === 'ghostty-vt' || raw === 'xterm' || raw === 'auto') return raw;
-    return 'auto';
-}
-
-export function isGhosttyVtBackendAvailable(): boolean {
-    return !!loadGhosttyVtBinding(false);
+    throw cachedBindingError;
 }
 
 export class GhosttyVtTerminalBackend implements TerminalViewportBackend {
@@ -100,10 +85,7 @@ export class GhosttyVtTerminalBackend implements TerminalViewportBackend {
     private terminal: GhosttyVtTerminal;
 
     constructor(options: TerminalViewportBackendOptions) {
-        const binding = loadGhosttyVtBinding(true);
-        if (!binding) {
-            throw new Error('ghostty-vt backend requested but no binding is available');
-        }
+        const binding = loadGhosttyVtBinding();
         this.terminal = binding.createTerminal({
             cols: Math.max(1, options.cols | 0),
             rows: Math.max(1, options.rows | 0),
@@ -121,15 +103,10 @@ export class GhosttyVtTerminalBackend implements TerminalViewportBackend {
     }
 
     getText(): string {
-        // (fix) ghostty's `trim:true` mode strips trailing whitespace per row
-        // AND collapses cells that were touched only by cursor-forward (ESC[<n>C)
-        // without a printable glyph. Many TUIs (Claude Code most prominently)
-        // render inter-word spaces via CUF rather than literal spaces, so
-        // trim:true would smash "Do you want to proceed?" into
-        // "Doyouwanttoproceed?" and break every downstream regex
-        // (approval detection, prompt-line discovery, etc.). Keep the per-row
-        // padding, then trim each row's trailing whitespace ourselves so the
-        // serialized text matches what the user sees in the terminal.
+        // ghostty's `trim:true` collapses CUF-advanced cells — many TUIs including
+        // Claude Code render spaces via cursor-forward rather than literal spaces,
+        // which would break downstream regex matching. Keep per-row padding and
+        // trim trailing whitespace ourselves.
         const raw = this.terminal.formatPlainText({ trim: false }) || '';
         if (!raw) return '';
         const lines = raw.split('\n').map((row) => row.replace(/\s+$/, ''));

package/src/cli-adapters/terminal-backends/types.ts

@@ -1,6 +1,4 @@
-export type TerminalViewportBackendKind = 'xterm' | 'ghostty-vt';
-
-export type TerminalViewportBackendPreference = TerminalViewportBackendKind | 'auto';
+export type TerminalViewportBackendKind = 'ghostty-vt';
 
 export type TerminalViewportBackendOptions = {
     rows: number;

package/src/cli-adapters/terminal-screen.ts

@@ -1,99 +1,29 @@
 /**
- * PTY screen snapshot abstraction.
- *
- * Terminal viewport backend selection.
- *
- * Runtime preference is backend-agnostic:
- * - prefer ghostty-vt when available (or when explicitly requested)
- * - fall back to xterm when ghostty-vt is unavailable
+ * PTY screen snapshot abstraction — ghostty-vt backend.
  */
 
-import { LOG } from '../logging/logger.js';
-import { GhosttyVtTerminalBackend, isGhosttyVtBackendAvailable, resolveTerminalBackendPreference } from './terminal-backends/ghostty-vt-backend.js';
-import type {
-    TerminalViewportBackend,
-    TerminalViewportBackendKind,
-    TerminalViewportBackendOptions,
-    TerminalViewportBackendPreference,
-} from './terminal-backends/types.js';
-import { XtermTerminalBackend } from './terminal-backends/xterm-backend.js';
+import { GhosttyVtTerminalBackend } from './terminal-backends/ghostty-vt-backend.js';
+import type { TerminalViewportBackendKind } from './terminal-backends/types.js';
+import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from '@adhdev/session-host-core';
 
 const DEFAULT_SCROLLBACK = 2000;
-const loggedTerminalBackends = new Set<string>();
 
 export function getTerminalBackendRuntimeStatus(): {
     backend: TerminalViewportBackendKind;
-    preference: TerminalViewportBackendPreference;
-    ghosttyAvailable: boolean;
 } {
-    const preference = resolveTerminalBackendPreference();
-    const ghosttyAvailable = isGhosttyVtBackendAvailable();
-    const backend: TerminalViewportBackendKind = (
-        preference === 'ghostty-vt' || (preference === 'auto' && ghosttyAvailable)
-            ? 'ghostty-vt'
-            : 'xterm'
-    );
-    return { backend, preference, ghosttyAvailable };
-}
-
-function createTerminalBackend(
-    options: TerminalViewportBackendOptions,
-    preference: TerminalViewportBackendPreference,
-): TerminalViewportBackend {
-    const ghosttyAvailable = isGhosttyVtBackendAvailable();
-    if (preference === 'ghostty-vt') {
-        const backend = new GhosttyVtTerminalBackend(options);
-        logTerminalBackendSelection(preference, ghosttyAvailable, backend.kind);
-        return backend;
-    }
-
-    if (preference === 'auto' && ghosttyAvailable) {
-        const backend = new GhosttyVtTerminalBackend(options);
-        logTerminalBackendSelection(preference, ghosttyAvailable, backend.kind);
-        return backend;
-    }
-
-    const backend = new XtermTerminalBackend(options);
-    logTerminalBackendSelection(preference, ghosttyAvailable, backend.kind);
-    return backend;
-}
-
-function logTerminalBackendSelection(
-    preference: TerminalViewportBackendPreference,
-    ghosttyAvailable: boolean,
-    backendKind: TerminalViewportBackendKind,
-): void {
-    const key = `${preference}:${ghosttyAvailable}:${backendKind}`;
-    if (loggedTerminalBackends.has(key)) return;
-    loggedTerminalBackends.add(key);
-    if (backendKind === 'xterm' && preference !== 'xterm' && !ghosttyAvailable) {
-        const message = `[terminal-screen] ghostty-vt unavailable; using xterm fallback (preference=${preference})`;
-        if (preference === 'auto') {
-            LOG.info('Terminal', message);
-        } else {
-            LOG.warn('Terminal', message);
-        }
-        return;
-    }
-    LOG.info(
-        'Terminal',
-        `[terminal-screen] backend=${backendKind} preference=${preference} ghosttyAvailable=${ghosttyAvailable}`,
-    );
+    return { backend: 'ghostty-vt' };
 }
 
 export class TerminalScreen {
-    readonly backendKind: TerminalViewportBackendKind;
+    readonly backendKind: TerminalViewportBackendKind = 'ghostty-vt';
     private rows: number;
     private cols: number;
-    private readonly preference: TerminalViewportBackendPreference;
-    private terminal: TerminalViewportBackend;
+    private terminal: GhosttyVtTerminalBackend;
 
-    constructor(rows = 40, cols = 120) {
+    constructor(rows = DEFAULT_SESSION_HOST_ROWS, cols = DEFAULT_SESSION_HOST_COLS) {
         this.rows = Math.max(1, rows | 0);
         this.cols = Math.max(1, cols | 0);
-        this.preference = resolveTerminalBackendPreference();
         this.terminal = this.createBackend();
-        this.backendKind = this.terminal.kind;
     }
 
     reset(rows = this.rows, cols = this.cols): void {
@@ -125,11 +55,11 @@ export class TerminalScreen {
         this.terminal.dispose();
     }
 
-    private createBackend(): TerminalViewportBackend {
-        return createTerminalBackend({
+    private createBackend(): GhosttyVtTerminalBackend {
+        return new GhosttyVtTerminalBackend({
             cols: this.cols,
             rows: this.rows,
             scrollback: DEFAULT_SCROLLBACK,
-        }, this.preference);
+        });
     }
 }

package/src/commands/mesh-coordinator.ts

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto'
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import * as os from 'node:os'
+import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from '@adhdev/session-host-core'
 import { basename, isAbsolute, join, resolve } from 'node:path'
 import { LOG } from '../logging/logger.js'
 import type {
@@ -557,8 +558,8 @@ export async function execUnderPty(
     try {
       child = ptyLib.spawn(command, args, {
         name: 'xterm-256color',
-        cols: 120,
-        rows: 30,
+        cols: DEFAULT_SESSION_HOST_COLS,
+        rows: DEFAULT_SESSION_HOST_ROWS,
         cwd: options.cwd ?? process.cwd(),
         env,
       })

package/src/daemon/dev-auto-implement.ts

@@ -9,6 +9,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from '@adhdev/session-host-core';
 import type * as http from 'http';
 import type { ChildProcess } from 'child_process';
 import type { DevServerContext, ProviderCategory } from './dev-server-types.js';
@@ -482,8 +483,8 @@ export async function handleAutoImplement(ctx: DevServerContext, type: string, r
       const isWin = os.platform() === 'win32';
       child = pty.spawn(isWin ? 'cmd.exe' : (process.env.SHELL || '/bin/zsh'), [isWin ? '/c' : '-c', shellCmd], {
         name: 'xterm-256color',
-        cols: 120,
-        rows: 40,
+        cols: DEFAULT_SESSION_HOST_COLS,
+        rows: DEFAULT_SESSION_HOST_ROWS,
         cwd: providerDir,
         env: { ...process.env, ...(spawn.env || {}) },
       });

package/src/providers/spec/adapter.ts

@@ -1,65 +1,35 @@
 /**
- * Thin generic terminal adapter.
+ * PTY + terminal-screen adapter for the spec driver.
  *
- * Spawns a PTY, feeds bytes into a headless xterm so a visible screen
- * snapshot is always available, and exposes a small hook surface
- * (init / tick / on_screen_changed / on_exit). Nothing in this module
- * knows about agents, modals, or specs — it's just a terminal host.
+ * Spawns a PTY, feeds bytes into a TerminalScreen (ghostty-vt when available,
+ * xterm fallback otherwise) so a visible-screen snapshot is always available,
+ * and exposes a small hook surface for the SpecDriver to consume:
  *
- * The Spec Driver is built on top of this adapter and consumes the
- * hooks to drive its declarative state machine.
- *
- * Inbound from driver:
- *   send_keys(str)  — raw bytes to PTY
- *   resize(c, r)    — resize the PTY and the xterm
- *   kill()          — terminate the child
- *
- * Outbound to driver:
- *   init({ pid })
- *   on_pty_data(chunk)            — raw bytes for dashboard's terminal pane
- *   on_screen_changed(snapshot)   — coalesced visible-screen change
- *   tick()                        — periodic timer (configurable interval)
- *   on_exit({ exitCode })
+ *   init({ pid })               — PTY spawned
+ *   on_pty_data(chunk)          — raw PTY byte chunk received
+ *   on_screen_changed(snapshot) — coalesced visible-screen change
+ *   on_exit({ exitCode })       — PTY exited
+ *   tick()                      — periodic tick (if tickIntervalMs > 0)
  */
 'use strict';
 
-// @xterm/headless ships as CJS only but stamps __esModule = true on its
-// export object, so tsup's __toESM helper neither synthesizes a `default`
-// property (it sees the __esModule marker and trusts it) nor preserves
-// the named `Terminal` export through a plain ESM-style
-// `import { Terminal } from '@xterm/headless'`. The first symptom we saw
-// from this was the published `adhdev` CLI exploding with
-// "Named export 'Terminal' not found" inside the mcp ipc bootstrap.
-//
-// Pull Terminal off the namespace import (which tsup compiles into a
-// shim that *does* see the package's own Terminal property) instead.
-// Type-only import keeps the .d.ts surface honest.
-import type { Terminal as TerminalType } from '@xterm/headless';
-import * as xtermHeadlessNs from '@xterm/headless';
-const TerminalCtor: { new (...args: unknown[]): TerminalType } =
-    (xtermHeadlessNs as any).Terminal
-    ?? (xtermHeadlessNs as any).default?.Terminal;
-import { NodePtyTransportFactory, type PtyRuntimeTransport, type PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import { TerminalScreen } from '../../cli-adapters/terminal-screen.js';
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import type { PtyRuntimeTransport } from '../../cli-adapters/pty-transport.js';
+import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from '@adhdev/session-host-core';
+
+export type { PtyTransportFactory };
 
 export interface TerminalAdapterOpts {
     binary: string;
     args?: string[];
-    cwd: string;
+    cwd?: string;
     env?: Record<string, string>;
     cols?: number;
     rows?: number;
     /** Coalesce screen snapshots: emit on_screen_changed at most this often. */
     screenChangeDebounceMs?: number;
-    /** tick() period. 0 disables ticks. */
     tickIntervalMs?: number;
-    /**
-     * Optional PTY transport factory. When the daemon supplies a
-     * SessionHostPtyTransportFactory (standalone runs the PTY inside the
-     * session-host so the runtime/<sid>/snapshot endpoint can serve it),
-     * forward it here. Without it the PTY spawns locally inside the
-     * daemon process and the dashboard's terminal pane reports
-     * "Runtime terminal unavailable: Unknown session".
-     */
     transportFactory?: PtyTransportFactory;
 }
 
@@ -67,18 +37,18 @@ export interface TerminalAdapterHandlers {
     init?(info: { pid: number }): void;
     on_pty_data?(chunk: string): void;
     on_screen_changed?(snapshot: string): void;
-    tick?(): void;
     on_exit?(info: { exitCode: number }): void;
+    tick?(): void;
 }
 
 export class TerminalAdapter {
-    private term: TerminalType;
-    private pty: PtyRuntimeTransport | null = null;
-    private factory: PtyTransportFactory;
-    private cols: number;
     private rows: number;
-    private screenDebounceMs: number;
-    private tickIntervalMs: number;
+    private cols: number;
+    private readonly screenDebounceMs: number;
+    private readonly tickIntervalMs: number;
+    private readonly factory: PtyTransportFactory;
+    private screen: TerminalScreen;
+    private pty: PtyRuntimeTransport | null = null;
     private screenTimer: ReturnType<typeof setTimeout> | null = null;
     private tickTimer: ReturnType<typeof setInterval> | null = null;
     private lastScreen = '';
@@ -87,17 +57,20 @@ export class TerminalAdapter {
         private readonly opts: TerminalAdapterOpts,
         private readonly handlers: TerminalAdapterHandlers,
     ) {
-        this.cols = opts.cols ?? 100;
-        this.rows = opts.rows ?? 30;
+        this.cols = opts.cols ?? DEFAULT_SESSION_HOST_COLS;
+        this.rows = opts.rows ?? DEFAULT_SESSION_HOST_ROWS;
         this.screenDebounceMs = opts.screenChangeDebounceMs ?? 80;
         this.tickIntervalMs = opts.tickIntervalMs ?? 0;
+        // Import NodePtyTransportFactory lazily to avoid loading node-pty in
+        // environments that don't need it (tests, fixture runners).
+        const { NodePtyTransportFactory } = require('../../cli-adapters/pty-transport.js');
         this.factory = opts.transportFactory ?? new NodePtyTransportFactory();
-        this.term = new TerminalCtor({ cols: this.cols, rows: this.rows, allowProposedApi: true, scrollback: 1000 });
+        this.screen = new TerminalScreen(this.rows, this.cols);
     }
 
     start(): void {
         this.pty = this.factory.spawn(this.opts.binary, this.opts.args ?? [], {
-            cwd: this.opts.cwd,
+            cwd: this.opts.cwd ?? process.cwd(),
             env: { ...process.env, ...(this.opts.env ?? {}) } as Record<string, string>,
             cols: this.cols,
             rows: this.rows,
@@ -114,14 +87,10 @@ export class TerminalAdapter {
         }
     }
 
-    send_keys(s: string): void {
-        this.pty?.write(s);
-    }
-
     resize(cols: number, rows: number): void {
         this.cols = cols; this.rows = rows;
         this.pty?.resize(cols, rows);
-        this.term.resize(cols, rows);
+        this.screen.resize(rows, cols);
     }
 
     snapshot(): string {
@@ -129,23 +98,24 @@ export class TerminalAdapter {
     }
 
     getCursorPosition(): { row: number; col: number } {
-        const buf = this.term.buffer.active;
-        return {
-            row: Math.max(0, (buf as any).cursorY ?? 0),
-            col: Math.max(0, (buf as any).cursorX ?? 0),
-        };
+        const pos = this.screen.getCursorPosition();
+        return { row: pos.row, col: pos.col };
+    }
+
+    send_keys(text: string): void {
+        this.pty?.write(text);
     }
 
     kill(): void {
         this.stopTimers();
         try { this.pty?.kill(); } catch { /* ignore */ }
         this.pty = null;
-        this.term.dispose();
+        this.screen.dispose();
     }
 
     private onChunk(chunk: string): void {
         try { this.handlers.on_pty_data?.(chunk); } catch { /* user side */ }
-        this.term.write(chunk);
+        this.screen.write(chunk);
         // Coalesce snapshot emission — rapid bursts shouldn't fire 200x.
         if (this.screenTimer) return;
         this.screenTimer = setTimeout(() => {
@@ -158,15 +128,7 @@ export class TerminalAdapter {
     }
 
     private computeScreen(): string {
-        const buf = this.term.buffer.active;
-        const out: string[] = [];
-        for (let y = 0; y < buf.length; y += 1) {
-            const line = buf.getLine(y);
-            if (!line) continue;
-            out.push(line.translateToString(true));
-        }
-        while (out.length > 0 && out[out.length - 1].trim() === '') out.pop();
-        return out.join('\n');
+        return this.screen.getText();
     }
 
     private stopTimers(): void {