@love-moon/ai-sdk 0.2.20 → 0.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,5 +25,5 @@
     "@types/node": "^22.10.2",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "d622756"
+  "gitCommitId": "fa11085"
 }

package/dist/tui-session.d.ts

@@ -1,154 +0,0 @@
-export function profileNameForBackend(backend: any): any;
-export function parseCommandParts(commandLine: any): {
-    command: string;
-    args: string[];
-};
-export function buildResumeArgsForBackend(backend: any, sessionId: any): string[];
-export function resumeProviderForBackend(backend: any): "codex" | "copilot" | "claude" | null;
-export function createAiSession(backend: any, options?: {}): TuiAiSession;
-export class TuiAiSession extends EventEmitter<[never]> {
-    constructor(backend: any, options?: {});
-    backend: any;
-    options: {};
-    logger: any;
-    cwd: any;
-    sessionId: any;
-    history: any[];
-    pendingHistorySeed: boolean;
-    sessionInfo: {
-        backend: any;
-        sessionId: any;
-        sessionFilePath: any;
-    } | null;
-    command: string;
-    args: string[];
-    tuiDebug: boolean;
-    tuiTrace: boolean;
-    tuiTraceLines: number;
-    lastSignalSignature: string;
-    lastPollSignature: string;
-    lastSnapshotHash: string;
-    closeRequested: boolean;
-    closed: boolean;
-    closeWaiters: Set<any>;
-    sessionMessageHandler: any;
-    sessionMonitorPromise: Promise<void> | null;
-    sessionMonitorStopRequested: boolean;
-    sessionMonitorCursor: number;
-    sessionMonitorSessionId: string;
-    sessionMonitorSessionFilePath: string;
-    sessionMonitorActiveReplyTo: string;
-    sessionMonitorHasActiveReplyTarget: boolean;
-    sessionMonitorLastReplyTo: string;
-    sessionMonitorAwaitingFirstReply: boolean;
-    workingStatusHandler: any;
-    workingStatusMonitorPromise: Promise<void> | null;
-    workingStatusMonitorStopRequested: boolean;
-    lastReportedWorkingStatusLine: string;
-    turnDeadlineMs: any;
-    useSessionFileReplyStream: boolean;
-    sessionMonitorFastPollMs: any;
-    sessionMonitorSlowPollMs: any;
-    workingStatusPollMs: any;
-    driver: TuiDriver;
-    writeLog(message: any): void;
-    get threadId(): any;
-    get threadOptions(): {
-        model: any;
-    };
-    getSnapshot(): {
-        backend: any;
-        command: string;
-        args: string[];
-        cwd: any;
-        sessionId: any;
-        sessionInfo: {
-            backend: any;
-            sessionId: any;
-            sessionFilePath: any;
-        } | null;
-        useSessionFileReplyStream: boolean;
-    };
-    applySessionInfo(session: any): void;
-    getSessionInfo(): {
-        backend: any;
-        sessionId: any;
-        sessionFilePath: any;
-    } | null;
-    ensureSessionInfo(): Promise<{
-        backend: any;
-        sessionId: any;
-        sessionFilePath: any;
-    } | null>;
-    getSessionUsageSummary(): Promise<import("@love-moon/tui-driver").TuiSessionUsageSummary | null>;
-    usesSessionFileReplyStream(): boolean;
-    setSessionMessageHandler(handler: any): void;
-    setWorkingStatusHandler(handler: any): void;
-    setSessionReplyTarget(replyTo: any): void;
-    ensureSessionFileMonitor(): Promise<void>;
-    ensureWorkingStatusMonitor(): Promise<void>;
-    runSessionFileMonitor(): Promise<void>;
-    runWorkingStatusMonitor(): Promise<void>;
-    resolveSessionMonitorPollMs(): any;
-    normalizeCodexWorkingStatusLine(statusLine: any): string;
-    normalizeCopilotWorkingStatusLine(statusLine: any): string;
-    normalizeWorkingStatusLine(statusLine: any): string;
-    getCurrentReplyTarget(): string | undefined;
-    pollWorkingStatus(): Promise<void>;
-    pollSessionFileMessages(): Promise<void>;
-    createSessionClosedError(): Error;
-    createTurnTimeoutError(timeoutMs: any): Error;
-    createCloseGuard(): {
-        promise: Promise<any>;
-        cleanup: () => void;
-    };
-    createTurnTimeoutGuard(): {
-        promise: Promise<any>;
-        cleanup: () => void;
-    };
-    flushCloseWaiters(): void;
-    close(): Promise<void>;
-    getHealthStatus(): import("@love-moon/tui-driver").HealthStatus | {
-        healthy: boolean;
-        reason: string;
-        message: string;
-    };
-    buildPrompt(promptText: any, { useInitialImages }?: {
-        useInitialImages?: boolean | undefined;
-    }): string;
-    emitProgress(onProgress: any, payload: any): void;
-    trace(message: any): void;
-    formatSignalSummary(signals?: {}): {
-        prompt: string | undefined;
-        replyInProgress: boolean;
-        status: string | undefined;
-        done: string | undefined;
-        replyPreview: string | undefined;
-        blocks: any;
-    };
-    logSignals(state: any, signals: any, snapshot: any): void;
-    logSnapshot(state: any, snapshot: any): void;
-    runTurn(promptText: any, { useInitialImages, onProgress }?: {
-        useInitialImages?: boolean | undefined;
-    }): Promise<{
-        text: string;
-        usage: null;
-        items: never[];
-        events: never[];
-        provider?: undefined;
-        metadata?: undefined;
-    } | {
-        text: string;
-        usage: null;
-        items: never[];
-        events: never[];
-        provider: any;
-        metadata: {
-            source: string;
-            elapsed_ms: any;
-            signals: any;
-        };
-    }>;
-}
-import { EventEmitter } from "node:events";
-import { TuiDriver } from "@love-moon/tui-driver";

