atoo-studio 0.0.1 → 0.0.2

package/dist/src/agents/claude-code-terminal/adapter.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from 'events';
+import type { Agent, AgentInitOptions, AgentSessionInfo, Attachment } from '../types.js';
+import type { SessionEvent } from '../../events/types.js';
+import type { WireMessage } from '../../events/wire.js';
+/**
+ * Terminal-only Claude Code agent.
+ * Spawns a plain `claude` PTY — no MITM proxy, no MCP, no /remote-control,
+ * no message parsing, no /context workflow. The user interacts purely via the
+ * terminal xterm view.
+ */
+export declare class ClaudeCodeTerminalAgent extends EventEmitter implements Agent {
+    readonly sessionId: string;
+    envId: string | null;
+    private status;
+    private mode;
+    private cwd;
+    private createdAt;
+    private destroyed;
+    private cliSessionId;
+    private activityTracker;
+    constructor(sessionId: string);
+    initialize(options: AgentInitOptions): Promise<void>;
+    destroy(): Promise<void>;
+    sendMessage(text: string, _attachments?: Attachment[]): void;
+    approve(_requestId: string, _updatedInput?: any): void;
+    deny(_requestId: string): void;
+    answerQuestion(_requestId: string, _answers: Record<string, string>): void;
+    setMode(_mode: string): void;
+    setModel(_model: string): void;
+    refreshContext(): void;
+    onFocused(): void;
+    onBlurred(): void;
+    sendKey(key: string): void;
+    getInfo(): AgentSessionInfo;
+    forkToResumable(_afterEventUuid: string, _fromEventUuid?: string, _targetDir?: string): string | null;
+    getMessages(): WireMessage[];
+    getEvents(): SessionEvent[];
+    getCliSessionId(): string | null;
+    getWireMessages(): WireMessage[];
+    private getCapabilities;
+    private setStatus;
+}

package/dist/src/agents/claude-code-terminal/adapter.js

