@co0ontty/wand 0.2.1 → 0.4.0

package/dist/session-lifecycle.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Session Lifecycle Manager
+ * Inspired by Happy's session lifecycle management
+ */
+import type { SessionLifecycleState, SessionLifecycle } from "./types.js";
+export interface SessionLifecycleEvents {
+    onStateChange?: (sessionId: string, oldState: SessionLifecycleState, newState: SessionLifecycleState) => void;
+    onIdle?: (sessionId: string) => void;
+    onArchived?: (sessionId: string, reason: string) => void;
+}
+export declare class SessionLifecycleManager {
+    private sessions;
+    private events;
+    private idleTimeout;
+    private archiveTimeout;
+    private checkInterval;
+    constructor(events?: SessionLifecycleEvents, options?: {
+        idleTimeout?: number;
+        archiveTimeout?: number;
+    });
+    /**
+     * Register a new session
+     */
+    register(sessionId: string, initialState?: SessionLifecycleState): void;
+    /**
+     * Update session state
+     */
+    setState(sessionId: string, newState: SessionLifecycleState): void;
+    /**
+     * Update last activity timestamp
+     */
+    touch(sessionId: string): void;
+    /**
+     * Mark session as thinking
+     */
+    startThinking(sessionId: string): void;
+    /**
+     * Mark session as done thinking
+     */
+    stopThinking(sessionId: string): void;
+    /**
+     * Mark session as waiting for input
+     */
+    waitingInput(sessionId: string): void;
+    /**
+     * Archive a session
+     */
+    archive(sessionId: string, reason: string, by?: "user" | "timeout" | "error"): void;
+    /**
+     * Unregister a session
+     */
+    unregister(sessionId: string): void;
+    /**
+     * Get session lifecycle
+     */
+    get(sessionId: string): SessionLifecycle | undefined;
+    /**
+     * Get all sessions
+     */
+    getAll(): Map<string, SessionLifecycle>;
+    /**
+     * Get sessions by state
+     */
+    getByState(state: SessionLifecycleState): string[];
+    /**
+     * Start periodic check for idle/archived sessions
+     */
+    private startPeriodicCheck;
+    /**
+     * Stop periodic check
+     */
+    stopPeriodicCheck(): void;
+    /**
+     * Check sessions for idle/archived status
+     */
+    private checkSessions;
+    /**
+     * Cleanup all sessions
+     */
+    cleanup(): void;
+}

package/dist/session-lifecycle.js

