@adhdev/daemon-core 0.9.82-rc.37 → 0.9.82-rc.370

package/src/cli-adapters/provider-cli-parse.d.ts

@@ -15,6 +15,7 @@ export declare function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;

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

@@ -35,22 +35,30 @@ export function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;
     scope?: TurnParseScope | null;
     runtimeSettings: Record<string, any>;
+    spawnAt?: number;
 }): CliScriptInput {
     const {
         accumulatedBuffer,
         accumulatedRawBuffer,
         recentOutputBuffer,
         terminalScreenText,
+        workingDir,
+        providerSessionId,
+        historySessionId,
         baseMessages,
         partialResponse,
         isWaitingForResponse,
         scope,
         runtimeSettings,
+        spawnAt,
     } = options;
     const buffer = scope
         ? sliceFromOffset(accumulatedBuffer, scope.bufferStart)
@@ -66,6 +74,10 @@ export function buildCliParseInput(options: {
         rawBuffer,
         recentBuffer,
         screenText,
+        workspace: workingDir,
+        workingDir,
+        providerSessionId,
+        historySessionId,
         screen: buildCliScreenSnapshot(screenText),
         bufferScreen: buildCliScreenSnapshot(buffer),
         recentScreen: buildCliScreenSnapshot(recentBuffer),
@@ -74,6 +86,7 @@ export function buildCliParseInput(options: {
         isWaitingForResponse,
         promptText: scope?.prompt || '',
         settings: { ...runtimeSettings },
+        ...(typeof spawnAt === 'number' && spawnAt > 0 ? { spawnAt } : {}),
     };
 }
 

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

@@ -34,20 +34,69 @@ export function resolveCliSpawnPlan(options: {
     const configuredCommand = typeof runtimeSettings.executablePath === 'string' && runtimeSettings.executablePath.trim()
         ? runtimeSettings.executablePath.trim()
         : spawnConfig.command;
-    const binaryPath = findBinary(configuredCommand);
+    return resolveCliSpawnPlanFromParts({
+        command: configuredCommand,
+        baseArgs: spawnConfig.args,
+        shell: spawnConfig.shell,
+        baseEnv: spawnConfig.env,
+        workingDir,
+        extraArgs,
+        extraEnv,
+    });
+}
+
+/**
+ * Cols/rows for a PTY spawn. Defaults to the session-host terminal size; the
+ * spec driver may override per-instance.
+ */
+export interface CliSpawnGeometry {
+    cols?: number;
+    rows?: number;
+}
+
+/**
+ * Core spawn-plan resolution from already-flattened spawn parts — the single
+ * source of truth for binary resolution (findBinary: PATH + npm-global / Node
+ * dir fallback), `{{workingDir}}` token substitution, shell wrapping
+ * (script-shims / non-absolute / non-native binaries), and env sanitization +
+ * TERMINAL_CWD. Both the legacy provider-module path (resolveCliSpawnPlan) and
+ * the spec/FSM path (FsmDriver.buildAdapterOpts) feed into this so the two
+ * spawn paths can never diverge.
+ */
+export function resolveCliSpawnPlanFromParts(options: {
+    /** Raw command from the spec/provider (`binary` / `spawn.command`), or an
+     *  operator-configured executable path override. */
+    command: string;
+    /** Base launch args declared by the spec/provider (`spawn_args` /
+     *  `spawn.args`). */
+    baseArgs?: string[];
+    /** When true, always wrap the launch in a login shell. */
+    shell?: boolean;
+    /** Base env declared by the spec/provider (`env` / `spawn.env`). */
+    baseEnv?: Record<string, string>;
+    workingDir: string;
+    /** Per-launch extra args (e.g. resume session id) appended after baseArgs. */
+    extraArgs?: string[];
+    extraEnv?: Record<string, string>;
+    geometry?: CliSpawnGeometry;
+}): CliSpawnPlan {
+    const { command, baseArgs, shell, baseEnv, workingDir, extraArgs, extraEnv, geometry } = options;
+    const binaryPath = findBinary(command);
     const isWin = os.platform() === 'win32';
-    const allArgs = [...spawnConfig.args, ...extraArgs];
+    const allArgs = [...(baseArgs ?? []), ...(extraArgs ?? [])].map((arg) =>
+        typeof arg === 'string' ? arg.replace(/\{\{workingDir\}\}/g, workingDir) : arg,
+    );
 
     let shellCmd: string;
     let shellArgs: string[];
     const useShellUnix = !isWin && (
-        !!spawnConfig.shell
+        !!shell
         || !path.isAbsolute(binaryPath)
         || isScriptBinary(binaryPath)
         || !looksLikeMachOOrElf(binaryPath)
     );
     const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
-    const useShellWin = !!spawnConfig.shell
+    const useShellWin = !!shell
         || isCmdShim
         || !path.isAbsolute(binaryPath)
         || isScriptBinary(binaryPath);
@@ -66,7 +115,7 @@ export function resolveCliSpawnPlan(options: {
         shellArgs = allArgs;
     }
 
-    const env = buildCliSpawnEnv(process.env, { ...(spawnConfig.env || {}), ...(extraEnv || {}) });
+    const env = buildCliSpawnEnv(process.env, { ...(baseEnv || {}), ...(extraEnv || {}) });
     // Some CLI agents, notably Hermes, route their tools through TERMINAL_CWD
     // rather than process.cwd(). Keep the generic ADHDev launch workspace as
     // the single source of truth so PTY cwd and tool cwd cannot diverge.
@@ -80,8 +129,8 @@ export function resolveCliSpawnPlan(options: {
         isWin,
         useShell,
         ptyOptions: {
-            cols: DEFAULT_SESSION_HOST_COLS,
-            rows: DEFAULT_SESSION_HOST_ROWS,
+            cols: geometry?.cols ?? DEFAULT_SESSION_HOST_COLS,
+            rows: geometry?.rows ?? DEFAULT_SESSION_HOST_ROWS,
             cwd: workingDir,
             env,
         },

package/src/cli-adapters/provider-cli-shared.d.ts

@@ -18,6 +18,8 @@ export interface CliSessionStatus {
     activeModal: { message: string; buttons: string[] } | null;
     errorMessage?: string;
     errorReason?: string;
+    lastOutputAt?: number;
+    lastScreenChangeAt?: number;
 }
 export interface CliScripts {
     detectStatus?: (input: CliStatusInput) => string | null;
@@ -55,6 +57,8 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;

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

@@ -4,6 +4,7 @@ import { execSync } from 'child_process';
 import type { ProviderResumeCapability } from '../providers/contracts.js';
 import type { ChatMessageKind } from '../providers/chat-message-normalization.js';
 import type { ChatBubbleState } from '../types.js';
+import type { InteractivePrompt } from '../providers/types/interactive-prompt.js';
 import { sanitizeSpawnEnv } from './spawn-env.js';
 
 export interface CliChatMessage {
@@ -28,8 +29,52 @@ export interface CliSessionStatus {
     messages: CliChatMessage[];
     workingDir: string;
     activeModal: { message: string; buttons: string[] } | null;
+    /**
+     * Monotonic counter identifying which approval *entry* the current modal
+     * belongs to. Bumped by the FSM on every fresh waiting_approval entry.
+     * Consumers (e.g. auto-approval) use it to distinguish a genuinely new
+     * approval from the same approval re-observed across TUI paint flaps —
+     * two distinct approvals can carry identical message/button text, so the
+     * seq is the only reliable discriminator.
+     */
+    approvalEntrySeq?: number;
+    /**
+     * The approval entry seq that the engine's last resolveModal() handled. When
+     * `lastResolvedEntrySeq >= approvalEntrySeq` (and approvalEntrySeq > 0) it is positive
+     * evidence that the current/latest approval entry was resolved through ADHDev (auto-approve
+     * fire, dashboard / mesh_approve, or dev-cli-debug — all route through resolveModal). The
+     * completion finalization gate uses this to avoid confirming a waiting_approval→idle
+     * transition for which no resolution actually occurred (a false idle: the spec's text-based
+     * approval→idle rule tripped while the modal is still on screen).
+     */
+    lastResolvedEntrySeq?: number;
+    activeInteractivePrompt?: InteractivePrompt | null;
+    pendingOutboundCount?: number;
+    pendingOutboundMessages?: Array<{
+        id: string;
+        role: 'user';
+        content: string;
+        queuedAt: number;
+        source: string;
+    }>;
     errorMessage?: string;
     errorReason?: string;
+    providerSessionId?: string;
+    /**
+     * Timestamp (ms) of the most recent raw PTY output chunk. Advances on every
+     * byte the process emits, including tool/build output that produces no
+     * parsed assistant text. Liveness watchdogs use this to distinguish a real
+     * stall (no output at all) from an active turn whose assistant buffer is
+     * momentarily static while a tool runs.
+     */
+    lastOutputAt?: number;
+    /**
+     * Timestamp (ms) of the most recent *visible* terminal screen change.
+     * Stricter than lastOutputAt — only advances when the rendered screen
+     * content actually differs, so repeated keepalive bytes do not register as
+     * progress. Preferred liveness signal for the no-progress watchdog.
+     */
+    lastScreenChangeAt?: number;
     bufferState?: {
         responseBuffer?: { truncated: boolean; droppedChars: number; maxChars: number };
         recentOutputBuffer?: { truncated: boolean; droppedChars: number; maxChars: number };
@@ -43,6 +88,9 @@ export interface ParsedSession {
     messages: any[];
     modal: { message: string; buttons: string[] } | null;
     parsedStatus: string | null;
+    errorMessage?: string;
+    errorReason?: string;
+    providerSessionId?: string;
     transcriptAuthority?: 'provider' | 'daemon';
     coverage?: 'full' | 'tail' | 'current-turn';
 }
@@ -94,6 +142,10 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;
@@ -103,6 +155,7 @@ export interface CliScriptInput {
     promptText?: string;
     settings?: Record<string, any>;
     args?: Record<string, any>;
+    spawnAt?: number;
 }
 
 export interface CliStatusInput {
@@ -141,16 +194,26 @@ export interface CliProviderModule {
     binary: string;
     approvalKeys?: Record<number, string>;
     sendDelayMs?: number;
+    /** Wall-clock budget (ms) for a single provider script invocation. Default 50. Range 1..5000.
+     *  Exceeding the budget records `timedOut: true` on the invocation trace and emits a
+     *  throttled WARN — it does NOT abort the script (Node CJS can't interrupt sync code). */
+    scriptCallBudgetMs?: number;
     sendKey?: string;
     submitStrategy?: 'wait_for_echo' | 'immediate';
     /** Require the typed prompt to be visible on the PTY screen before sending Enter. */
     requirePromptEchoBeforeSubmit?: boolean;
     /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
     allowInputDuringGeneration?: boolean;
+    /** When true, only transition to idle after the parsed transcript includes a final standard assistant message. */
+    requiresFinalAssistantBeforeIdle?: boolean;
+    /** When true, allow providers to augment stale snapshot data before parse. Reserved for future use. */
+    augmentStaleSnapshot?: boolean;
     /** When provider-owned, daemon treats provider parser output as canonical transcript authority. */
     transcriptAuthority?: 'provider' | 'daemon';
     /** Full context lets provider-owned parsers canonicalize retained history instead of daemon prefix stitching. */
     transcriptContext?: 'full' | 'tail';
+    /** v1 declarative tui block — used by CliScriptRunner to synthesize SDK helpers (declarativeDetectStatus, declarativeParseApproval). */
+    tui?: Record<string, unknown>;
     scripts?: CliScripts;
     spawn: {
         command: string;
@@ -342,7 +405,18 @@ export class TerminalTranscriptAccumulator {
         this.ensureRow();
         if (final === 'A') this.row = Math.max(0, this.row - count);
         else if (final === 'B') this.row += count;
-        else if (final === 'C') this.col += count;
+        else if (final === 'C') {
+            // (fix) Cursor-forward must materialize spaces in the cells it
+            // skips, otherwise rendered transcripts collapse "Do you" written
+            // as "Do\x1b[1Cyou" into "Doyou". That mis-rendering broke
+            // Claude Code's approval-prompt and prompt-line detection
+            // (parseApproval saw "Doyouwanttoproceed?" and returned null).
+            const line = this.lines[this.row];
+            for (let c = this.col; c < this.col + count; c += 1) {
+                if (line[c] === undefined) line[c] = ' ';
+            }
+            this.col += count;
+        }
         else if (final === 'D') this.col = Math.max(0, this.col - count);
         else if (final === 'G') this.col = Math.max(0, count - 1);
         else if (final === 'H' || final === 'f') {
@@ -484,17 +558,42 @@ export function findBinary(name: string): string {
         return path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
     }
     const isWin = os.platform() === 'win32';
-    try {
-        const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
-        return execSync(cmd, {
-            encoding: 'utf-8',
-            timeout: 5000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            ...(isWin ? { windowsHide: true } : {}),
-        }).trim().split('\n')[0].trim();
-    } catch {
-        return isWin ? `${trimmed}.cmd` : trimmed;
+    const paths = (process.env.PATH || '').split(path.delimiter);
+    // Also search well-known global-bin directories that are frequently NOT on
+    // the daemon's inherited PATH. A daemon running under one Node install (e.g.
+    // nvm) never sees another npm prefix's bin dir — notably npm's Windows
+    // default prefix at %APPDATA%\npm, where `npm i -g @openai/codex` lands. We
+    // append these after PATH (so explicit PATH entries still win) so that an
+    // npm-global CLI resolves to an absolute path; the spawn layer's .cmd-shim
+    // handling then launches it correctly regardless of PATH.
+    const extraDirs: string[] = [];
+    if (isWin) {
+        if (process.env.APPDATA) extraDirs.push(path.join(process.env.APPDATA, 'npm'));
+        try { extraDirs.push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+    } else {
+        extraDirs.push(path.join(os.homedir(), '.npm-global', 'bin'));
+        extraDirs.push('/usr/local/bin', '/opt/homebrew/bin');
+        try { extraDirs.push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+    }
+    const searchDirs = [...paths, ...extraDirs];
+    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+
+    for (const p of searchDirs) {
+        if (!p) continue;
+        for (const ext of exes) {
+            const fullPath = path.join(p, trimmed + ext);
+            try {
+                const fs = require('fs');
+                if (fs.existsSync(fullPath)) {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+                        return fullPath;
+                    }
+                }
+            } catch { }
+        }
     }
+    return isWin ? `${trimmed}.cmd` : trimmed;
 }
 
 export function isScriptBinary(binaryPath: string): boolean {

package/src/cli-adapters/pty-transport.ts

@@ -1,5 +1,6 @@
 import * as os from 'os';
 import { ensureNodePtySpawnHelperPermissions } from './spawn-env.js';
+import { resolveWin32Executable } from './resolve-executable.js';
 
 let cachedPty: any | null | undefined;
 
@@ -119,7 +120,7 @@ export class NodePtyTransportFactory implements PtyTransportFactory {
         cwd = os.homedir();
       }
     }
-    const handle = pty.spawn(command, args, {
+    const handle = pty.spawn(resolveWin32Executable(command), args, {
       name: 'xterm-256color',
       cols: options.cols,
       rows: options.rows,

package/src/cli-adapters/raw-terminal-io.ts

@@ -0,0 +1,252 @@
+import { randomUUID } from 'crypto';
+import {
+    SessionHostClient,
+    type SessionHostEndpoint,
+    type SessionHostRequest,
+    type SessionHostResponse,
+    type SessionTerminalSnapshot,
+    type SessionTerminalState,
+} from '@adhdev/session-host-core';
+
+type LowercaseLetter =
+    | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm'
+    | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+
+type FunctionKey = 'f1' | 'f2' | 'f3' | 'f4' | 'f5' | 'f6' | 'f7' | 'f8' | 'f9' | 'f10' | 'f11' | 'f12';
+type BaseNamedKey =
+    | 'enter' | 'escape' | 'tab' | 'backspace'
+    | 'up' | 'down' | 'left' | 'right'
+    | 'home' | 'end' | 'pageup' | 'pagedown' | 'space'
+    | FunctionKey;
+type ShiftNamedKey = BaseNamedKey | LowercaseLetter | `ctrl+${LowercaseLetter}` | `alt+${LowercaseLetter}`;
+
+export type NamedKey =
+    | BaseNamedKey
+    | `ctrl+${LowercaseLetter}`
+    | `alt+${LowercaseLetter}`
+    | `shift+${ShiftNamedKey}`;
+
+const BASE_KEY_SEQUENCES: Record<BaseNamedKey, string> = {
+    enter: '\r',
+    escape: '\x1b',
+    tab: '\t',
+    backspace: '\x7f',
+    up: '\x1b[A',
+    down: '\x1b[B',
+    right: '\x1b[C',
+    left: '\x1b[D',
+    home: '\x1b[H',
+    end: '\x1b[F',
+    pageup: '\x1b[5~',
+    pagedown: '\x1b[6~',
+    space: ' ',
+    f1: '\x1bOP',
+    f2: '\x1bOQ',
+    f3: '\x1bOR',
+    f4: '\x1bOS',
+    f5: '\x1b[15~',
+    f6: '\x1b[17~',
+    f7: '\x1b[18~',
+    f8: '\x1b[19~',
+    f9: '\x1b[20~',
+    f10: '\x1b[21~',
+    f11: '\x1b[23~',
+    f12: '\x1b[24~',
+};
+
+const SHIFTED_CSI_KEYS: Partial<Record<BaseNamedKey, string>> = {
+    up: '\x1b[1;2A',
+    down: '\x1b[1;2B',
+    right: '\x1b[1;2C',
+    left: '\x1b[1;2D',
+    home: '\x1b[1;2H',
+    end: '\x1b[1;2F',
+    pageup: '\x1b[5;2~',
+    pagedown: '\x1b[6;2~',
+    f1: '\x1b[1;2P',
+    f2: '\x1b[1;2Q',
+    f3: '\x1b[1;2R',
+    f4: '\x1b[1;2S',
+    f5: '\x1b[15;2~',
+    f6: '\x1b[17;2~',
+    f7: '\x1b[18;2~',
+    f8: '\x1b[19;2~',
+    f9: '\x1b[20;2~',
+    f10: '\x1b[21;2~',
+    f11: '\x1b[23;2~',
+    f12: '\x1b[24;2~',
+};
+
+function isLowercaseLetter(value: string): value is LowercaseLetter {
+    return /^[a-z]$/.test(value);
+}
+
+function encodeControlLetter(letter: LowercaseLetter): string {
+    return String.fromCharCode(letter.charCodeAt(0) - 96);
+}
+
+function encodeShiftedKey(key: string): string {
+    if (isLowercaseLetter(key)) return key.toUpperCase();
+    if (key.startsWith('ctrl+') && isLowercaseLetter(key.slice(5))) {
+        return encodeControlLetter(key.slice(5) as LowercaseLetter);
+    }
+    if (key.startsWith('alt+') && isLowercaseLetter(key.slice(4))) {
+        return `\x1b${key.slice(4).toUpperCase()}`;
+    }
+    if (key === 'tab') return '\x1b[Z';
+    if (key in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key as BaseNamedKey]!;
+    if (key in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key as BaseNamedKey];
+    throw new Error(`Unsupported named key: shift+${key}`);
+}
+
+export function namedKeyToAnsi(key: NamedKey | string): string {
+    const normalized = String(key || '').trim().toLowerCase();
+    if (normalized in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[normalized as BaseNamedKey];
+    if (normalized.startsWith('ctrl+') && isLowercaseLetter(normalized.slice(5))) {
+        return encodeControlLetter(normalized.slice(5) as LowercaseLetter);
+    }
+    if (normalized.startsWith('alt+') && isLowercaseLetter(normalized.slice(4))) {
+        return `\x1b${normalized.slice(4)}`;
+    }
+    if (normalized.startsWith('shift+')) return encodeShiftedKey(normalized.slice(6));
+    throw new Error(`Unsupported named key: ${key}`);
+}
+
+export function namedKeysToAnsi(keys: readonly (NamedKey | string)[]): string {
+    if (!Array.isArray(keys)) throw new Error('keys must be an array');
+    return keys.map(namedKeyToAnsi).join('');
+}
+
+export interface RawTerminalSessionHostClient {
+    connect(): Promise<void>;
+    request<T = unknown>(request: SessionHostRequest): Promise<SessionHostResponse<T>>;
+    close(): Promise<void>;
+}
+
+export interface RawTerminalAttachmentOptions {
+    endpoint?: SessionHostEndpoint;
+    sessionId: string;
+    mode?: 'read' | 'write';
+    clientId?: string;
+    client?: RawTerminalSessionHostClient;
+}
+
+export class RawTerminalAttachment {
+    private closed = false;
+
+    private constructor(
+        readonly sessionId: string,
+        private readonly clientId: string,
+        private readonly mode: 'read' | 'write',
+        private readonly client: RawTerminalSessionHostClient,
+    ) {}
+
+    static async attach(options: RawTerminalAttachmentOptions): Promise<RawTerminalAttachment> {
+        const sessionId = String(options.sessionId || '').trim();
+        if (!sessionId) throw new Error('sessionId is required');
+        const mode = options.mode || 'read';
+        const clientId = options.clientId || `raw-terminal-${process.pid}-${randomUUID().slice(0, 8)}`;
+        const client = options.client || new SessionHostClient({ endpoint: options.endpoint });
+        await client.connect();
+
+        const attachResponse = await client.request({
+            type: 'attach_session',
+            payload: {
+                sessionId,
+                clientId,
+                clientType: 'web',
+                readOnly: mode === 'read',
+            },
+        });
+        if (!attachResponse.success) {
+            await client.close().catch(() => {});
+            throw new Error(attachResponse.error || `Failed to attach terminal session ${sessionId}`);
+        }
+
+        if (mode === 'write') {
+            const ownerResponse = await client.request({
+                type: 'acquire_write',
+                payload: {
+                    sessionId,
+                    clientId,
+                    ownerType: 'user',
+                    force: true,
+                },
+            });
+            if (!ownerResponse.success) {
+                await client.request({
+                    type: 'detach_session',
+                    payload: { sessionId, clientId },
+                }).catch(() => ({ success: false }));
+                await client.close().catch(() => {});
+                throw new Error(ownerResponse.error || `Failed to acquire terminal session ${sessionId}`);
+            }
+        }
+
+        return new RawTerminalAttachment(sessionId, clientId, mode, client);
+    }
+
+    async readSnapshot(): Promise<SessionTerminalSnapshot> {
+        const response = await this.client.request<SessionTerminalSnapshot>({
+            type: 'get_terminal_snapshot',
+            payload: { sessionId: this.sessionId },
+        });
+        if (!response.success || !response.result) {
+            throw new Error(response.error || `Terminal screen unavailable for ${this.sessionId}`);
+        }
+        return response.result;
+    }
+
+    async readScreenText(): Promise<string> {
+        return (await this.readSnapshot()).text;
+    }
+
+    async readState(): Promise<SessionTerminalState> {
+        return (await this.readSnapshot()).state;
+    }
+
+    async writeInput(text: string): Promise<void> {
+        if (this.mode !== 'write') throw new Error('Raw terminal attachment is read-only');
+        const response = await this.client.request({
+            type: 'send_input',
+            payload: {
+                sessionId: this.sessionId,
+                clientId: this.clientId,
+                data: text,
+            },
+        });
+        if (!response.success) throw new Error(response.error || `Failed to write terminal input to ${this.sessionId}`);
+    }
+
+    async writeKeys(keys: readonly (NamedKey | string)[]): Promise<void> {
+        await this.writeInput(namedKeysToAnsi(keys));
+    }
+
+    async close(): Promise<void> {
+        if (this.closed) return;
+        this.closed = true;
+        if (this.mode === 'write') {
+            await this.client.request({
+                type: 'release_write',
+                payload: { sessionId: this.sessionId, clientId: this.clientId },
+            }).catch(() => ({ success: false }));
+        }
+        await this.client.request({
+            type: 'detach_session',
+            payload: { sessionId: this.sessionId, clientId: this.clientId },
+        }).catch(() => ({ success: false }));
+        await this.client.close().catch(() => {});
+    }
+}
+
+export async function withRawTerminalAttachment<T>(
+    options: RawTerminalAttachmentOptions,
+    operation: (attachment: RawTerminalAttachment) => Promise<T>,
+): Promise<T> {
+    const attachment = await RawTerminalAttachment.attach(options);
+    try {
+        return await operation(attachment);
+    } finally {
+        await attachment.close();
+    }
+}