@@ -0,0 +1,166 @@
+import { EventEmitter } from 'events';
+import os from 'os';
+import { getProcessPid, getPty, killCliProcess } from '../../spawner.js';
+import { spawnTerminalCliProcess } from './spawner.js';
+import { initFileTracking } from '../lib/fs-tracking.js';
+import { PtyActivityTracker } from '../lib/pty-activity-tracker.js';
+import { precreateClaudeSession } from '../lib/session-precreate.js';
+/**
+ * Terminal-only Claude Code agent.
+ * Spawns a plain `claude` PTY — no MITM proxy, no MCP, no /remote-control,
+ * no message parsing, no /context workflow. The user interacts purely via the
+ * terminal xterm view.
+ */
+export class ClaudeCodeTerminalAgent extends EventEmitter {
+    sessionId;
+    envId = null;
+    status = 'open';
+    mode = 'default';
+    cwd = null;
+    createdAt = Date.now();
+    destroyed = false;
+    cliSessionId = null;
+    activityTracker = null;
+    constructor(sessionId) {
+        super();
+        this.sessionId = sessionId;
+    }
+    async initialize(options) {
+        this.cwd = options.cwd || os.homedir();
+        if (options.skipPermissions) {
+            this.mode = 'bypassPermissions';
+        }
+        // Determine session UUID: use provided resume UUID, or pre-create a new one
+        const resumeUuid = options.resumeSessionUuid || precreateClaudeSession(this.cwd, options.initialMessage);
+        this.cliSessionId = resumeUuid;
+        try {
+            const { envId, preloadSessionId } = spawnTerminalCliProcess({
+                skipPermissions: options.skipPermissions,
+                cwd: this.cwd,
+                resumeSessionUuid: resumeUuid,
+                isChainContinuation: options.isChainContinuation,
+            });
+            this.envId = envId;
+            // Set up PTY activity tracking (burst detection → status events)
+            this.activityTracker = new PtyActivityTracker((status) => {
+                this.setStatus(status);
+            });
+            const pty = getPty(this.envId);
+            if (pty) {
+                pty.onData((data) => this.activityTracker?.onPtyData(data));
+            }
+            // Start file change detection (levels 1+2: LD_PRELOAD + inotify)
+            const pid = getProcessPid(this.envId);
+            if (pid) {
+                initFileTracking({
+                    sessionId: this.cliSessionId,
+                    cwd: this.cwd,
+                    pid,
+                    preloadSessionId,
+                });
+            }
+            this.emit('ready');
+        }
+        catch (err) {
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        if (this.activityTracker) {
+            this.activityTracker.dispose();
+            this.activityTracker = null;
+        }
+        if (this.envId) {
+            killCliProcess(this.envId);
+        }
+        this.setStatus('exited');
+        this.emit('exit');
+    }
+    // Terminal-only: type message directly into the PTY
+    sendMessage(text, _attachments) {
+        if (!text || !this.envId)
+            return;
+        const pty = getPty(this.envId);
+        if (!pty)
+            return;
+        // Delay to let the CLI TUI initialize and show its prompt
+        setTimeout(() => {
+            const p = getPty(this.envId);
+            if (p)
+                p.write(text + '\n');
+        }, 2000);
+    }
+    approve(_requestId, _updatedInput) { }
+    deny(_requestId) { }
+    answerQuestion(_requestId, _answers) { }
+    setMode(_mode) { }
+    setModel(_model) { }
+    refreshContext() { }
+    onFocused() { this.activityTracker?.onFocused(); }
+    onBlurred() { this.activityTracker?.onBlurred(); }
+    sendKey(key) {
+        if (!this.envId)
+            return;
+        const pty = getPty(this.envId);
+        if (!pty)
+            return;
+        const KEY_MAP = {
+            escape: '\x1b',
+        };
+        const sequence = KEY_MAP[key];
+        if (sequence) {
+            pty.write(sequence);
+        }
+    }
+    getInfo() {
+        return {
+            sessionId: this.sessionId,
+            agentType: 'claude-code-terminal',
+            agentMode: 'terminal',
+            status: this.status,
+            mode: this.mode,
+            cwd: this.cwd || undefined,
+            capabilities: this.getCapabilities(),
+            createdAt: this.createdAt,
+            cliSessionId: this.cliSessionId || undefined,
+        };
+    }
+    forkToResumable(_afterEventUuid, _fromEventUuid, _targetDir) {
+        return null;
+    }
+    getMessages() {
+        return [];
+    }
+    getEvents() {
+        return [];
+    }
+    getCliSessionId() {
+        return this.cliSessionId;
+    }
+    getWireMessages() {
+        return [];
+    }
+    getCapabilities() {
+        return {
+            canChangeMode: false,
+            canChangeModel: false,
+            hasContextUsage: false,
+            canFork: false,
+            canResume: true,
+            hasTerminal: true,
+            hasFileTracking: true,
+            availableModes: [],
+            availableModels: [],
+        };
+    }
+    setStatus(status) {
+        if (this.status === status)
+            return;
+        this.status = status;
+        this.emit('status', status);
+    }
+}

package/dist/src/agents/claude-code-terminal/index.d.ts

@@ -0,0 +1,13 @@
+import type { AgentFactory, Agent, AgentDescriptor, HistoricalSession } from '../types.js';
+import type { SessionEvent } from '../../events/types.js';
+export declare class ClaudeCodeTerminalAgentFactory implements AgentFactory {
+    agentType: string;
+    agentFamily: string;
+    create(sessionId: string): Agent;
+    getDescriptor(): AgentDescriptor;
+    getHistoricalSessions(): Promise<HistoricalSession[]>;
+    ownsSession(uuid: string): Promise<boolean>;
+    getSessionFilesForProject(cwds: string[]): Promise<string[]>;
+    readSessionEvents(uuid: string): Promise<SessionEvent[]>;
+    writeSessionForResume(events: SessionEvent[], targetUuid: string, directory: string): string;
+}

package/dist/src/agents/claude-code-terminal/index.js

@@ -0,0 +1,45 @@
+import { ClaudeCodeTerminalAgent } from './adapter.js';
+import { fsSessionScanner } from '../lib/claude/fs-sessions.js';
+import { writeForkedClaudeJsonl } from '../lib/claude/jsonl-writer.js';
+export class ClaudeCodeTerminalAgentFactory {
+    agentType = 'claude-code-terminal';
+    agentFamily = 'claude';
+    create(sessionId) {
+        return new ClaudeCodeTerminalAgent(sessionId);
+    }
+    getDescriptor() {
+        return {
+            agentType: this.agentType,
+            agentFamily: this.agentFamily,
+            name: 'Claude Code',
+            mode: 'terminal',
+            iconUrl: `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="#d97757" viewBox="0 0 16 16"><path d="m3.127 10.604 3.135-1.76.053-.153-.053-.085H6.11l-.525-.032-1.791-.048-1.554-.065-1.505-.08-.38-.081L0 7.832l.036-.234.32-.214.455.04 1.009.069 1.513.105 1.097.064 1.626.17h.259l.036-.105-.089-.065-.068-.064-1.566-1.062-1.695-1.121-.887-.646-.48-.327-.243-.306-.104-.67.435-.48.585.04.15.04.593.456 1.267.981 1.654 1.218.242.202.097-.068.012-.049-.109-.181-.9-1.626-.96-1.655-.428-.686-.113-.411a2 2 0 0 1-.068-.484l.496-.674L4.446 0l.662.089.279.242.411.94.666 1.48 1.033 2.014.302.597.162.553.06.17h.105v-.097l.085-1.134.157-1.392.154-1.792.052-.504.25-.605.497-.327.387.186.319.456-.045.294-.19 1.23-.37 1.93-.243 1.29h.142l.161-.16.654-.868 1.097-1.372.484-.545.565-.601.363-.287h.686l.505.751-.226.775-.707.895-.585.759-.839 1.13-.524.904.048.072.125-.012 1.897-.403 1.024-.186 1.223-.21.553.258.06.263-.218.536-1.307.323-1.533.307-2.284.54-.028.02.032.04 1.029.098.44.024h1.077l2.005.15.525.346.315.424-.053.323-.807.411-3.631-.863-.872-.218h-.12v.073l.726.71 1.331 1.202 1.667 1.55.084.383-.214.302-.226-.032-1.464-1.101-.565-.497-1.28-1.077h-.084v.113l.295.432 1.557 2.34.08.718-.112.234-.404.141-.444-.08-.911-1.28-.94-1.44-.759-1.291-.093.053-.448 4.821-.21.246-.484.186-.403-.307-.214-.496.214-.98.258-1.28.21-1.016.19-1.263.112-.42-.008-.028-.092.012-.953 1.307-1.448 1.957-1.146 1.227-.274.109-.477-.247.045-.44.266-.39 1.586-2.018.956-1.25.617-.723-.004-.105h-.036l-4.212 2.736-.75.096-.324-.302.04-.496.154-.162 1.267-.871z"/></svg>')}`,
+        };
+    }
+    async getHistoricalSessions() {
+        const fsSessions = await fsSessionScanner.scan();
+        return fsSessions.map(s => ({
+            id: s.uuid,
+            agentType: this.agentType,
+            title: s.title,
+            directory: s.directory,
+            lastModified: s.lastModified,
+            eventCount: s.eventCount,
+        }));
+    }
+    async ownsSession(uuid) {
+        if (fsSessionScanner.getByUuid(uuid))
+            return true;
+        await fsSessionScanner.scan();
+        return !!fsSessionScanner.getByUuid(uuid);
+    }
+    async getSessionFilesForProject(cwds) {
+        return fsSessionScanner.getFilesForProject(cwds);
+    }
+    async readSessionEvents(uuid) {
+        return fsSessionScanner.readEvents(uuid);
+    }
+    writeSessionForResume(events, targetUuid, directory) {
+        return writeForkedClaudeJsonl(events, targetUuid, directory);
+    }
+}

package/dist/src/agents/claude-code-terminal/spawner.d.ts

@@ -0,0 +1,9 @@
+export declare function spawnTerminalCliProcess(options: {
+    skipPermissions?: boolean;
+    cwd?: string;
+    resumeSessionUuid?: string;
+    isChainContinuation?: boolean;
+}): {
+    envId: string;
+    preloadSessionId: string;
+};

package/dist/src/agents/claude-code-terminal/spawner.js

@@ -0,0 +1,37 @@
+/**
+ * Claude Code Terminal–specific spawn logic.
+ * Plain `claude` PTY with MCP, system prompt, and LD_PRELOAD for file tracking.
+ */
+import os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+import { spawnProcess } from '../../spawner.js';
+import { ensureWorkspaceTrust } from '../lib/claude/workspace-trust.js';
+import { getMcpConfigPath, MCP_SYSTEM_PROMPT, CHAIN_SYSTEM_PROMPT } from '../../mcp/config.js';
+import { addPreloadEnv } from '../lib/fs-tracking.js';
+export function spawnTerminalCliProcess(options) {
+    const cwd = options.cwd || process.env.HOME || os.homedir();
+    ensureWorkspaceTrust(cwd);
+    const systemPrompt = options.isChainContinuation
+        ? MCP_SYSTEM_PROMPT + CHAIN_SYSTEM_PROMPT
+        : MCP_SYSTEM_PROMPT;
+    const mcpConfigPath = getMcpConfigPath(options.resumeSessionUuid);
+    const args = [];
+    if (options.skipPermissions)
+        args.push('--dangerously-skip-permissions');
+    args.push('--append-system-prompt', systemPrompt, '--mcp-config', mcpConfigPath);
+    if (options.resumeSessionUuid)
+        args.push('--resume', options.resumeSessionUuid);
+    const preloadSessionId = uuidv4();
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+    addPreloadEnv(env, preloadSessionId);
+    const { envId } = spawnProcess({
+        command: 'claude',
+        args,
+        cwd,
+        env,
+        preloadSessionId,
+        logPrefix: 'claude-terminal',
+    });
+    return { envId, preloadSessionId };
+}

package/dist/src/agents/claude-code-terminal-chatro/adapter.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from 'events';
+import type { Agent, AgentInitOptions, AgentSessionInfo, Attachment } from '../types.js';
+import type { SessionEvent } from '../../events/types.js';
+import type { WireMessage } from '../../events/wire.js';
+/**
+ * Terminal + Chat Read-Only agent.
+ * Spawns a plain `claude` PTY (like the terminal agent) but also watches
+ * the CLI's JSONL session file to stream messages into a read-only Chat UI.
+ */
+export declare class ClaudeCodeTerminalChatROAgent extends EventEmitter implements Agent {
+    readonly sessionId: string;
+    envId: string | null;
+    private status;
+    private mode;
+    private activityTracker;
+    private cwd;
+    private createdAt;
+    private destroyed;
+    private jsonlWatcher;
+    private toolTracker;
+    private wireMessages;
+    private events;
+    private pendingToolUses;
+    private sidechainSessions;
+    private cliSessionId;
+    private resumeSessionUuid;
+    private preloadedUuids;
+    constructor(sessionId: string);
+    initialize(options: AgentInitOptions): Promise<void>;
+    destroy(): Promise<void>;
+    sendMessage(text: string, _attachments?: Attachment[]): void;
+    approve(_requestId: string, _updatedInput?: any): void;
+    deny(_requestId: string): void;
+    answerQuestion(_requestId: string, _answers: Record<string, string>): void;
+    setMode(_mode: string): void;
+    setModel(_model: string): void;
+    refreshContext(): void;
+    onFocused(): void;
+    onBlurred(): void;
+    sendKey(key: string): void;
+    getInfo(): AgentSessionInfo;
+    forkToResumable(afterEventUuid: string, fromEventUuid?: string, targetDir?: string): string | null;
+    getCliSessionId(): string | null;
+    getMessages(): WireMessage[];
+    getEvents(): SessionEvent[];
+    getWireMessages(): WireMessage[];
+    private loadHistoricalMessages;
+    private handleJsonlEvent;
+    private getCapabilities;
+    private setStatus;
+}

package/dist/src/agents/claude-code-terminal-chatro/adapter.js

@@ -0,0 +1,301 @@
+import { EventEmitter } from 'events';
+import os from 'os';
+import { toWireMessages } from '../../events/wire.js';
+import { forkEventsToResumable } from '../lib/claude/jsonl-writer.js';
+import { getProcessPid, getPty, killCliProcess } from '../../spawner.js';
+import { spawnTerminalCliProcess } from './spawner.js';
+import { JsonlWatcher } from './jsonl-watcher.js';
+import { fsSessionScanner } from '../lib/claude/fs-sessions.js';
+import { initFileTracking, ToolResultFileTracker } from '../lib/fs-tracking.js';
+import { PtyActivityTracker } from '../lib/pty-activity-tracker.js';
+import { precreateClaudeSession } from '../lib/session-precreate.js';
+/**
+ * Terminal + Chat Read-Only agent.
+ * Spawns a plain `claude` PTY (like the terminal agent) but also watches
+ * the CLI's JSONL session file to stream messages into a read-only Chat UI.
+ */
+export class ClaudeCodeTerminalChatROAgent extends EventEmitter {
+    sessionId;
+    envId = null;
+    status = 'open';
+    mode = 'default';
+    activityTracker = null;
+    cwd = null;
+    createdAt = Date.now();
+    destroyed = false;
+    jsonlWatcher = null;
+    toolTracker = null;
+    wireMessages = [];
+    events = []; // canonical event store
+    pendingToolUses = new Map();
+    sidechainSessions = new Map(); // sessionId → parentToolUseId
+    cliSessionId = null; // CLI's own session UUID (JSONL filename)
+    resumeSessionUuid = null; // Original session UUID for parent linking
+    preloadedUuids = new Set(); // UUIDs from pre-loaded historical events
+    constructor(sessionId) {
+        super();
+        this.sessionId = sessionId;
+    }
+    async initialize(options) {
+        this.cwd = options.cwd || os.homedir();
+        if (options.skipPermissions) {
+            this.mode = 'bypassPermissions';
+        }
+        // Determine session UUID: use provided resume UUID, or pre-create a new one
+        const resumeUuid = options.resumeSessionUuid || precreateClaudeSession(this.cwd, options.initialMessage);
+        this.cliSessionId = resumeUuid;
+        try {
+            // Pre-load historical messages for resume (before spawning CLI)
+            if (options.resumeSessionUuid) {
+                this.resumeSessionUuid = options.resumeSessionUuid;
+                await this.loadHistoricalMessages(options.resumeSessionUuid);
+            }
+            // Create JSONL watcher and start tailing the known file immediately
+            this.jsonlWatcher = new JsonlWatcher({
+                cwd: this.cwd,
+                resumeUuid: resumeUuid,
+            });
+            this.jsonlWatcher.on('event', (event, metadata) => {
+                this.handleJsonlEvent(event, metadata);
+            });
+            this.jsonlWatcher.on('error', (err) => {
+                console.error(`[terminal-chatro] JSONL watcher error:`, err.message);
+            });
+            // Spawn the terminal PTY — always with --resume since we pre-created the file
+            const { envId, preloadSessionId } = spawnTerminalCliProcess({
+                skipPermissions: options.skipPermissions,
+                cwd: this.cwd,
+                resumeSessionUuid: resumeUuid,
+                isChainContinuation: options.isChainContinuation,
+            });
+            this.envId = envId;
+            // Set up PTY activity tracking (burst detection → status events)
+            this.activityTracker = new PtyActivityTracker((status) => {
+                this.setStatus(status);
+            });
+            const pty = getPty(this.envId);
+            if (pty) {
+                pty.onData((data) => this.activityTracker?.onPtyData(data));
+            }
+            // Start file change detection (all 3 levels)
+            const pid = getProcessPid(this.envId);
+            if (pid) {
+                initFileTracking({
+                    sessionId: this.cliSessionId,
+                    cwd: this.cwd,
+                    pid,
+                    preloadSessionId,
+                });
+            }
+            this.toolTracker = new ToolResultFileTracker(this.cliSessionId);
+            // Start tailing the known JSONL file — UUID is known, no discovery needed
+            this.jsonlWatcher.startTailingKnownUuid(resumeUuid);
+            this.emit('ready');
+        }
+        catch (err) {
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        if (this.activityTracker) {
+            this.activityTracker.dispose();
+            this.activityTracker = null;
+        }
+        if (this.jsonlWatcher) {
+            this.jsonlWatcher.stop();
+            this.jsonlWatcher = null;
+        }
+        if (this.envId) {
+            killCliProcess(this.envId);
+        }
+        this.setStatus('exited');
+        this.emit('exit');
+    }
+    // Terminal-only: type message directly into the PTY
+    sendMessage(text, _attachments) {
+        if (!text || !this.envId)
+            return;
+        const pty = getPty(this.envId);
+        if (!pty)
+            return;
+        setTimeout(() => {
+            const p = getPty(this.envId);
+            if (p)
+                p.write(text + '\n');
+        }, 2000);
+    }
+    approve(_requestId, _updatedInput) { }
+    deny(_requestId) { }
+    answerQuestion(_requestId, _answers) { }
+    setMode(_mode) { }
+    setModel(_model) { }
+    refreshContext() { }
+    onFocused() { this.activityTracker?.onFocused(); }
+    onBlurred() { this.activityTracker?.onBlurred(); }
+    sendKey(key) {
+        if (!this.envId)
+            return;
+        const pty = getPty(this.envId);
+        if (!pty)
+            return;
+        const KEY_MAP = {
+            escape: '\x1b',
+        };
+        const sequence = KEY_MAP[key];
+        if (sequence) {
+            pty.write(sequence);
+        }
+    }
+    getInfo() {
+        return {
+            sessionId: this.sessionId,
+            agentType: 'claude-code-terminal-chatro',
+            agentMode: 'terminal+chatRO',
+            status: this.status,
+            mode: this.mode,
+            cwd: this.cwd || undefined,
+            capabilities: this.getCapabilities(),
+            createdAt: this.createdAt,
+            cliSessionId: this.cliSessionId || undefined,
+        };
+    }
+    forkToResumable(afterEventUuid, fromEventUuid, targetDir) {
+        const dir = targetDir || this.cwd || os.homedir();
+        // Prefer the original resume UUID for parent linking — the CLI creates a new
+        // session UUID on --resume, but forks should link to the session the user sees.
+        const parentId = this.resumeSessionUuid || this.cliSessionId || this.sessionId;
+        return forkEventsToResumable(this.events, afterEventUuid, dir, parentId, fromEventUuid);
+    }
+    getCliSessionId() {
+        return this.cliSessionId;
+    }
+    getMessages() {
+        return this.wireMessages;
+    }
+    getEvents() {
+        return this.events;
+    }
+    getWireMessages() {
+        const wireToolUses = new Map();
+        const result = [];
+        for (const event of this.events) {
+            result.push(...toWireMessages(this.sessionId, event, wireToolUses));
+        }
+        return result;
+    }
+    async loadHistoricalMessages(uuid) {
+        try {
+            if (!fsSessionScanner.getByUuid(uuid)) {
+                fsSessionScanner.invalidate();
+                await fsSessionScanner.scan();
+            }
+            const historicalEvents = await fsSessionScanner.readEvents(uuid);
+            this.events.push(...historicalEvents);
+            // Track UUIDs so the JSONL watcher skips already-loaded events
+            for (const event of historicalEvents) {
+                if (event.uuid)
+                    this.preloadedUuids.add(event.uuid);
+            }
+            // Replay events through toWireMessages for correlation
+            const historyToolUses = new Map();
+            for (const event of historicalEvents) {
+                const wireMsgs = toWireMessages(this.sessionId, event, historyToolUses);
+                for (const msg of wireMsgs) {
+                    if (event.timestamp)
+                        msg.timestamp = event.timestamp;
+                    if (msg.type === 'tool_result' && !msg.isPending) {
+                        const pendingIdx = this.wireMessages.findIndex(m => m.type === 'tool_result' && m.isPending && m.requestId === msg.requestId);
+                        if (pendingIdx >= 0) {
+                            this.wireMessages[pendingIdx] = msg;
+                            continue;
+                        }
+                    }
+                    this.wireMessages.push(msg);
+                }
+            }
+            // Sync pendingToolUses with the history replay state
+            for (const [id, info] of historyToolUses) {
+                this.pendingToolUses.set(id, info);
+            }
+            console.log(`[terminal-chatro] Loaded ${this.wireMessages.length} historical messages for resume of ${uuid}`);
+        }
+        catch (err) {
+            console.warn(`[terminal-chatro] Failed to load historical messages for ${uuid}:`, err.message);
+        }
+    }
+    handleJsonlEvent(event, metadata) {
+        // Skip file-history-snapshot events
+        if (event.type === 'file-history-snapshot')
+            return;
+        // Skip events already loaded from historical pre-load
+        if (event.uuid && this.preloadedUuids.has(event.uuid))
+            return;
+        // Skip progress events from the main file when we're tailing the subagent's own file
+        // (progress events are condensed duplicates of the full subagent transcript)
+        if (!metadata && event.type === 'progress' && event.data?.agentId) {
+            if (this.jsonlWatcher && this.jsonlWatcher.tailedAgentIds.has(event.data.agentId)) {
+                return;
+            }
+        }
+        // Store the raw event as a SessionEvent
+        this.events.push(event);
+        // Level 3: detect file-modifying tool results
+        this.toolTracker?.processEvent(event);
+        // Track sidechain sessions (from main file events)
+        if (!metadata && event.isSidechain && event.parentUuid) {
+            if (event.sessionId) {
+                this.sidechainSessions.set(event.sessionId, event.parentUuid);
+            }
+        }
+        // Determine sidechain parentToolUseId:
+        // 1. From subagent metadata (subagent file tailing)
+        // 2. From event's own isSidechain + parentUuid fields
+        // 3. From tracked sidechain sessions
+        const parentToolUseId = metadata
+            ? metadata.parentToolUseID
+            : (event.isSidechain && event.parentUuid)
+                ? event.parentUuid
+                : (event.sessionId && this.sidechainSessions.has(event.sessionId))
+                    ? this.sidechainSessions.get(event.sessionId)
+                    : undefined;
+        const isSidechain = !!metadata || !!parentToolUseId;
+        const agentId = metadata?.agentId;
+        // Map JSONL event to WireMessages
+        const mapped = toWireMessages(this.sessionId, event, this.pendingToolUses);
+        for (const msg of mapped) {
+            // Tag sidechain messages
+            if (isSidechain && parentToolUseId) {
+                msg._sidechain = true;
+                msg._parentToolUseId = parentToolUseId;
+            }
+            if (agentId) {
+                msg._agentId = agentId;
+            }
+            this.wireMessages.push(msg);
+            this.emit('message', msg);
+        }
+    }
+    getCapabilities() {
+        return {
+            canChangeMode: false,
+            canChangeModel: false,
+            hasContextUsage: false,
+            canFork: true,
+            canResume: true,
+            hasTerminal: true,
+            hasFileTracking: true,
+            availableModes: [],
+            availableModels: [],
+        };
+    }
+    setStatus(status) {
+        if (this.status === status)
+            return;
+        this.status = status;
+        this.emit('status', status);
+    }
+}

package/dist/src/agents/claude-code-terminal-chatro/index.d.ts

@@ -0,0 +1,13 @@
+import type { AgentFactory, Agent, AgentDescriptor, HistoricalSession } from '../types.js';
+import type { SessionEvent } from '../../events/types.js';
+export declare class ClaudeCodeTerminalChatROAgentFactory implements AgentFactory {
+    agentType: string;
+    agentFamily: string;
+    create(sessionId: string): Agent;
+    getDescriptor(): AgentDescriptor;
+    getHistoricalSessions(): Promise<HistoricalSession[]>;
+    ownsSession(uuid: string): Promise<boolean>;
+    getSessionFilesForProject(cwds: string[]): Promise<string[]>;
+    readSessionEvents(uuid: string): Promise<SessionEvent[]>;
+    writeSessionForResume(events: SessionEvent[], targetUuid: string, directory: string): string;
+}