@@ -0,0 +1,181 @@
+/**
+ * Session Lifecycle Manager
+ * Inspired by Happy's session lifecycle management
+ */
+export class SessionLifecycleManager {
+    sessions = new Map();
+    events;
+    idleTimeout;
+    archiveTimeout;
+    checkInterval = null;
+    constructor(events = {}, options = {}) {
+        this.events = events;
+        this.idleTimeout = options.idleTimeout ?? 5 * 60 * 1000; // 5 minutes
+        this.archiveTimeout = options.archiveTimeout ?? 30 * 60 * 1000; // 30 minutes
+        // Start periodic check
+        this.startPeriodicCheck();
+    }
+    /**
+     * Register a new session
+     */
+    register(sessionId, initialState = "initializing") {
+        const lifecycle = {
+            state: initialState,
+            stateSince: Date.now(),
+            lastActivityAt: Date.now(),
+        };
+        this.sessions.set(sessionId, lifecycle);
+        console.error(`[Lifecycle] Session ${sessionId} registered with state: ${initialState}`);
+    }
+    /**
+     * Update session state
+     */
+    setState(sessionId, newState) {
+        const lifecycle = this.sessions.get(sessionId);
+        if (!lifecycle) {
+            console.error(`[Lifecycle] Session ${sessionId} not found`);
+            return;
+        }
+        const oldState = lifecycle.state;
+        if (oldState === newState) {
+            return;
+        }
+        lifecycle.state = newState;
+        lifecycle.stateSince = Date.now();
+        lifecycle.lastActivityAt = Date.now();
+        console.error(`[Lifecycle] Session ${sessionId} state changed: ${oldState} -> ${newState}`);
+        // Emit state change event
+        this.events.onStateChange?.(sessionId, oldState, newState);
+    }
+    /**
+     * Update last activity timestamp
+     */
+    touch(sessionId) {
+        const lifecycle = this.sessions.get(sessionId);
+        if (lifecycle) {
+            lifecycle.lastActivityAt = Date.now();
+        }
+    }
+    /**
+     * Mark session as thinking
+     */
+    startThinking(sessionId) {
+        this.setState(sessionId, "thinking");
+    }
+    /**
+     * Mark session as done thinking
+     */
+    stopThinking(sessionId) {
+        const lifecycle = this.sessions.get(sessionId);
+        if (lifecycle?.state === "thinking") {
+            this.setState(sessionId, "idle");
+        }
+    }
+    /**
+     * Mark session as waiting for input
+     */
+    waitingInput(sessionId) {
+        this.setState(sessionId, "waiting-input");
+    }
+    /**
+     * Archive a session
+     */
+    archive(sessionId, reason, by = "user") {
+        const lifecycle = this.sessions.get(sessionId);
+        if (!lifecycle) {
+            return;
+        }
+        lifecycle.state = "archived";
+        lifecycle.stateSince = Date.now();
+        lifecycle.archivedBy = by;
+        lifecycle.archiveReason = reason;
+        console.error(`[Lifecycle] Session ${sessionId} archived: ${reason} (by: ${by})`);
+        // Emit archived event
+        this.events.onArchived?.(sessionId, reason);
+    }
+    /**
+     * Unregister a session
+     */
+    unregister(sessionId) {
+        this.sessions.delete(sessionId);
+        console.error(`[Lifecycle] Session ${sessionId} unregistered`);
+    }
+    /**
+     * Get session lifecycle
+     */
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Get all sessions
+     */
+    getAll() {
+        return new Map(this.sessions);
+    }
+    /**
+     * Get sessions by state
+     */
+    getByState(state) {
+        const result = [];
+        for (const [sessionId, lifecycle] of this.sessions) {
+            if (lifecycle.state === state) {
+                result.push(sessionId);
+            }
+        }
+        return result;
+    }
+    /**
+     * Start periodic check for idle/archived sessions
+     */
+    startPeriodicCheck() {
+        if (this.checkInterval) {
+            return;
+        }
+        this.checkInterval = setInterval(() => {
+            this.checkSessions();
+        }, 60 * 1000); // Check every minute
+    }
+    /**
+     * Stop periodic check
+     */
+    stopPeriodicCheck() {
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = null;
+        }
+    }
+    /**
+     * Check sessions for idle/archived status
+     */
+    checkSessions() {
+        const now = Date.now();
+        for (const [sessionId, lifecycle] of this.sessions) {
+            try {
+                if (lifecycle.state === "archived") {
+                    continue;
+                }
+                const timeSinceLastActivity = now - lifecycle.lastActivityAt;
+                // Check for archive timeout
+                if (timeSinceLastActivity > this.archiveTimeout) {
+                    this.archive(sessionId, "Session timed out", "timeout");
+                    continue;
+                }
+                // Check for idle timeout
+                if (timeSinceLastActivity > this.idleTimeout && lifecycle.state !== "idle") {
+                    this.setState(sessionId, "idle");
+                    this.events.onIdle?.(sessionId);
+                }
+            }
+            catch (err) {
+                console.error(`[Lifecycle] Error checking session ${sessionId}: ${String(err)}`);
+            }
+        }
+    }
+    /**
+     * Cleanup all sessions
+     */
+    cleanup() {
+        this.stopPeriodicCheck();
+        this.sessions.clear();
+    }
+}

package/dist/session-logger.d.ts

@@ -3,15 +3,23 @@ import type { ConversationTurn } from "./types.js";
  * SessionLogger saves raw session content to local files for debugging and analysis.
  *
  * Directory structure: .wand/sessions/{sessionId}/