package/dist/tui-session.js

@@ -1,954 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { EventEmitter } from "node:events";
-import { setTimeout as delay } from "node:timers/promises";
-import yaml from "js-yaml";
-import { TuiDriver, claudeCodeProfile, codexProfile, copilotProfile } from "@love-moon/tui-driver";
-const CUSTOM_CLI_COMMAND = process.env.CONDUCTOR_CLI_COMMAND;
-const DEFAULT_ALLOW_CLI_LIST = loadAllowCliList();
-const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
-const MIN_TURN_DEADLINE_MS = 30 * 1000;
-const MAX_TURN_DEADLINE_MS = 30 * 60 * 1000;
-const BACKEND_PROFILE_MAP = {
-    codex: "codex",
-    code: "codex",
-    claude: "claude-code",
-    "claude-code": "claude-code",
-    copilot: "copilot",
-};
-function normalizeLogger(logger) {
-    if (typeof logger === "function") {
-        return { log: logger };
-    }
-    if (logger && typeof logger === "object") {
-        return logger;
-    }
-    return {};
-}
-function emitLog(logger, message) {
-    if (typeof logger?.log !== "function") {
-        return;
-    }
-    try {
-        logger.log(message);
-    }
-    catch {
-        // best effort
-    }
-}
-function tailLines(value, count = 6) {
-    if (!value)
-        return "";
-    const lines = String(value).split(/\r?\n/);
-    return lines.slice(Math.max(0, lines.length - Math.max(1, count))).join("\n");
-}
-export function profileNameForBackend(backend) {
-    const normalized = String(backend || "").trim().toLowerCase();
-    return BACKEND_PROFILE_MAP[normalized] || null;
-}
-export function parseCommandParts(commandLine) {
-    const normalized = String(commandLine || "").trim();
-    if (!normalized) {
-        return { command: "", args: [] };
-    }
-    const parts = normalized.split(/\s+/);
-    return {
-        command: parts[0],
-        args: parts.slice(1),
-    };
-}
-export function buildResumeArgsForBackend(backend, sessionId) {
-    const resumeSessionId = typeof sessionId === "string" ? sessionId.trim() : "";
-    if (!resumeSessionId) {
-        return [];
-    }
-    const normalizedBackend = String(backend || "").trim().toLowerCase();
-    if (normalizedBackend === "codex" || normalizedBackend === "code") {
-        return ["resume", resumeSessionId];
-    }
-    if (normalizedBackend === "claude" || normalizedBackend === "claude-code") {
-        return ["--resume", resumeSessionId];
-    }
-    if (normalizedBackend === "copilot") {
-        return [`--resume=${resumeSessionId}`];
-    }
-    throw new Error(`--resume is not supported for backend "${backend}"`);
-}
-export function resumeProviderForBackend(backend) {
-    const normalizedBackend = String(backend || "").trim().toLowerCase();
-    if (normalizedBackend === "codex" || normalizedBackend === "code") {
-        return "codex";
-    }
-    if (normalizedBackend === "claude" || normalizedBackend === "claude-code") {
-        return "claude";
-    }
-    if (normalizedBackend === "copilot") {
-        return "copilot";
-    }
-    return null;
-}
-function loadAllowCliList(configFilePath) {
-    try {
-        const home = os.homedir();
-        const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
-        if (fs.existsSync(configPath)) {
-            const content = fs.readFileSync(configPath, "utf8");
-            const parsed = yaml.load(content);
-            if (parsed && typeof parsed === "object" && parsed.allow_cli_list) {
-                return parsed.allow_cli_list;
-            }
-        }
-    }
-    catch {
-        // ignore error
-    }
-    return {};
-}
-function loadEnvConfig(configFilePath) {
-    try {
-        const home = os.homedir();
-        const configPath = configFilePath || process.env.CONDUCTOR_CONFIG || path.join(home, ".conductor", "config.yaml");
-        if (fs.existsSync(configPath)) {
-            const content = fs.readFileSync(configPath, "utf8");
-            const parsed = yaml.load(content);
-            if (parsed && typeof parsed === "object" && parsed.envs) {
-                return parsed.envs;
-            }
-        }
-    }
-    catch {
-        // ignore error
-    }
-    return null;
-}
-function proxyToEnv(envConfig) {
-    if (!envConfig || typeof envConfig !== "object") {
-        return {};
-    }
-    const env = {};
-    const mappings = {
-        http_proxy: ["HTTP_PROXY", "http_proxy"],
-        https_proxy: ["HTTPS_PROXY", "https_proxy"],
-        all_proxy: ["ALL_PROXY", "all_proxy"],
-        no_proxy: ["NO_PROXY", "no_proxy"],
-    };
-    for (const [key, envKeys] of Object.entries(mappings)) {
-        const value = envConfig[key] || envConfig[key.toUpperCase()];
-        if (!value) {
-            continue;
-        }
-        for (const envKey of envKeys) {
-            env[envKey] = value;
-        }
-    }
-    return env;
-}
-function truncateText(value, maxLen = 240) {
-    if (!value)
-        return "";
-    const text = String(value).trim();
-    if (text.length <= maxLen)
-        return text;
-    return `${text.slice(0, maxLen)}...`;
-}
-function isTruthyEnv(value) {
-    if (value === undefined || value === null)
-        return false;
-    const normalized = String(value).trim().toLowerCase();
-    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
-}
-function sanitizeForLog(value, maxLen = 180) {
-    if (!value)
-        return "";
-    return truncateText(String(value).replace(/\s+/g, " ").trim(), maxLen);
-}
-function getBoundedEnvInt(envName, fallback, min, max) {
-    const fallbackNumber = Number(fallback);
-    const normalizedFallback = Number.isFinite(fallbackNumber)
-        ? Math.min(Math.max(Math.round(fallbackNumber), min), max)
-        : min;
-    const raw = process.env[envName];
-    const parsed = Number.parseInt(String(raw ?? ""), 10);
-    if (!Number.isFinite(parsed)) {
-        return normalizedFallback;
-    }
-    return Math.min(Math.max(parsed, min), max);
-}
-export function createAiSession(backend, options = {}) {
-    return new TuiAiSession(backend, options);
-}
-export class TuiAiSession extends EventEmitter {
-    constructor(backend, options = {}) {
-        super();
-        this.backend = backend;
-        this.options = options;
-        this.logger = normalizeLogger(options.logger);
-        this.cwd =
-            typeof options.cwd === "string" && options.cwd.trim()
-                ? options.cwd.trim()
-                : process.cwd();
-        const resumeSessionId = typeof options.resumeSessionId === "string" ? options.resumeSessionId.trim() : "";
-        this.sessionId = resumeSessionId || `${backend}-${Date.now()}`;
-        this.history = Array.isArray(options.initialHistory) ? [...options.initialHistory] : [];
-        this.pendingHistorySeed = this.history.length > 0;
-        this.sessionInfo = null;
-        const allowCliList = options.configFile ? loadAllowCliList(options.configFile) : DEFAULT_ALLOW_CLI_LIST;
-        const cliCommand = CUSTOM_CLI_COMMAND || allowCliList[backend] || backend;
-        const { command, args } = parseCommandParts(cliCommand);
-        if (!command) {
-            throw new Error(`Invalid command for backend "${backend}"`);
-        }
-        const resumeArgs = buildResumeArgsForBackend(backend, resumeSessionId);
-        this.command = command;
-        this.args = [...args, ...resumeArgs];
-        this.tuiDebug = isTruthyEnv(process.env.CONDUCTOR_TUI_DEBUG);
-        this.tuiTrace = this.tuiDebug || isTruthyEnv(process.env.CONDUCTOR_TUI_TRACE);
-        this.tuiTraceLines = Number.isFinite(Number.parseInt(process.env.CONDUCTOR_TUI_TRACE_LINES || "", 10))
-            ? Math.max(2, Number.parseInt(process.env.CONDUCTOR_TUI_TRACE_LINES, 10))
-            : 8;
-        this.lastSignalSignature = "";
-        this.lastPollSignature = "";
-        this.lastSnapshotHash = "";
-        this.closeRequested = false;
-        this.closed = false;
-        this.closeWaiters = new Set();
-        this.sessionMessageHandler = null;
-        this.sessionMonitorPromise = null;
-        this.sessionMonitorStopRequested = false;
-        this.sessionMonitorCursor = 0;
-        this.sessionMonitorSessionId = "";
-        this.sessionMonitorSessionFilePath = "";
-        this.sessionMonitorActiveReplyTo = "";
-        this.sessionMonitorHasActiveReplyTarget = false;
-        this.sessionMonitorLastReplyTo = "";
-        this.sessionMonitorAwaitingFirstReply = false;
-        this.workingStatusHandler = null;
-        this.workingStatusMonitorPromise = null;
-        this.workingStatusMonitorStopRequested = false;
-        this.lastReportedWorkingStatusLine = "";
-        this.turnDeadlineMs = getBoundedEnvInt("CONDUCTOR_TURN_DEADLINE_MS", DEFAULT_TURN_DEADLINE_MS, MIN_TURN_DEADLINE_MS, MAX_TURN_DEADLINE_MS);
-        const profileName = profileNameForBackend(backend);
-        if (!profileName) {
-            throw new Error(`Backend "${backend}" is not supported by tui-driver`);
-        }
-        this.useSessionFileReplyStream = profileName === "codex" || profileName === "copilot";
-        this.sessionMonitorFastPollMs = getBoundedEnvInt("CONDUCTOR_CODEX_SESSION_FAST_POLL_MS", 700, 100, 10 * 1000);
-        this.sessionMonitorSlowPollMs = getBoundedEnvInt("CONDUCTOR_CODEX_SESSION_SLOW_POLL_MS", 2500, 300, 60 * 1000);
-        this.workingStatusPollMs = getBoundedEnvInt("CONDUCTOR_CODEX_TUI_STATUS_POLL_MS", 700, 100, 10 * 1000);
-        const profileMap = {
-            codex: codexProfile,
-            "claude-code": claudeCodeProfile,
-            copilot: copilotProfile,
-        };
-        const baseProfile = profileMap[profileName];
-        const effectiveDriverArgs = [...(baseProfile.args || []), ...this.args];
-        const envConfig = loadEnvConfig(options.configFile);
-        const proxyEnv = proxyToEnv(envConfig);
-        const cliEnv = envConfig && typeof envConfig === "object" ? { ...envConfig, ...proxyEnv } : proxyEnv;
-        if (Object.keys(proxyEnv).length > 0) {
-            this.writeLog(`Using proxy: ${proxyEnv.http_proxy || proxyEnv.https_proxy || proxyEnv.all_proxy}`);
-        }
-        this.writeLog(`Using TUI command for ${backend}: ${[this.command, ...effectiveDriverArgs].join(" ")} (cwd: ${this.cwd})`);
-        if (this.tuiTrace) {
-            this.writeLog(`[${this.backend}] [tui-trace] profile=${baseProfile.name} command=${this.command} args=${JSON.stringify(effectiveDriverArgs)}`);
-            this.writeLog(`[${this.backend}] [tui-trace] timeouts=${JSON.stringify(baseProfile.timeouts || {})} size=${baseProfile.cols || 120}x${baseProfile.rows || 40}`);
-        }
-        this.driver = new TuiDriver({
-            profile: {
-                ...baseProfile,
-                command: this.command,
-                args: effectiveDriverArgs,
-                env: {
-                    ...process.env,
-                    ...(baseProfile.env || {}),
-                    ...cliEnv,
-                },
-            },
-            cwd: this.cwd,
-            expectedSessionId: resumeSessionId || undefined,
-            debug: this.tuiDebug,
-            onSnapshot: this.tuiTrace
-                ? (snapshot, state) => {
-                    this.logSnapshot(state, snapshot);
-                }
-                : undefined,
-            onSignals: this.tuiTrace
-                ? (signals, snapshot, state) => {
-                    this.logSignals(state, signals, snapshot);
-                }
-                : undefined,
-        });
-        this.driver.on("login_required", (health) => {
-            this.writeLog(`[${this.backend}] [WARN] Login required detected: ${health.message || health.reason}`);
-            if (health.matchedPattern) {
-                this.writeLog(`[${this.backend}] [WARN] Matched pattern: "${health.matchedPattern}"`);
-            }
-            this.writeLog(`[${this.backend}] [WARN] Please run "${this.command} login" or authenticate manually.`);
-            this.emit("auth_required", health);
-        });
-        this.driver.on("session", (session) => {
-            this.applySessionInfo(session);
-        });
-    }
-    writeLog(message) {
-        emitLog(this.logger, message);
-    }
-    get threadId() {
-        return this.sessionId;
-    }
-    get threadOptions() {
-        return { model: this.backend };
-    }
-    getSnapshot() {
-        return {
-            backend: this.backend,
-            command: this.command,
-            args: [...this.args],
-            cwd: this.cwd,
-            sessionId: this.sessionId,
-            sessionInfo: this.getSessionInfo(),
-            useSessionFileReplyStream: this.usesSessionFileReplyStream(),
-        };
-    }
-    applySessionInfo(session) {
-        if (!session || typeof session !== "object") {
-            return;
-        }
-        const sessionId = typeof session.sessionId === "string" ? session.sessionId.trim() : "";
-        const sessionFilePath = typeof session.sessionFilePath === "string" ? session.sessionFilePath.trim() : "";
-        if (!sessionId) {
-            return;
-        }
-        this.sessionId = sessionId;
-        this.sessionInfo = {
-            backend: this.backend,
-            sessionId,
-            sessionFilePath: sessionFilePath || undefined,
-        };
-        this.trace(`session id=${sessionId} file="${sanitizeForLog(sessionFilePath, 180)}"`);
-        this.emit("session", this.getSessionInfo());
-        if (this.useSessionFileReplyStream) {
-            void this.ensureSessionFileMonitor();
-        }
-    }
-    getSessionInfo() {
-        if (this.sessionInfo) {
-            return { ...this.sessionInfo };
-        }
-        return null;
-    }
-    async ensureSessionInfo() {
-        if (!this.driver) {
-            return null;
-        }
-        try {
-            await this.driver.boot();
-        }
-        catch (error) {
-            this.trace(`session boot failed: ${sanitizeForLog(error?.message || error, 180)}`);
-            return this.getSessionInfo();
-        }
-        try {
-            if (typeof this.driver.ensureSessionInfo === "function") {
-                const detected = await this.driver.ensureSessionInfo();
-                this.applySessionInfo(detected);
-            }
-            else if (typeof this.driver.getSessionInfo === "function") {
-                this.applySessionInfo(this.driver.getSessionInfo());
-            }
-        }
-        catch (error) {
-            this.trace(`session detect failed: ${sanitizeForLog(error?.message || error, 180)}`);
-        }
-        return this.getSessionInfo();
-    }
-    async getSessionUsageSummary() {
-        if (!this.driver || typeof this.driver.getSessionUsageSummary !== "function") {
-            return null;
-        }
-        try {
-            const summary = await this.driver.getSessionUsageSummary();
-            return summary && typeof summary === "object" ? summary : null;
-        }
-        catch (error) {
-            this.trace(`session usage detect failed: ${sanitizeForLog(error?.message || error, 180)}`);
-            return null;
-        }
-    }
-    usesSessionFileReplyStream() {
-        return Boolean(this.useSessionFileReplyStream);
-    }
-    setSessionMessageHandler(handler) {
-        this.sessionMessageHandler = typeof handler === "function" ? handler : null;
-        if (this.useSessionFileReplyStream) {
-            void this.ensureSessionFileMonitor();
-        }
-    }
-    setWorkingStatusHandler(handler) {
-        this.workingStatusHandler = typeof handler === "function" ? handler : null;
-        if (this.useSessionFileReplyStream) {
-            void this.ensureWorkingStatusMonitor();
-        }
-    }
-    setSessionReplyTarget(replyTo) {
-        if (!this.useSessionFileReplyStream) {
-            return;
-        }
-        const normalizedReplyTo = typeof replyTo === "string" ? replyTo.trim() : "";
-        this.sessionMonitorActiveReplyTo = normalizedReplyTo;
-        this.sessionMonitorHasActiveReplyTarget = true;
-        if (normalizedReplyTo) {
-            this.sessionMonitorLastReplyTo = normalizedReplyTo;
-        }
-        this.sessionMonitorAwaitingFirstReply = true;
-        void this.ensureSessionFileMonitor();
-    }
-    async ensureSessionFileMonitor() {
-        if (!this.useSessionFileReplyStream || this.sessionMonitorPromise) {
-            return;
-        }
-        this.sessionMonitorStopRequested = false;
-        const monitorPromise = this.runSessionFileMonitor();
-        this.sessionMonitorPromise = monitorPromise;
-        monitorPromise.catch((error) => {
-            this.trace(`session monitor exited: ${sanitizeForLog(error?.message || error, 180)}`);
-        });
-    }
-    async ensureWorkingStatusMonitor() {
-        if (!this.useSessionFileReplyStream || this.workingStatusMonitorPromise) {
-            return;
-        }
-        this.workingStatusMonitorStopRequested = false;
-        const monitorPromise = this.runWorkingStatusMonitor();
-        this.workingStatusMonitorPromise = monitorPromise;
-        monitorPromise.catch((error) => {
-            this.trace(`working status monitor exited: ${sanitizeForLog(error?.message || error, 180)}`);
-        });
-    }
-    async runSessionFileMonitor() {
-        try {
-            while (!this.closeRequested && !this.sessionMonitorStopRequested) {
-                try {
-                    await this.pollSessionFileMessages();
-                }
-                catch (error) {
-                    this.trace(`session monitor poll failed: ${sanitizeForLog(error?.message || error, 180)}`);
-                }
-                await delay(this.resolveSessionMonitorPollMs());
-            }
-        }
-        finally {
-            this.sessionMonitorPromise = null;
-        }
-    }
-    async runWorkingStatusMonitor() {
-        try {
-            while (!this.closeRequested && !this.workingStatusMonitorStopRequested) {
-                try {
-                    await this.pollWorkingStatus();
-                }
-                catch (error) {
-                    this.trace(`working status monitor poll failed: ${sanitizeForLog(error?.message || error, 180)}`);
-                }
-                await delay(this.workingStatusPollMs);
-            }
-        }
-        finally {
-            this.workingStatusMonitorPromise = null;
-        }
-    }
-    resolveSessionMonitorPollMs() {
-        return this.sessionMonitorAwaitingFirstReply
-            ? this.sessionMonitorFastPollMs
-            : this.sessionMonitorSlowPollMs;
-    }
-    normalizeCodexWorkingStatusLine(statusLine) {
-        const normalized = typeof statusLine === "string" ? statusLine.trim() : "";
-        if (!normalized) {
-            return "";
-        }
-        if (/^\s*[•◦]\s*Working\b/i.test(normalized)) {
-            return normalized;
-        }
-        if (/\bWorking\s*\([^)]*\)/i.test(normalized)) {
-            return normalized;
-        }
-        return "";
-    }
-    normalizeCopilotWorkingStatusLine(statusLine) {
-        const normalized = typeof statusLine === "string" ? statusLine.trim() : "";
-        if (!normalized) {
-            return "";
-        }
-        if (/^\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+Esc to cancel/i.test(normalized)) {
-            return normalized;
-        }
-        if (/^\s*.+Esc to cancel/i.test(normalized)) {
-            return normalized;
-        }
-        return "";
-    }
-    normalizeWorkingStatusLine(statusLine) {
-        if (this.backend === "copilot") {
-            return this.normalizeCopilotWorkingStatusLine(statusLine);
-        }
-        return this.normalizeCodexWorkingStatusLine(statusLine);
-    }
-    getCurrentReplyTarget() {
-        if (this.sessionMonitorHasActiveReplyTarget) {
-            return this.sessionMonitorActiveReplyTo || undefined;
-        }
-        return this.sessionMonitorLastReplyTo || undefined;
-    }
-    async pollWorkingStatus() {
-        if (!this.useSessionFileReplyStream || !this.driver || !this.driver.running) {
-            return;
-        }
-        const signals = this.driver.getSignals();
-        const workingStatusLine = this.normalizeWorkingStatusLine(signals.statusLine);
-        if (workingStatusLine === this.lastReportedWorkingStatusLine) {
-            return;
-        }
-        this.lastReportedWorkingStatusLine = workingStatusLine;
-        if (typeof this.workingStatusHandler !== "function") {
-            return;
-        }
-        const payload = workingStatusLine
-            ? {
-                phase: "working_status_monitor",
-                source: "tui-driver",
-                reply_in_progress: true,
-                status_line: workingStatusLine,
-                replyTo: this.getCurrentReplyTarget(),
-            }
-            : {
-                phase: "working_status_clear",
-                source: "tui-driver",
-                reply_in_progress: false,
-                replyTo: this.getCurrentReplyTarget(),
-            };
-        await this.workingStatusHandler(payload);
-        this.emit("working_status", payload);
-    }
-    async pollSessionFileMessages() {
-        if (!this.useSessionFileReplyStream || !this.driver) {
-            return;
-        }
-        const sessionInfo = this.getSessionInfo();
-        if (!sessionInfo?.sessionId || !sessionInfo?.sessionFilePath) {
-            return;
-        }
-        const sessionId = String(sessionInfo.sessionId).trim();
-        const sessionFilePath = String(sessionInfo.sessionFilePath).trim();
-        if (!sessionId || !sessionFilePath) {
-            return;
-        }
-        const sessionChanged = sessionId !== this.sessionMonitorSessionId ||
-            sessionFilePath !== this.sessionMonitorSessionFilePath;
-        if (sessionChanged) {
-            this.sessionMonitorSessionId = sessionId;
-            this.sessionMonitorSessionFilePath = sessionFilePath;
-            this.sessionMonitorCursor = this.sessionMonitorAwaitingFirstReply
-                ? 0
-                : await this.driver.getSessionFileSize(sessionInfo);
-            this.trace(`session monitor bound id=${sessionId} file="${sanitizeForLog(sessionFilePath, 180)}" cursor=${this.sessionMonitorCursor}`);
-        }
-        const batch = await this.driver.readSessionAssistantMessagesSince(sessionInfo, this.sessionMonitorCursor);
-        this.sessionMonitorCursor = Number.isFinite(batch?.nextOffset)
-            ? batch.nextOffset
-            : this.sessionMonitorCursor;
-        const messages = Array.isArray(batch?.messages) ? batch.messages : [];
-        if (messages.length === 0) {
-            return;
-        }
-        for (const message of messages) {
-            const text = typeof message?.text === "string" ? message.text.trim() : "";
-            if (!text) {
-                continue;
-            }
-            this.history.push({ role: "assistant", content: text });
-            this.sessionMonitorAwaitingFirstReply = false;
-            const payload = {
-                ...message,
-                replyTo: this.sessionMonitorHasActiveReplyTarget
-                    ? this.sessionMonitorActiveReplyTo || undefined
-                    : this.sessionMonitorLastReplyTo || undefined,
-            };
-            if (typeof this.sessionMessageHandler === "function") {
-                await this.sessionMessageHandler(payload);
-            }
-            this.emit("assistant_message", payload);
-        }
-    }
-    createSessionClosedError() {
-        const error = new Error("TUI session closed");
-        error.reason = "session_closed";
-        return error;
-    }
-    createTurnTimeoutError(timeoutMs) {
-        const seconds = Math.max(1, Math.round(timeoutMs / 1000));
-        const error = new Error(`Turn exceeded hard deadline (${seconds}s)`);
-        error.reason = "turn_timeout";
-        error.timeoutMs = timeoutMs;
-        return error;
-    }
-    createCloseGuard() {
-        if (this.closeRequested) {
-            return {
-                promise: Promise.reject(this.createSessionClosedError()),
-                cleanup: () => { },
-            };
-        }
-        let waiter = null;
-        const promise = new Promise((_, reject) => {
-            waiter = () => {
-                reject(this.createSessionClosedError());
-            };
-            this.closeWaiters.add(waiter);
-        });
-        return {
-            promise,
-            cleanup: () => {
-                if (waiter) {
-                    this.closeWaiters.delete(waiter);
-                }
-            },
-        };
-    }
-    createTurnTimeoutGuard() {
-        if (!Number.isFinite(this.turnDeadlineMs) || this.turnDeadlineMs <= 0) {
-            return {
-                promise: new Promise(() => { }),
-                cleanup: () => { },
-            };
-        }
-        let timer = null;
-        const promise = new Promise((_, reject) => {
-            timer = setTimeout(() => {
-                reject(this.createTurnTimeoutError(this.turnDeadlineMs));
-            }, this.turnDeadlineMs);
-            if (typeof timer.unref === "function") {
-                timer.unref();
-            }
-        });
-        return {
-            promise,
-            cleanup: () => {
-                if (timer) {
-                    clearTimeout(timer);
-                }
-            },
-        };
-    }
-    flushCloseWaiters() {
-        if (!this.closeWaiters || this.closeWaiters.size === 0) {
-            return;
-        }
-        for (const waiter of this.closeWaiters) {
-            try {
-                waiter();
-            }
-            catch {
-                // best effort
-            }
-        }
-        this.closeWaiters.clear();
-    }
-    async close() {
-        if (this.closed) {
-            return;
-        }
-        this.closed = true;
-        this.closeRequested = true;
-        this.sessionMonitorStopRequested = true;
-        this.workingStatusMonitorStopRequested = true;
-        this.flushCloseWaiters();
-        if (this.driver) {
-            this.driver.kill();
-        }
-    }
-    getHealthStatus() {
-        if (!this.driver) {
-            return { healthy: false, reason: "not_initialized", message: "Driver not initialized" };
-        }
-        return this.driver.healthCheck();
-    }
-    buildPrompt(promptText, { useInitialImages = false } = {}) {
-        let effectivePrompt = String(promptText || "").trim();
-        if (!effectivePrompt) {
-            return "";
-        }
-        if (this.pendingHistorySeed) {
-            const historyText = this.history
-                .map((item) => {
-                const role = String(item?.role || "").toLowerCase() === "assistant" ? "Assistant" : "User";
-                return `${role}: ${String(item?.content || "").trim()}`;
-            })
-                .filter(Boolean)
-                .join("\n\n");
-            if (historyText) {
-                effectivePrompt = [
-                    "Continue the existing conversation with this history.",
-                    "",
-                    historyText,
-                    "",
-                    `User: ${effectivePrompt}`,
-                ].join("\n");
-            }
-            this.pendingHistorySeed = false;
-        }
-        const images = Array.isArray(this.options.initialImages) ? this.options.initialImages : [];
-        if (useInitialImages && images.length > 0) {
-            const imageContext = images.map((item, idx) => `${idx + 1}. ${item}`).join("\n");
-            effectivePrompt = `${effectivePrompt}\n\nAttached image files:\n${imageContext}`;
-        }
-        return effectivePrompt;
-    }
-    emitProgress(onProgress, payload) {
-        if (typeof onProgress !== "function") {
-            return;
-        }
-        try {
-            onProgress(payload);
-        }
-        catch {
-            // best effort
-        }
-    }
-    trace(message) {
-        if (!this.tuiTrace) {
-            return;
-        }
-        this.writeLog(`[${this.backend}] [tui-trace] ${message}`);
-    }
-    formatSignalSummary(signals = {}) {
-        return {
-            prompt: sanitizeForLog(signals.promptLine || "", 100) || undefined,
-            replyInProgress: Boolean(signals.replyInProgress),
-            status: sanitizeForLog(signals.statusLine || "", 140) || undefined,
-            done: sanitizeForLog(signals.statusDoneLine || "", 140) || undefined,
-            replyPreview: sanitizeForLog(signals.replyText || "", 180) || undefined,
-            blocks: Array.isArray(signals.replyBlocks) ? signals.replyBlocks.length : 0,
-        };
-    }
-    logSignals(state, signals, snapshot) {
-        const summary = this.formatSignalSummary(signals);
-        const signature = JSON.stringify(summary);
-        if (signature === this.lastSignalSignature) {
-            return;
-        }
-        this.lastSignalSignature = signature;
-        this.trace(`signals state=${state} hash=${snapshot?.hash || "n/a"} prompt="${summary.prompt || ""}" status="${summary.status || ""}" done="${summary.done || ""}" replyInProgress=${summary.replyInProgress} blocks=${summary.blocks} preview="${summary.replyPreview || ""}"`);
-    }
-    logSnapshot(state, snapshot) {
-        if (!snapshot || snapshot.hash === this.lastSnapshotHash) {
-            return;
-        }
-        this.lastSnapshotHash = snapshot.hash;
-        const viewportTail = sanitizeForLog(tailLines(snapshot.viewportText, this.tuiTraceLines), 400);
-        this.trace(`snapshot state=${state} hash=${snapshot.hash} cursor=${snapshot.cursor?.x || 0},${snapshot.cursor?.y || 0} tail="${viewportTail}"`);
-    }
-    async runTurn(promptText, { useInitialImages = false, onProgress } = {}) {
-        if (this.closeRequested) {
-            throw this.createSessionClosedError();
-        }
-        const effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
-        if (!effectivePrompt) {
-            return {
-                text: "",
-                usage: null,
-                items: [],
-                events: [],
-            };
-        }
-        this.writeLog(`[${this.backend}] Running prompt: ${truncateText(effectivePrompt, 100)}...`);
-        this.trace(`runTurn start promptLen=${effectivePrompt.length} useInitialImages=${Boolean(useInitialImages)}`);
-        const useSessionFileReplyStream = this.usesSessionFileReplyStream();
-        const handleStateChange = (transition) => {
-            this.trace(`state ${transition.from} -> ${transition.to}`);
-            if (useSessionFileReplyStream) {
-                return;
-            }
-            this.emitProgress(onProgress, {
-                state: transition.to,
-                phase: "state_change",
-                source: "tui-driver",
-            });
-        };
-        this.driver.on("stateChange", handleStateChange);
-        const signalTimer = setInterval(() => {
-            const signals = this.driver.getSignals();
-            if (this.tuiTrace) {
-                const pollSummary = this.formatSignalSummary(signals);
-                const pollSignature = JSON.stringify({
-                    state: this.driver.state,
-                    replyInProgress: pollSummary.replyInProgress,
-                    status: pollSummary.status,
-                    done: pollSummary.done,
-                    preview: pollSummary.replyPreview,
-                });
-                if (pollSignature !== this.lastPollSignature) {
-                    this.lastPollSignature = pollSignature;
-                    this.trace(`poll state=${this.driver.state} replyInProgress=${pollSummary.replyInProgress} status="${pollSummary.status || ""}" done="${pollSummary.done || ""}" preview="${pollSummary.replyPreview || ""}"`);
-                }
-            }
-            if (useSessionFileReplyStream) {
-                return;
-            }
-            this.emitProgress(onProgress, {
-                state: this.driver.state,
-                phase: "signal_poll",
-                source: "tui-driver",
-                reply_in_progress: Boolean(signals.replyInProgress),
-                status_line: signals.statusLine || undefined,
-                status_done_line: signals.statusDoneLine || undefined,
-                reply_preview: truncateText(signals.replyText || "", 240) || undefined,
-            });
-        }, 700);
-        if (typeof signalTimer.unref === "function") {
-            signalTimer.unref();
-        }
-        const previousCwd = process.cwd();
-        const shouldSwitchCwd = this.cwd && this.cwd !== previousCwd;
-        if (shouldSwitchCwd) {
-            try {
-                process.chdir(this.cwd);
-            }
-            catch (error) {
-                throw new Error(`Failed to switch backend cwd to ${this.cwd}: ${error?.message || error}`);
-            }
-        }
-        const closeGuard = this.createCloseGuard();
-        const turnTimeoutGuard = this.createTurnTimeoutGuard();
-        if (useSessionFileReplyStream) {
-            this.history.push({ role: "user", content: promptText });
-            void this.ensureSessionFileMonitor();
-            void this.ensureWorkingStatusMonitor();
-        }
-        try {
-            const result = await Promise.race([this.driver.ask(effectivePrompt), closeGuard.promise, turnTimeoutGuard.promise]);
-            const answer = String(result.answer || result.replyText || "").trim();
-            this.trace(`runTurn finished success=${Boolean(result.success)} elapsedMs=${result.elapsedMs} answerLen=${answer.length} state=${this.driver.state}`);
-            if (!useSessionFileReplyStream) {
-                this.history.push({ role: "user", content: promptText });
-            }
-            if (answer && !useSessionFileReplyStream) {
-                this.history.push({ role: "assistant", content: answer });
-            }
-            if (!useSessionFileReplyStream) {
-                this.emitProgress(onProgress, {
-                    state: result.success ? "DONE" : "ERROR",
-                    phase: "turn_result",
-                    source: "tui-driver",
-                    reply_in_progress: false,
-                    status_line: result.statusLine || undefined,
-                    status_done_line: result.statusDoneLine || undefined,
-                    reply_preview: truncateText(result.replyText || answer, 240) || undefined,
-                });
-            }
-            if (!result.success) {
-                const error = result.error || new Error("tui-driver failed to complete this turn");
-                throw error;
-            }
-            this.writeLog(`[${this.backend}] Response received: ${truncateText(answer, 100)}...`);
-            this.trace(`runTurn reply preview="${sanitizeForLog(answer, 220)}"`);
-            return {
-                text: answer,
-                usage: null,
-                items: [],
-                events: [],
-                provider: this.backend,
-                metadata: {
-                    source: "tui-driver",
-                    elapsed_ms: result.elapsedMs,
-                    signals: result.signals ?? null,
-                },
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const errorReason = error?.reason || "unknown";
-            if (errorReason === "session_closed") {
-                this.trace("runTurn interrupted because backend session is closing");
-                throw error instanceof Error ? error : new Error(errorMessage);
-            }
-            if (errorReason === "turn_timeout") {
-                this.emitProgress(onProgress, {
-                    state: "ERROR",
-                    phase: "timeout_recovered",
-                    source: "tui-driver",
-                    error: errorMessage,
-                    reason: errorReason,
-                    timeout_ms: error?.timeoutMs,
-                });
-                this.writeLog(`[${this.backend}] Turn timed out (${error?.timeoutMs || this.turnDeadlineMs}ms), restarting TUI session`);
-                try {
-                    await this.driver.forceRestart();
-                }
-                catch (restartError) {
-                    this.writeLog(`[${this.backend}] Failed to restart TUI after timeout: ${restartError?.message || restartError}`);
-                }
-                this.writeLog(`[${this.backend}] Error: ${errorMessage}`);
-            }
-            else if (errorReason === "login_required") {
-                this.emitProgress(onProgress, {
-                    state: "ERROR",
-                    phase: "login_required",
-                    source: "tui-driver",
-                    error: errorMessage,
-                    reason: errorReason,
-                    matched_pattern: error?.matchedPattern,
-                });
-                this.writeLog(`[${this.backend}] Login required: ${errorMessage}`);
-                this.writeLog(`[${this.backend}] Please run "${this.command} login" or authenticate manually.`);
-            }
-            else if (errorReason === "permission_required") {
-                this.emitProgress(onProgress, {
-                    state: "ERROR",
-                    phase: "permission_required",
-                    source: "tui-driver",
-                    error: errorMessage,
-                    reason: errorReason,
-                    matched_pattern: error?.matchedPattern,
-                });
-                this.writeLog(`[${this.backend}] Permission required: ${errorMessage}`);
-            }
-            else {
-                this.emitProgress(onProgress, {
-                    state: "ERROR",
-                    phase: "exception",
-                    source: "tui-driver",
-                    error: errorMessage,
-                    reason: errorReason,
-                });
-                this.writeLog(`[${this.backend}] Error: ${errorMessage}`);
-            }
-            let latestSignals = {};
-            try {
-                latestSignals = this.driver.getSignals();
-            }
-            catch {
-                // driver may already be disposed while closing
-            }
-            const summary = this.formatSignalSummary(latestSignals);
-            this.trace(`runTurn exception state=${this.driver.state} error="${sanitizeForLog(errorMessage, 220)}" status="${summary.status || ""}" done="${summary.done || ""}" preview="${summary.replyPreview || ""}"`);
-            throw error instanceof Error ? error : new Error(errorMessage);
-        }
-        finally {
-            if (shouldSwitchCwd) {
-                try {
-                    process.chdir(previousCwd);
-                }
-                catch (error) {
-                    this.writeLog(`Failed to restore cwd to ${previousCwd}: ${error?.message || error}`);
-                }
-            }
-            clearInterval(signalTimer);
-            this.driver.off("stateChange", handleStateChange);
-            turnTimeoutGuard.cleanup();
-            closeGuard.cleanup();
-            this.trace(`runTurn cleanup state=${this.driver.state}`);
-        }
-    }
-}