- *   - pty-output.log     Raw PTY output (append-only)
- *   - stream-events.jsonl NDJSON events from native mode (append-only)
- *   - messages.json       Final structured messages (overwritten on each update)
+ *   - pty-output.log       Raw PTY output (current, rotated when > 50 MB)
+ *   - pty-output.log.1..3  Rotated PTY output backups
+ *   - stream-events.jsonl  NDJSON events from native mode (append-only)
+ *   - messages.json        Final structured messages (overwritten on each update)
  */
 export declare class SessionLogger {
     private readonly baseDir;
     private readonly dirs;
     constructor(configDir: string);
     private ensureDir;
+    /**
+     * Rotate PTY log files if the current one exceeds the size limit.
+     * pty-output.log.2 → pty-output.log.3 (deleted if at max)
+     * pty-output.log.1 → pty-output.log.2
+     * pty-output.log   → pty-output.log.1
+     */
+    private rotatePtyLog;
     /** Append raw PTY output chunk */
     appendPtyOutput(sessionId: string, chunk: string): void;
     /** Append a native mode NDJSON event */
@@ -20,4 +28,6 @@ export declare class SessionLogger {
     saveMessages(sessionId: string, messages: ConversationTurn[]): void;
     /** Save session metadata */
     saveMetadata(sessionId: string, meta: Record<string, unknown>): void;
+    /** Delete all log files for a session */
+    deleteSession(sessionId: string): void;
 }

package/dist/session-logger.js

@@ -1,13 +1,19 @@
-import { mkdirSync, appendFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, appendFileSync, writeFileSync, existsSync, statSync, renameSync, unlinkSync } from "node:fs";
 import path from "node:path";
 import process from "node:process";
+// ── Constants ──
+/** Max size for a single PTY log file before rotation (50 MB) */
+const PTY_LOG_MAX_SIZE = 50 * 1024 * 1024;
+/** Maximum number of rotated log files to keep */
+const PTY_LOG_MAX_ROTATIONS = 3;
 /**
  * SessionLogger saves raw session content to local files for debugging and analysis.
  *
  * Directory structure: .wand/sessions/{sessionId}/
- *   - pty-output.log     Raw PTY output (append-only)
- *   - stream-events.jsonl NDJSON events from native mode (append-only)
- *   - messages.json       Final structured messages (overwritten on each update)
+ *   - pty-output.log       Raw PTY output (current, rotated when > 50 MB)
+ *   - pty-output.log.1..3  Rotated PTY output backups
+ *   - stream-events.jsonl  NDJSON events from native mode (append-only)
+ *   - messages.json        Final structured messages (overwritten on each update)
  */
 export class SessionLogger {
     baseDir;
@@ -35,11 +41,45 @@ export class SessionLogger {
         this.dirs.set(sessionId, dir);
         return dir;
     }
+    /**
+     * Rotate PTY log files if the current one exceeds the size limit.
+     * pty-output.log.2 → pty-output.log.3 (deleted if at max)
+     * pty-output.log.1 → pty-output.log.2
+     * pty-output.log   → pty-output.log.1
+     */
+    rotatePtyLog(dir) {
+        // Delete oldest if it exists (beyond max rotations)
+        const oldest = path.join(dir, `pty-output.log.${PTY_LOG_MAX_ROTATIONS}`);
+        if (existsSync(oldest)) {
+            unlinkSync(oldest);
+        }
+        // Shift existing rotations up by one
+        for (let i = PTY_LOG_MAX_ROTATIONS - 1; i >= 1; i--) {
+            const src = path.join(dir, `pty-output.log.${i}`);
+            const dst = path.join(dir, `pty-output.log.${i + 1}`);
+            if (existsSync(src)) {
+                renameSync(src, dst);
+            }
+        }
+        // Rotate current to .1
+        const current = path.join(dir, "pty-output.log");
+        if (existsSync(current)) {
+            renameSync(current, path.join(dir, "pty-output.log.1"));
+        }
+    }
     /** Append raw PTY output chunk */
     appendPtyOutput(sessionId, chunk) {
         try {
             const dir = this.ensureDir(sessionId);
-            appendFileSync(path.join(dir, "pty-output.log"), chunk);
+            const logPath = path.join(dir, "pty-output.log");
+            // Check size and rotate if needed
+            if (existsSync(logPath)) {
+                const stats = statSync(logPath);
+                if (stats.size >= PTY_LOG_MAX_SIZE) {
+                    this.rotatePtyLog(dir);
+                }
+            }
+            appendFileSync(logPath, chunk);
         }
         catch {
             // Non-critical — don't let logging failures affect main flow
@@ -75,4 +115,15 @@ export class SessionLogger {
             // Non-critical
         }
     }
+    /** Delete all log files for a session */
+    deleteSession(sessionId) {
+        const dir = path.join(this.baseDir, sessionId);
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch {
+            // Non-critical
+        }
+        this.dirs.delete(sessionId);
+    }
 }

package/dist/storage.d.ts

@@ -27,6 +27,15 @@ export declare class WandStorage {
     deleteAuthSession(token: string): void;
     deleteExpiredAuthSessions(now: number): void;
     saveSession(snapshot: SessionSnapshot): void;
+    /**
+     * Lightweight update — only touches scalar session fields, skips messages.
+     * Use this in the hot persist path to avoid serializing large message arrays.
+     * Full messages are written by saveSession() at state transitions (exit/stop).
+     */
+    saveSessionMetadata(snapshot: SessionSnapshot): void;
+    getSession(id: string): SessionSnapshot | null;
+    getLatestSessionByClaudeSessionId(claudeSessionId: string): SessionSnapshot | null;
     loadSessions(): SessionSnapshot[];
+    private mapSessionRow;
     deleteSession(id: string): void;
 }

package/dist/storage.js

@@ -1,6 +1,17 @@
 import { existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+function parseStoredMessages(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
 export const DEFAULT_DB_FILE = "wand.db";
 export function resolveDatabasePath(configPath) {
     return path.resolve(path.dirname(configPath), DEFAULT_DB_FILE);
@@ -113,9 +124,10 @@ export class WandStorage {
         try {
             this.db
                 .prepare(`INSERT INTO command_sessions (
-             id, command, cwd, mode, status, exit_code, started_at, ended_at, output
+           id, command, cwd, mode, status, exit_code, started_at, ended_at, output
              , archived, archived_at, claude_session_id, messages
-           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+             , resumed_from_session_id, resumed_to_session_id, auto_recovered
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            ON CONFLICT(id) DO UPDATE SET
              command = excluded.command,
              cwd = excluded.cwd,
@@ -128,8 +140,11 @@ export class WandStorage {
              archived = excluded.archived,
              archived_at = excluded.archived_at,
              claude_session_id = excluded.claude_session_id,
-             messages = excluded.messages`)
-                .run(snapshot.id, snapshot.command, snapshot.cwd, snapshot.mode, snapshot.status, snapshot.exitCode, snapshot.startedAt, snapshot.endedAt, snapshot.output, snapshot.archived ? 1 : 0, snapshot.archivedAt, snapshot.claudeSessionId, snapshot.messages ? JSON.stringify(snapshot.messages) : null);
+             messages = excluded.messages,
+             resumed_from_session_id = excluded.resumed_from_session_id,
+             resumed_to_session_id = excluded.resumed_to_session_id,
+             auto_recovered = excluded.auto_recovered`)
+                .run(snapshot.id, snapshot.command, snapshot.cwd, snapshot.mode, snapshot.status, snapshot.exitCode, snapshot.startedAt, snapshot.endedAt, snapshot.output, snapshot.archived ? 1 : 0, snapshot.archivedAt, snapshot.claudeSessionId, snapshot.messages ? JSON.stringify(snapshot.messages) : null, snapshot.resumedFromSessionId ?? null, snapshot.resumedToSessionId ?? null, snapshot.autoRecovered ? 1 : 0);
             this.db.exec("COMMIT");
         }
         catch (error) {
@@ -137,13 +152,52 @@ export class WandStorage {
             throw error;
         }
     }
+    /**
+     * Lightweight update — only touches scalar session fields, skips messages.
+     * Use this in the hot persist path to avoid serializing large message arrays.
+     * Full messages are written by saveSession() at state transitions (exit/stop).
+     */
+    saveSessionMetadata(snapshot) {
+        this.db
+            .prepare(`UPDATE command_sessions SET
+           command = ?, cwd = ?, mode = ?, status = ?, exit_code = ?,
+           started_at = ?, ended_at = ?, output = ?,
+           archived = ?, archived_at = ?, claude_session_id = ?,
+           resumed_from_session_id = ?, resumed_to_session_id = ?, auto_recovered = ?
+         WHERE id = ?`)
+            .run(snapshot.command, snapshot.cwd, snapshot.mode, snapshot.status, snapshot.exitCode, snapshot.startedAt, snapshot.endedAt, snapshot.output, snapshot.archived ? 1 : 0, snapshot.archivedAt, snapshot.claudeSessionId, snapshot.resumedFromSessionId ?? null, snapshot.resumedToSessionId ?? null, snapshot.autoRecovered ? 1 : 0, snapshot.id);
+    }
+    getSession(id) {
+        const row = this.db
+            .prepare(`SELECT id, command, cwd, mode, status, exit_code, started_at, ended_at, output, archived, archived_at, claude_session_id, messages
+             , resumed_from_session_id, resumed_to_session_id, auto_recovered
+         FROM command_sessions
+         WHERE id = ?`)
+            .get(id);
+        return row ? this.mapSessionRow(row) : null;
+    }
+    getLatestSessionByClaudeSessionId(claudeSessionId) {
+        const row = this.db
+            .prepare(`SELECT id, command, cwd, mode, status, exit_code, started_at, ended_at, output, archived, archived_at, claude_session_id, messages
+             , resumed_from_session_id, resumed_to_session_id, auto_recovered
+         FROM command_sessions
+         WHERE claude_session_id = ?
+         ORDER BY started_at DESC
+         LIMIT 1`)
+            .get(claudeSessionId);
+        return row ? this.mapSessionRow(row) : null;
+    }
     loadSessions() {
         const rows = this.db
             .prepare(`SELECT id, command, cwd, mode, status, exit_code, started_at, ended_at, output, archived, archived_at, claude_session_id, messages
+             , resumed_from_session_id, resumed_to_session_id, auto_recovered
          FROM command_sessions
          ORDER BY started_at DESC`)
             .all();
-        return rows.map((row) => ({
+        return rows.map((row) => this.mapSessionRow(row));
+    }
+    mapSessionRow(row) {
+        return {
             id: row.id,
             command: row.command,
             cwd: row.cwd,
@@ -156,8 +210,11 @@ export class WandStorage {
             archived: Boolean(row.archived),
             archivedAt: row.archived_at,
             claudeSessionId: row.claude_session_id,
-            messages: row.messages ? JSON.parse(row.messages) : undefined
-        }));
+            messages: parseStoredMessages(row.messages),
+            resumedFromSessionId: row.resumed_from_session_id ?? undefined,
+            resumedToSessionId: row.resumed_to_session_id ?? undefined,
+            autoRecovered: Boolean(row.auto_recovered)
+        };
     }
     deleteSession(id) {
         this.db.prepare("DELETE FROM command_sessions WHERE id = ?").run(id);
@@ -178,4 +235,13 @@ function ensureCommandSessionSchema(db) {
     if (!names.has("messages")) {
         db.exec("ALTER TABLE command_sessions ADD COLUMN messages TEXT");
     }
+    if (!names.has("resumed_from_session_id")) {
+        db.exec("ALTER TABLE command_sessions ADD COLUMN resumed_from_session_id TEXT");
+    }
+    if (!names.has("resumed_to_session_id")) {
+        db.exec("ALTER TABLE command_sessions ADD COLUMN resumed_to_session_id TEXT");
+    }
+    if (!names.has("auto_recovered")) {
+        db.exec("ALTER TABLE command_sessions ADD COLUMN auto_recovered INTEGER NOT NULL DEFAULT 0");
+    }
 }

package/dist/types.d.ts

@@ -1,4 +1,28 @@
-export type ExecutionMode = "auto-edit" | "default" | "full-access" | "native" | "managed";
+export type ExecutionMode = "assist" | "agent" | "agent-max" | "default" | "auto-edit" | "full-access" | "native" | "managed";
+export type AutonomyPolicy = "assist" | "agent" | "agent-max";
+export type ApprovalPolicy = "ask-every-time" | "approve-once" | "remember-this-turn";
+export type EscalationScope = "write_file" | "run_command" | "network" | "outside_workspace" | "dangerous_shell" | "unknown";
+export type EscalationRunner = "json" | "pty";
+export type EscalationResolution = "approve_once" | "approve_turn" | "deny" | "fallback_manual";
+export type EscalationSource = "tool_permission_request" | "sandbox_hard_block" | "workspace_policy_limit" | "cli_capability_limit" | "unknown";
+export interface EscalationRequest {
+    requestId: string;
+    scope: EscalationScope;
+    runner: EscalationRunner;
+    source: EscalationSource;
+    resolution?: EscalationResolution;
+    target?: string;
+    reason: string;
+}
+export interface TurnRequest {
+    message: string;
+    autonomyPolicy?: AutonomyPolicy;
+    approvalPolicy?: ApprovalPolicy;
+    allowedScopes?: EscalationScope[];
+}
+export interface EscalationDecisionRequest {
+    resolution?: Extract<EscalationResolution, "approve_once" | "approve_turn" | "deny">;
+}
 export interface CommandPreset {
     label: string;
     command: string;
@@ -7,7 +31,7 @@ export interface CommandPreset {
 export interface WandConfig {
     host: string;
     port: number;
-    /** Enable HTTPS with self-signed certificate (default: true) */
+    /** Enable HTTPS with self-signed certificate (default: false) */
     https?: boolean;
     password: string;
     defaultMode: ExecutionMode;
@@ -25,8 +49,12 @@ export interface CommandRequest {
 }
 export interface InputRequest {
     input?: string;
-    /** Current UI view: "chat" or "terminal". Used to route via native pipeline in chat mode. */
+    /** Current UI view: "chat" or "terminal". Chat view uses PTY-derived structured messages. */
     view?: "chat" | "terminal";
+    autonomyPolicy?: AutonomyPolicy;
+    approvalPolicy?: ApprovalPolicy;
+    allowedScopes?: EscalationScope[];
+    turn?: TurnRequest;
 }
 export interface ResizeRequest {
     cols?: number;
@@ -70,14 +98,17 @@ export interface ToolUseBlock {
 export interface ToolResultBlock {
     type: "tool_result";
     tool_use_id: string;
-    content: string;
+    content: string | Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
     is_error?: boolean;
 }
 export type ContentBlock = TextBlock | ThinkingBlock | ToolUseBlock | ToolResultBlock;
 export interface ConversationTurn {
     role: "user" | "assistant";
     content: ContentBlock[];
-    /** Token usage for this turn (native mode only) */
+    /** Optional usage metadata when available from the underlying tool. */
     usage?: {
         inputTokens?: number;
         outputTokens?: number;
@@ -91,6 +122,9 @@ export interface SessionSnapshot {
     command: string;
     cwd: string;
     mode: ExecutionMode;
+    autonomyPolicy?: AutonomyPolicy;
+    approvalPolicy?: ApprovalPolicy;
+    allowedScopes?: EscalationScope[];
     status: "running" | "exited" | "failed" | "stopped";
     exitCode: number | null;
     startedAt: string;
@@ -98,8 +132,80 @@ export interface SessionSnapshot {
     output: string;
     archived: boolean;
     archivedAt: string | null;
+    /** Backward-compatible derived flag from pendingEscalation */
+    permissionBlocked?: boolean;
+    pendingEscalation?: EscalationRequest | null;
+    lastEscalationResult?: {
+        requestId: string;
+        resolution: EscalationResolution;
+        reason: string;
+    } | null;
     /** Claude Code 会话 ID，用于 --resume 恢复会话 */
     claudeSessionId: string | null;
-    /** Structured conversation messages (from JSON chat mode) */
+    /** Structured conversation messages derived from PTY output. */
     messages?: ConversationTurn[];
+    /** Session lifecycle state */
+    lifecycleState?: "running" | "idle" | "archived";
+    /** Last activity timestamp */
+    lastActivityAt?: string | null;
+    /** 此会话是从哪个 Wand 会话恢复而来 */
+    resumedFromSessionId?: string | null;
+    /** 此会话被哪个恢复后的会话替代 */
+    resumedToSessionId?: string | null;
+    /** 服务器重启时是否自动恢复 */
+    autoRecovered?: boolean;
+}
+export type SessionLifecycleState = "initializing" | "running" | "idle" | "thinking" | "waiting-input" | "archived";
+export interface SessionLifecycle {
+    state: SessionLifecycleState;
+    stateSince: number;
+    lastActivityAt: number;
+    archivedBy?: "user" | "timeout" | "error";
+    archiveReason?: string;
+}
+/** Unified event type emitted by ClaudePtyBridge for WebSocket broadcast */
+export type SessionEventType = "output.raw" | "output.chat" | "chat.turn" | "permission.prompt" | "permission.resolved" | "session.id" | "task" | "ended";
+export interface SessionEvent {
+    type: SessionEventType;
+    sessionId: string;
+    timestamp: number;
+    data?: unknown;
+}
+export interface RawOutputData {
+    chunk: string;
+    /** Full accumulated output for terminal view */
+    output: string;
+}
+export interface ChatOutputData {
+    /** Current messages array */
+    messages: ConversationTurn[];
+    /** Index of the message being streamed */
+    streamingIndex?: number;
+    /** Whether assistant is currently responding */
+    isResponding: boolean;
+}
+export interface ChatTurnData {
+    /** The completed turn */
+    turn: ConversationTurn;
+    /** Full messages array */
+    messages: ConversationTurn[];
+}
+export interface PermissionPromptData {
+    /** Detected prompt text */
+    prompt: string;
+    /** Inferred scope */
+    scope: EscalationScope;
+    /** Target if detected */
+    target?: string;
+}
+export interface SessionIdData {
+    /** Claude CLI session UUID */
+    claudeSessionId: string;
+}
+export interface TaskData {
+    title: string;
+    tool?: string;
+}
+export interface SessionEndData {
+    exitCode: number | null;
 }