Commit 800eb3b547aa5e073248f1db9272efe556df6928 | the-knife

apps/server/src/terminalManager.test.ts+76-4

...	@@ -2,10 +2,7 @@ import fs from "node:fs";	...	@@ -2,10 +2,7 @@ import fs from "node:fs";
2	import os from "node:os";	2	import os from "node:os";
3	import path from "node:path";	3	import path from "node:path";
4		4
5	import type {	5	import { DEFAULT_TERMINAL_ID, type TerminalEvent, type TerminalOpenInput } from "@t3tools/contracts";
6	TerminalEvent,
7	TerminalOpenInput,
8	} from "@t3tools/contracts";
9	import { afterEach, describe, expect, it } from "vitest";	6	import { afterEach, describe, expect, it } from "vitest";
10		7
11	import type { PtyAdapter, PtyExitEvent, PtyProcess, PtySpawnInput } from "./ptyAdapter";	8	import type { PtyAdapter, PtyExitEvent, PtyProcess, PtySpawnInput } from "./ptyAdapter";
...	@@ -109,10 +106,26 @@ function historyLogName(threadId: string): string {	...	@@ -109,10 +106,26 @@ function historyLogName(threadId: string): string {
109	return `terminal_${Buffer.from(threadId, "utf8").toString("base64url")}.log`;	106	return `terminal_${Buffer.from(threadId, "utf8").toString("base64url")}.log`;
110	}	107	}
111		108
		109	function multiTerminalHistoryLogName(threadId: string, terminalId: string): string {
		110	const threadPart = `terminal_${Buffer.from(threadId, "utf8").toString("base64url")}`;
		111	if (terminalId === DEFAULT_TERMINAL_ID) {
		112	return `${threadPart}.log`;
		113	}
		114	return `${threadPart}_${Buffer.from(terminalId, "utf8").toString("base64url")}.log`;
		115	}
		116
112	function historyLogPath(logsDir: string, threadId = "thread-1"): string {	117	function historyLogPath(logsDir: string, threadId = "thread-1"): string {
113	return path.join(logsDir, historyLogName(threadId));	118	return path.join(logsDir, historyLogName(threadId));
114	}	119	}
115		120
		121	function multiTerminalHistoryLogPath(
		122	logsDir: string,
		123	threadId = "thread-1",
		124	terminalId = "default",
		125	): string {
		126	return path.join(logsDir, multiTerminalHistoryLogName(threadId, terminalId));
		127	}
		128
116	describe("TerminalManager", () => {	129	describe("TerminalManager", () => {
117	const tempDirs: string[] = [];	130	const tempDirs: string[] = [];
118		131
...	@@ -144,6 +157,7 @@ describe("TerminalManager", () => {	...	@@ -144,6 +157,7 @@ describe("TerminalManager", () => {
144	const third = await manager.open(openInput());	157	const third = await manager.open(openInput());
145		158
146	expect(first.threadId).toBe("thread-1");	159	expect(first.threadId).toBe("thread-1");
		160	expect(first.terminalId).toBe("default");
147	expect(second.threadId).toBe("thread-1");	161	expect(second.threadId).toBe("thread-1");
148	expect(third.threadId).toBe("thread-1");	162	expect(third.threadId).toBe("thread-1");
149	expect(ptyAdapter.spawnInputs).toHaveLength(1);	163	expect(ptyAdapter.spawnInputs).toHaveLength(1);
...	@@ -167,6 +181,27 @@ describe("TerminalManager", () => {	...	@@ -167,6 +181,27 @@ describe("TerminalManager", () => {
167	manager.dispose();	181	manager.dispose();
168	});	182	});
169		183
		184	it("supports multiple terminals per thread with isolated sessions", async () => {
		185	const { manager, ptyAdapter } = makeManager();
		186	await manager.open(openInput({ terminalId: "default" }));
		187	await manager.open(openInput({ terminalId: "term-2" }));
		188
		189	const first = ptyAdapter.processes[0];
		190	const second = ptyAdapter.processes[1];
		191	expect(first).toBeDefined();
		192	expect(second).toBeDefined();
		193	if (!first \|\| !second) return;
		194
		195	await manager.write({ threadId: "thread-1", terminalId: "default", data: "pwd\n" });
		196	await manager.write({ threadId: "thread-1", terminalId: "term-2", data: "ls\n" });
		197
		198	expect(first.writes).toEqual(["pwd\n"]);
		199	expect(second.writes).toEqual(["ls\n"]);
		200	expect(ptyAdapter.spawnInputs).toHaveLength(2);
		201
		202	manager.dispose();
		203	});
		204
170	it("clears transcript and emits cleared event", async () => {	205	it("clears transcript and emits cleared event", async () => {
171	const { manager, ptyAdapter, logsDir } = makeManager();	206	const { manager, ptyAdapter, logsDir } = makeManager();
172	const events: TerminalEvent[] = [];	207	const events: TerminalEvent[] = [];
...	@@ -184,6 +219,14 @@ describe("TerminalManager", () => {	...	@@ -184,6 +219,14 @@ describe("TerminalManager", () => {
184	await waitFor(() => fs.readFileSync(historyLogPath(logsDir), "utf8") === "");	219	await waitFor(() => fs.readFileSync(historyLogPath(logsDir), "utf8") === "");
185		220
186	expect(events.some((event) => event.type === "cleared")).toBe(true);	221	expect(events.some((event) => event.type === "cleared")).toBe(true);
		222	expect(
		223	events.some(
		224	(event) =>
		225	event.type === "cleared" &&
		226	event.threadId === "thread-1" &&
		227	event.terminalId === "default",
		228	),
		229	).toBe(true);
187		230
188	manager.dispose();	231	manager.dispose();
189	});	232	});
...	@@ -262,6 +305,35 @@ describe("TerminalManager", () => {	...	@@ -262,6 +305,35 @@ describe("TerminalManager", () => {
262	manager.dispose();	305	manager.dispose();
263	});	306	});
264		307
		308	it("closes all terminals for a thread when close omits terminalId", async () => {
		309	const { manager, ptyAdapter, logsDir } = makeManager();
		310	await manager.open(openInput({ terminalId: "default" }));
		311	await manager.open(openInput({ terminalId: "sidecar" }));
		312	const defaultProcess = ptyAdapter.processes[0];
		313	const sidecarProcess = ptyAdapter.processes[1];
		314	expect(defaultProcess).toBeDefined();
		315	expect(sidecarProcess).toBeDefined();
		316	if (!defaultProcess \|\| !sidecarProcess) return;
		317
		318	defaultProcess.emitData("default\n");
		319	sidecarProcess.emitData("sidecar\n");
		320	await waitFor(() => fs.existsSync(multiTerminalHistoryLogPath(logsDir, "thread-1", "default")));
		321	await waitFor(() => fs.existsSync(multiTerminalHistoryLogPath(logsDir, "thread-1", "sidecar")));
		322
		323	await manager.close({ threadId: "thread-1", deleteHistory: true });
		324
		325	expect(defaultProcess.killed).toBe(true);
		326	expect(sidecarProcess.killed).toBe(true);
		327	expect(fs.existsSync(multiTerminalHistoryLogPath(logsDir, "thread-1", "default"))).toBe(
		328	false,
		329	);
		330	expect(fs.existsSync(multiTerminalHistoryLogPath(logsDir, "thread-1", "sidecar"))).toBe(
		331	false,
		332	);
		333
		334	manager.dispose();
		335	});
		336
265	it("loads existing legacy transcript filenames and keeps new naming for writes", async () => {	337	it("loads existing legacy transcript filenames and keeps new naming for writes", async () => {
266	const { manager, logsDir } = makeManager();	338	const { manager, logsDir } = makeManager();
267	const legacyPath = path.join(logsDir, "thread-1.log");	339	const legacyPath = path.join(logsDir, "thread-1.log");

apps/server/src/terminalManager.ts+184-70

 @@ -3,17 +3,19 @@ import fs from "node:fs";
 import path from "node:path";
 import {
+  DEFAULT_TERMINAL_ID,
+  type TerminalClearInput,
   type TerminalCloseInput,
   type TerminalEvent,
   type TerminalOpenInput,
+  type TerminalResizeInput,
   type TerminalSessionSnapshot,
   type TerminalSessionStatus,
-  type TerminalThreadInput,
   type TerminalWriteInput,
+  terminalClearInputSchema,
   terminalCloseInputSchema,
   terminalOpenInputSchema,
   terminalResizeInputSchema,
-  terminalThreadInputSchema,
   terminalWriteInputSchema,
 } from "@t3tools/contracts";
 @@ -36,6 +38,7 @@ export interface TerminalManagerOptions {
 interface TerminalSessionState {
   threadId: string;
+  terminalId: string;
   cwd: string;
   status: TerminalSessionStatus;
   pid: number | null;
 @@ -139,6 +142,14 @@ function toSafeThreadId(threadId: string): string {
   return `terminal_${Buffer.from(threadId, "utf8").toString("base64url")}`;
 }
+function toSafeTerminalId(terminalId: string): string {
+  return Buffer.from(terminalId, "utf8").toString("base64url");
+}
+function toSessionKey(threadId: string, terminalId: string): string {
+  return `${threadId}\u0000${terminalId}`;
+}
 export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
   private readonly sessions = new Map<string, TerminalSessionState>();
   private readonly logsDir: string;
 @@ -167,12 +178,14 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
     return this.runWithThreadLock(input.threadId, async () => {
       await this.assertValidCwd(input.cwd);
-      const existing = this.sessions.get(input.threadId);
+      const sessionKey = toSessionKey(input.threadId, input.terminalId);
+      const existing = this.sessions.get(sessionKey);
       if (!existing) {
-        await this.flushPersistQueue(input.threadId);
+        await this.flushPersistQueue(input.threadId, input.terminalId);
-        const history = await this.readHistory(input.threadId);
+        const history = await this.readHistory(input.threadId, input.terminalId);
         const session: TerminalSessionState = {
           threadId: input.threadId,
+          terminalId: input.terminalId,
           cwd: input.cwd,
           status: "starting",
           pid: null,
 @@ -186,7 +199,7 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
           unsubscribeData: null,
           unsubscribeExit: null,
         };
-        this.sessions.set(input.threadId, session);
+        this.sessions.set(sessionKey, session);
         this.startSession(session, input, "started");
         return this.snapshot(session);
       }
 @@ -195,10 +208,10 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
         this.stopProcess(existing);
         existing.cwd = input.cwd;
         existing.history = "";
-        await this.persistHistory(existing.threadId, existing.history);
+        await this.persistHistory(existing.threadId, existing.terminalId, existing.history);
       } else if (existing.status === "exited" || existing.status === "error") {
         existing.history = "";
-        await this.persistHistory(existing.threadId, existing.history);
+        await this.persistHistory(existing.threadId, existing.terminalId, existing.history);
       }
       if (!existing.process) {
 @@ -219,18 +232,22 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
   async write(raw: TerminalWriteInput): Promise<void> {
     const input = terminalWriteInputSchema.parse(raw);
-    const session = this.requireSession(input.threadId);
+    const session = this.requireSession(input.threadId, input.terminalId);
     if (!session.process || session.status !== "running") {
-      throw new Error(`Terminal is not running for thread: ${input.threadId}`);
+      throw new Error(
+        `Terminal is not running for thread: ${input.threadId}, terminal: ${input.terminalId}`,
+      );
     }
     session.process.write(input.data);
   }
-  async resize(raw: TerminalThreadInput & { cols: number; rows: number }): Promise<void> {
+  async resize(raw: TerminalResizeInput): Promise<void> {
     const input = terminalResizeInputSchema.parse(raw);
-    const session = this.requireSession(input.threadId);
+    const session = this.requireSession(input.threadId, input.terminalId);
     if (!session.process || session.status !== "running") {
-      throw new Error(`Terminal is not running for thread: ${input.threadId}`);
+      throw new Error(
+        `Terminal is not running for thread: ${input.threadId}, terminal: ${input.terminalId}`,
+      );
     }
     session.cols = input.cols;
     session.rows = input.rows;
 @@ -238,16 +255,17 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
     session.process.resize(input.cols, input.rows);
   }
-  async clear(raw: TerminalThreadInput): Promise<void> {
+  async clear(raw: TerminalClearInput): Promise<void> {
-    const input = terminalThreadInputSchema.parse(raw);
+    const input = terminalClearInputSchema.parse(raw);
     await this.runWithThreadLock(input.threadId, async () => {
-      const session = this.requireSession(input.threadId);
+      const session = this.requireSession(input.threadId, input.terminalId);
       session.history = "";
       session.updatedAt = new Date().toISOString();
-      await this.persistHistory(input.threadId, session.history);
+      await this.persistHistory(input.threadId, input.terminalId, session.history);
       this.emitEvent({
         type: "cleared",
         threadId: input.threadId,
+        terminalId: input.terminalId,
         createdAt: new Date().toISOString(),
       });
     });
 @@ -258,10 +276,12 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
     return this.runWithThreadLock(input.threadId, async () => {
       await this.assertValidCwd(input.cwd);
-      let session = this.sessions.get(input.threadId);
+      const sessionKey = toSessionKey(input.threadId, input.terminalId);
+      let session = this.sessions.get(sessionKey);
       if (!session) {
         session = {
           threadId: input.threadId,
+          terminalId: input.terminalId,
           cwd: input.cwd,
           status: "starting",
           pid: null,
 @@ -275,14 +295,14 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
           unsubscribeData: null,
           unsubscribeExit: null,
         };
-        this.sessions.set(input.threadId, session);
+        this.sessions.set(sessionKey, session);
       } else {
         this.stopProcess(session);
         session.cwd = input.cwd;
       }
       session.history = "";
-      await this.persistHistory(input.threadId, session.history);
+      await this.persistHistory(input.threadId, input.terminalId, session.history);
       this.startSession(session, input, "restarted");
       return this.snapshot(session);
     });
 @@ -291,14 +311,28 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
   async close(raw: TerminalCloseInput): Promise<void> {
     const input = terminalCloseInputSchema.parse(raw);
     await this.runWithThreadLock(input.threadId, async () => {
-      const session = this.sessions.get(input.threadId);
+      if (input.terminalId) {
-      if (session) {
+        await this.closeSession(
+          input.threadId,
+          input.terminalId,
+          input.deleteHistory === true,
+        );
+        return;
+      }
+      const threadSessions = this.sessionsForThread(input.threadId);
+      for (const session of threadSessions) {
         this.stopProcess(session);
-        this.sessions.delete(input.threadId);
+        this.sessions.delete(toSessionKey(session.threadId, session.terminalId));
       }
-      await this.flushPersistQueue(input.threadId);
+      await Promise.all(
+        threadSessions.map((session) =>
+          this.flushPersistQueue(session.threadId, session.terminalId),
+        ),
+      );
       if (input.deleteHistory) {
-        await this.deleteHistory(input.threadId);
+        await this.deleteAllHistoryForThread(input.threadId);
       }
     });
   }
 @@ -382,6 +416,7 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
       this.emitEvent({
         type: eventType,
         threadId: session.threadId,
+        terminalId: session.terminalId,
         createdAt: new Date().toISOString(),
         snapshot: this.snapshot(session),
       });
 @@ -401,11 +436,13 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
       this.emitEvent({
         type: "error",
         threadId: session.threadId,
+        terminalId: session.terminalId,
         createdAt: new Date().toISOString(),
         message,
       });
       this.logger.error("failed to start terminal", {
         threadId: session.threadId,
+        terminalId: session.terminalId,
         error: message,
         ...(startedShell ? { shell: startedShell } : {}),
       });
 @@ -415,10 +452,11 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
   private onProcessData(session: TerminalSessionState, data: string): void {
     session.history = capHistory(`${session.history}${data}`, this.historyLineLimit);
     session.updatedAt = new Date().toISOString();
-    this.queuePersist(session.threadId, session.history);
+    this.queuePersist(session.threadId, session.terminalId, session.history);
     this.emitEvent({
       type: "output",
       threadId: session.threadId,
+      terminalId: session.terminalId,
       createdAt: new Date().toISOString(),
       data,
     });
 @@ -435,6 +473,7 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
     this.emitEvent({
       type: "exited",
       threadId: session.threadId,
+      terminalId: session.terminalId,
       createdAt: new Date().toISOString(),
       exitCode: session.exitCode,
       exitSignal: session.exitSignal,
 @@ -455,6 +494,7 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
       const message = error instanceof Error ? error.message : String(error);
       this.logger.warn("failed to kill terminal process", {
         threadId: session.threadId,
+        terminalId: session.terminalId,
         error: message,
       });
     }
 @@ -467,69 +507,87 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
     session.unsubscribeExit = null;
   }
-  private queuePersist(threadId: string, history: string): void {
+  private queuePersist(threadId: string, terminalId: string, history: string): void {
-    this.pendingPersistHistory.set(threadId, history);
+    const persistenceKey = toSessionKey(threadId, terminalId);
-    this.schedulePersist(threadId);
+    this.pendingPersistHistory.set(persistenceKey, history);
+    this.schedulePersist(threadId, terminalId);
   }
-  private async persistHistory(threadId: string, history: string): Promise<void> {
+  private async persistHistory(
-    this.clearPersistTimer(threadId);
+    threadId: string,
-    this.pendingPersistHistory.delete(threadId);
+    terminalId: string,
-    await this.enqueuePersistWrite(threadId, history);
+    history: string,
+  ): Promise<void> {
+    const persistenceKey = toSessionKey(threadId, terminalId);
+    this.clearPersistTimer(threadId, terminalId);
+    this.pendingPersistHistory.delete(persistenceKey);
+    await this.enqueuePersistWrite(threadId, terminalId, history);
   }
-  private enqueuePersistWrite(threadId: string, history: string): Promise<void> {
+  private enqueuePersistWrite(
+    threadId: string,
+    terminalId: string,
+    history: string,
+  ): Promise<void> {
+    const persistenceKey = toSessionKey(threadId, terminalId);
     const task = async () => {
-      await fs.promises.writeFile(this.historyPath(threadId), history, "utf8");
+      await fs.promises.writeFile(this.historyPath(threadId, terminalId), history, "utf8");
     };
-    const previous = this.persistQueues.get(threadId) ?? Promise.resolve();
+    const previous = this.persistQueues.get(persistenceKey) ?? Promise.resolve();
     const next = previous
       .catch(() => undefined)
       .then(task)
       .catch((error) => {
         this.logger.warn("failed to persist terminal history", {
           threadId,
+          terminalId,
           error: error instanceof Error ? error.message : String(error),
         });
       });
-    this.persistQueues.set(threadId, next);
+    this.persistQueues.set(persistenceKey, next);
     const finalized = next.finally(() => {
-      if (this.persistQueues.get(threadId) === next) {
+      if (this.persistQueues.get(persistenceKey) === next) {
-        this.persistQueues.delete(threadId);
+        this.persistQueues.delete(persistenceKey);
       }
-      if (this.pendingPersistHistory.has(threadId) && !this.persistTimers.has(threadId)) {
+      if (
-        this.schedulePersist(threadId);
+        this.pendingPersistHistory.has(persistenceKey) &&
+        !this.persistTimers.has(persistenceKey)
+      ) {
+        this.schedulePersist(threadId, terminalId);
       }
     });
     void finalized.catch(() => undefined);
     return finalized;
   }
-  private schedulePersist(threadId: string): void {
+  private schedulePersist(threadId: string, terminalId: string): void {
-    if (this.persistTimers.has(threadId)) return;
+    const persistenceKey = toSessionKey(threadId, terminalId);
+    if (this.persistTimers.has(persistenceKey)) return;
     const timer = setTimeout(() => {
-      this.persistTimers.delete(threadId);
+      this.persistTimers.delete(persistenceKey);
-      const pendingHistory = this.pendingPersistHistory.get(threadId);
+      const pendingHistory = this.pendingPersistHistory.get(persistenceKey);
       if (pendingHistory === undefined) return;
-      this.pendingPersistHistory.delete(threadId);
+      this.pendingPersistHistory.delete(persistenceKey);
-      void this.enqueuePersistWrite(threadId, pendingHistory);
+      void this.enqueuePersistWrite(threadId, terminalId, pendingHistory);
     }, this.persistDebounceMs);
-    this.persistTimers.set(threadId, timer);
+    this.persistTimers.set(persistenceKey, timer);
   }
-  private clearPersistTimer(threadId: string): void {
+  private clearPersistTimer(threadId: string, terminalId: string): void {
-    const timer = this.persistTimers.get(threadId);
+    const persistenceKey = toSessionKey(threadId, terminalId);
+    const timer = this.persistTimers.get(persistenceKey);
     if (!timer) return;
     clearTimeout(timer);
-    this.persistTimers.delete(threadId);
+    this.persistTimers.delete(persistenceKey);
   }
-  private async readHistory(threadId: string): Promise<string> {
+  private async readHistory(threadId: string, terminalId: string): Promise<string> {
+    const historyPath = this.historyPath(threadId, terminalId);
     try {
-      const raw = await fs.promises.readFile(this.historyPath(threadId), "utf8");
+      const raw = await fs.promises.readFile(historyPath, "utf8");
       const capped = capHistory(raw, this.historyLineLimit);
       if (capped !== raw) {
-        await fs.promises.writeFile(this.historyPath(threadId), capped, "utf8");
+        await fs.promises.writeFile(historyPath, capped, "utf8");
       }
       return capped;
     } catch (error) {
 @@ -538,6 +596,10 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
       }
     }
+    if (terminalId !== DEFAULT_TERMINAL_ID) {
+      return "";
+    }
     try {
       const raw = await fs.promises.readFile(this.legacyHistoryPath(threadId), "utf8");
       const capped = capHistory(raw, this.historyLineLimit);
 @@ -553,31 +615,34 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
     }
   }
-  private async deleteHistory(threadId: string): Promise<void> {
+  private async deleteHistory(threadId: string, terminalId: string): Promise<void> {
+    const deletions = [fs.promises.rm(this.historyPath(threadId, terminalId), { force: true })];
+    if (terminalId === DEFAULT_TERMINAL_ID) {
+      deletions.push(fs.promises.rm(this.legacyHistoryPath(threadId), { force: true }));
+    }
     try {
-      await Promise.all([
+      await Promise.all(deletions);
-        fs.promises.rm(this.historyPath(threadId), { force: true }),
-        fs.promises.rm(this.legacyHistoryPath(threadId), { force: true }),
-      ]);
     } catch (error) {
       this.logger.warn("failed to delete terminal history", {
         threadId,
+        terminalId,
         error: error instanceof Error ? error.message : String(error),
       });
     }
   }
-  private async flushPersistQueue(threadId: string): Promise<void> {
+  private async flushPersistQueue(threadId: string, terminalId: string): Promise<void> {
-    this.clearPersistTimer(threadId);
+    const persistenceKey = toSessionKey(threadId, terminalId);
+    this.clearPersistTimer(threadId, terminalId);
     while (true) {
-      const pendingHistory = this.pendingPersistHistory.get(threadId);
+      const pendingHistory = this.pendingPersistHistory.get(persistenceKey);
       if (pendingHistory !== undefined) {
-        this.pendingPersistHistory.delete(threadId);
+        this.pendingPersistHistory.delete(persistenceKey);
-        await this.enqueuePersistWrite(threadId, pendingHistory);
+        await this.enqueuePersistWrite(threadId, terminalId, pendingHistory);
       }
-      const pending = this.persistQueues.get(threadId);
+      const pending = this.persistQueues.get(persistenceKey);
       if (!pending) {
         return;
       }
 @@ -600,10 +665,54 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
     }
   }
-  private requireSession(threadId: string): TerminalSessionState {
+  private async closeSession(
-    const session = this.sessions.get(threadId);
+    threadId: string,
+    terminalId: string,
+    deleteHistory: boolean,
+  ): Promise<void> {
+    const key = toSessionKey(threadId, terminalId);
+    const session = this.sessions.get(key);
+    if (session) {
+      this.stopProcess(session);
+      this.sessions.delete(key);
+    }
+    await this.flushPersistQueue(threadId, terminalId);
+    if (deleteHistory) {
+      await this.deleteHistory(threadId, terminalId);
+    }
+  }
+  private sessionsForThread(threadId: string): TerminalSessionState[] {
+    return [...this.sessions.values()].filter((session) => session.threadId === threadId);
+  }
+  private async deleteAllHistoryForThread(threadId: string): Promise<void> {
+    const threadPrefix = `${toSafeThreadId(threadId)}_`;
+    try {
+      const entries = await fs.promises.readdir(this.logsDir, { withFileTypes: true });
+      const removals = entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .filter(
+          (name) =>
+            name === `${toSafeThreadId(threadId)}.log` ||
+            name === `${legacySafeThreadId(threadId)}.log` ||
+            name.startsWith(threadPrefix),
+        )
+        .map((name) => fs.promises.rm(path.join(this.logsDir, name), { force: true }));
+      await Promise.all(removals);
+    } catch (error) {
+      this.logger.warn("failed to delete terminal histories for thread", {
+        threadId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  private requireSession(threadId: string, terminalId: string): TerminalSessionState {
+    const session = this.sessions.get(toSessionKey(threadId, terminalId));
     if (!session) {
-      throw new Error(`Unknown terminal thread: ${threadId}`);
+      throw new Error(`Unknown terminal thread: ${threadId}, terminal: ${terminalId}`);
     }
     return session;
   }
 @@ -611,6 +720,7 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
   private snapshot(session: TerminalSessionState): TerminalSessionSnapshot {
     return {
       threadId: session.threadId,
+      terminalId: session.terminalId,
       cwd: session.cwd,
       status: session.status,
       pid: session.pid,
 @@ -625,8 +735,12 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
     this.emit("event", event);
   }
-  private historyPath(threadId: string): string {
+  private historyPath(threadId: string, terminalId: string): string {
-    return path.join(this.logsDir, `${toSafeThreadId(threadId)}.log`);
+    const threadPart = toSafeThreadId(threadId);
+    if (terminalId === DEFAULT_TERMINAL_ID) {
+      return path.join(this.logsDir, `${threadPart}.log`);
+    }
+    return path.join(this.logsDir, `${threadPart}_${toSafeTerminalId(terminalId)}.log`);
   }
   private legacyHistoryPath(threadId: string): string {

apps/server/src/wsServer.test.ts+39-8

 @@ -7,14 +7,21 @@ import { describe, expect, it, afterEach, vi } from "vitest";
 import { createServer } from "./wsServer";
 import WebSocket from "ws";
-import { WS_CHANNELS, WS_METHODS, type WsPush, type WsResponse } from "@t3tools/contracts";
+import {
+  DEFAULT_TERMINAL_ID,
+  WS_CHANNELS,
+  WS_METHODS,
+  type WsPush,
+  type WsResponse,
+} from "@t3tools/contracts";
 import { ProjectRegistry } from "./projectRegistry";
 import type {
+  TerminalClearInput,
   TerminalCloseInput,
   TerminalEvent,
   TerminalOpenInput,
+  TerminalResizeInput,
   TerminalSessionSnapshot,
-  TerminalThreadInput,
   TerminalWriteInput,
 } from "@t3tools/contracts";
 import type { TerminalManager } from "./terminalManager";
 @@ -29,10 +36,16 @@ const pendingBySocket = new WeakMap<WebSocket, PendingMessages>();
 class MockTerminalManager extends EventEmitter<{ event: [event: TerminalEvent] }> {
   private readonly sessions = new Map<string, TerminalSessionSnapshot>();
+  private key(threadId: string, terminalId: string): string {
+    return `${threadId}\u0000${terminalId}`;
+  }
   async open(input: TerminalOpenInput): Promise<TerminalSessionSnapshot> {
     const now = new Date().toISOString();
+    const terminalId = input.terminalId ?? DEFAULT_TERMINAL_ID;
     const snapshot: TerminalSessionSnapshot = {
       threadId: input.threadId,
+      terminalId,
       cwd: input.cwd,
       status: "running",
       pid: 4242,
 @@ -41,11 +54,12 @@ class MockTerminalManager extends EventEmitter<{ event: [event: TerminalEvent] }
       exitSignal: null,
       updatedAt: now,
     };
-    this.sessions.set(input.threadId, snapshot);
+    this.sessions.set(this.key(input.threadId, terminalId), snapshot);
     queueMicrotask(() => {
       this.emit("event", {
         type: "started",
         threadId: input.threadId,
+        terminalId,
         createdAt: now,
         snapshot,
       });
 @@ -54,7 +68,8 @@ class MockTerminalManager extends EventEmitter<{ event: [event: TerminalEvent] }
   }
   async write(input: TerminalWriteInput): Promise<void> {
-    const existing = this.sessions.get(input.threadId);
+    const terminalId = input.terminalId ?? DEFAULT_TERMINAL_ID;
+    const existing = this.sessions.get(this.key(input.threadId, terminalId));
     if (!existing) {
       throw new Error(`Unknown terminal thread: ${input.threadId}`);
     }
 @@ -62,19 +77,22 @@ class MockTerminalManager extends EventEmitter<{ event: [event: TerminalEvent] }
       this.emit("event", {
         type: "output",
         threadId: input.threadId,
+        terminalId,
         createdAt: new Date().toISOString(),
         data: input.data,
       });
     });
   }
-  async resize(_input: TerminalThreadInput & { cols: number; rows: number }): Promise<void> {}
+  async resize(_input: TerminalResizeInput): Promise<void> {}
-  async clear(input: TerminalThreadInput): Promise<void> {
+  async clear(input: TerminalClearInput): Promise<void> {
+    const terminalId = input.terminalId ?? DEFAULT_TERMINAL_ID;
     queueMicrotask(() => {
       this.emit("event", {
         type: "cleared",
         threadId: input.threadId,
+        terminalId,
         createdAt: new Date().toISOString(),
       });
     });
 @@ -82,8 +100,10 @@ class MockTerminalManager extends EventEmitter<{ event: [event: TerminalEvent] }
   async restart(input: TerminalOpenInput): Promise<TerminalSessionSnapshot> {
     const now = new Date().toISOString();
+    const terminalId = input.terminalId ?? DEFAULT_TERMINAL_ID;
     const snapshot: TerminalSessionSnapshot = {
       threadId: input.threadId,
+      terminalId,
       cwd: input.cwd,
       status: "running",
       pid: 5252,
 @@ -92,11 +112,12 @@ class MockTerminalManager extends EventEmitter<{ event: [event: TerminalEvent] }
       exitSignal: null,
       updatedAt: now,
     };
-    this.sessions.set(input.threadId, snapshot);
+    this.sessions.set(this.key(input.threadId, terminalId), snapshot);
     queueMicrotask(() => {
       this.emit("event", {
         type: "restarted",
         threadId: input.threadId,
+        terminalId,
         createdAt: now,
         snapshot,
       });
 @@ -105,7 +126,15 @@ class MockTerminalManager extends EventEmitter<{ event: [event: TerminalEvent] }
   }
   async close(input: TerminalCloseInput): Promise<void> {
-    this.sessions.delete(input.threadId);
+    if (input.terminalId) {
+      this.sessions.delete(this.key(input.threadId, input.terminalId));
+      return;
+    }
+    for (const key of [...this.sessions.keys()]) {
+      if (key.startsWith(`${input.threadId}\u0000`)) {
+        this.sessions.delete(key);
+      }
+    }
   }
   dispose(): void {}
 @@ -340,6 +369,7 @@ describe("WebSocket Server", () => {
     });
     expect(open.error).toBeUndefined();
     expect((open.result as TerminalSessionSnapshot).threadId).toBe("thread-1");
+    expect((open.result as TerminalSessionSnapshot).terminalId).toBe(DEFAULT_TERMINAL_ID);
     const write = await sendRequest(ws, WS_METHODS.terminalWrite, {
       threadId: "thread-1",
 @@ -376,6 +406,7 @@ describe("WebSocket Server", () => {
     const manualEvent: TerminalEvent = {
       type: "output",
       threadId: "thread-1",
+      terminalId: DEFAULT_TERMINAL_ID,
       createdAt: new Date().toISOString(),
       data: "manual test output\n",
     };

apps/web/src/App.tsx+5-13

 @@ -7,7 +7,7 @@ import Sidebar from "./components/Sidebar";
 import { isElectron } from "./env";
 import { DEFAULT_MODEL } from "./model-logic";
 import { StoreProvider, useStore } from "./store";
-import { DEFAULT_THREAD_TERMINAL_HEIGHT } from "./types";
+import { DEFAULT_THREAD_TERMINAL_HEIGHT, DEFAULT_THREAD_TERMINAL_ID } from "./types";
 import { onServerWelcome } from "./wsNativeApi";
 import { useNativeApi } from "./hooks/useNativeApi";
 @@ -27,18 +27,6 @@ function EventRouter() {
     });
   }, [api, dispatch]);
-  useEffect(() => {
-    if (!api) return;
-    return api.terminal.onEvent((event) => {
-      if (event.type !== "exited") return;
-      dispatch({
-        type: "SET_THREAD_TERMINAL_OPEN",
-        threadId: event.threadId,
-        open: false,
-      });
-    });
-  }, [api, dispatch]);
   return null;
 }
 @@ -93,6 +81,10 @@ function AutoProjectBootstrap() {
           model: DEFAULT_MODEL,
           terminalOpen: false,
           terminalHeight: DEFAULT_THREAD_TERMINAL_HEIGHT,
+          terminalIds: [DEFAULT_THREAD_TERMINAL_ID],
+          activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,
+          terminalLayout: "single",
+          splitTerminalIds: [],
           session: null,
           messages: [],
           events: [],

apps/web/src/components/ChatView.tsx+37-7

...	@@ -269,6 +269,36 @@ export default function ChatView() {	...	@@ -269,6 +269,36 @@ export default function ChatView() {
269	open: !isOpen,	269	open: !isOpen,
270	});	270	});
271	}, [activeThread?.terminalOpen, activeThreadId, dispatch]);	271	}, [activeThread?.terminalOpen, activeThreadId, dispatch]);
		272	const splitTerminal = useCallback(() => {
		273	if (!activeThreadId) return;
		274	dispatch({
		275	type: "SPLIT_THREAD_TERMINAL",
		276	threadId: activeThreadId,
		277	terminalId: `terminal-${crypto.randomUUID()}`,
		278	});
		279	setTerminalFocusRequestId((value) => value + 1);
		280	}, [activeThreadId, dispatch]);
		281	const createNewTerminal = useCallback(() => {
		282	if (!activeThreadId) return;
		283	dispatch({
		284	type: "NEW_THREAD_TERMINAL",
		285	threadId: activeThreadId,
		286	terminalId: `terminal-${crypto.randomUUID()}`,
		287	});
		288	setTerminalFocusRequestId((value) => value + 1);
		289	}, [activeThreadId, dispatch]);
		290	const activateTerminal = useCallback(
		291	(terminalId: string) => {
		292	if (!activeThreadId) return;
		293	dispatch({
		294	type: "SET_THREAD_ACTIVE_TERMINAL",
		295	threadId: activeThreadId,
		296	terminalId,
		297	});
		298	setTerminalFocusRequestId((value) => value + 1);
		299	},
		300	[activeThreadId, dispatch],
		301	);
272		302
273	const handleRuntimeModeChange = async (mode: "approval-required" \| "full-access") => {	303	const handleRuntimeModeChange = async (mode: "approval-required" \| "full-access") => {
274	if (mode === state.runtimeMode) return;	304	if (mode === state.runtimeMode) return;
...	@@ -1451,7 +1481,14 @@ export default function ChatView() {	...	@@ -1451,7 +1481,14 @@ export default function ChatView() {
1451	threadId={activeThread.id}	1481	threadId={activeThread.id}
1452	cwd={activeProject.cwd}	1482	cwd={activeProject.cwd}
1453	height={activeThread.terminalHeight}	1483	height={activeThread.terminalHeight}
		1484	terminalIds={activeThread.terminalIds}
		1485	activeTerminalId={activeThread.activeTerminalId}
		1486	terminalLayout={activeThread.terminalLayout}
		1487	splitTerminalIds={activeThread.splitTerminalIds}
1454	focusRequestId={terminalFocusRequestId}	1488	focusRequestId={terminalFocusRequestId}
		1489	onSplitTerminal={splitTerminal}
		1490	onNewTerminal={createNewTerminal}
		1491	onActiveTerminalChange={activateTerminal}
1455	onHeightChange={(height) =>	1492	onHeightChange={(height) =>
1456	dispatch({	1493	dispatch({
1457	type: "SET_THREAD_TERMINAL_HEIGHT",	1494	type: "SET_THREAD_TERMINAL_HEIGHT",
...	@@ -1459,13 +1496,6 @@ export default function ChatView() {	...	@@ -1459,13 +1496,6 @@ export default function ChatView() {
1459	height,	1496	height,
1460	})	1497	})
1461	}	1498	}
1462	onThreadExited={() =>
1463	dispatch({
1464	type: "SET_THREAD_TERMINAL_OPEN",
1465	threadId: activeThread.id,
1466	open: false,
1467	})
1468	}
1469	/>	1499	/>
1470	)}	1500	)}
1471		1501

apps/web/src/components/Sidebar.tsx+10-1

 @@ -5,7 +5,12 @@ import { useTheme } from "../hooks/useTheme";
 import { DEFAULT_MODEL } from "../model-logic";
 import { derivePendingApprovals } from "../session-logic";
 import { useStore } from "../store";
-import { DEFAULT_THREAD_TERMINAL_HEIGHT, type Project, type Thread } from "../types";
+import {
+  DEFAULT_THREAD_TERMINAL_HEIGHT,
+  DEFAULT_THREAD_TERMINAL_ID,
+  type Project,
+  type Thread,
+} from "../types";
 import { useNativeApi } from "../hooks/useNativeApi";
 const THEME_CYCLE = { system: "light", light: "dark", dark: "system" } as const;
 @@ -112,6 +117,10 @@ export default function Sidebar() {
           model: state.projects.find((p) => p.id === projectId)?.model ?? DEFAULT_MODEL,
           terminalOpen: false,
           terminalHeight: DEFAULT_THREAD_TERMINAL_HEIGHT,
+          terminalIds: [DEFAULT_THREAD_TERMINAL_ID],
+          activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,
+          terminalLayout: "single",
+          splitTerminalIds: [],
           session: null,
           messages: [],
           events: [],

apps/web/src/components/ThreadTerminalDrawer.tsx+303-159

...	@@ -5,6 +5,7 @@ import {	...	@@ -5,6 +5,7 @@ import {
5	type PointerEvent as ReactPointerEvent,	5	type PointerEvent as ReactPointerEvent,
6	useCallback,	6	useCallback,
7	useEffect,	7	useEffect,
		8	useMemo,
8	useRef,	9	useRef,
9	useState,	10	useState,
10	} from "react";	11	} from "react";
...	@@ -15,7 +16,11 @@ import {	...	@@ -15,7 +16,11 @@ import {
15	resolvePathLinkTarget,	16	resolvePathLinkTarget,
16	} from "../terminal-links";	17	} from "../terminal-links";
17	import { isTerminalClearShortcut } from "../terminal-shortcuts";	18	import { isTerminalClearShortcut } from "../terminal-shortcuts";
18	import { DEFAULT_THREAD_TERMINAL_HEIGHT } from "../types";	19	import {
		20	DEFAULT_THREAD_TERMINAL_HEIGHT,
		21	DEFAULT_THREAD_TERMINAL_ID,
		22	type ThreadTerminalLayout,
		23	} from "../types";
19		24
20	const MIN_DRAWER_HEIGHT = 180;	25	const MIN_DRAWER_HEIGHT = 180;
21	const MAX_DRAWER_HEIGHT_RATIO = 0.75;	26	const MAX_DRAWER_HEIGHT_RATIO = 0.75;
...	@@ -103,162 +108,30 @@ function terminalThemeFromApp(): ITheme {	...	@@ -103,162 +108,30 @@ function terminalThemeFromApp(): ITheme {
103	};	108	};
104	}	109	}
105		110
106	interface ThreadTerminalDrawerProps {	111	interface TerminalViewportProps {
107	api: NativeApi;	112	api: NativeApi;
108	threadId: string;	113	threadId: string;
		114	terminalId: string;
109	cwd: string;	115	cwd: string;
110	height: number;
111	focusRequestId: number;	116	focusRequestId: number;
112	onHeightChange: (height: number) => void;	117	autoFocus: boolean;
113	onThreadExited: () => void;	118	resizeEpoch: number;
		119	drawerHeight: number;
114	}	120	}
115		121
116	export default function ThreadTerminalDrawer({	122	function TerminalViewport({
117	api,	123	api,
118	threadId,	124	threadId,
		125	terminalId,
119	cwd,	126	cwd,
120	height,
121	focusRequestId,	127	focusRequestId,
122	onHeightChange,	128	autoFocus,
123	onThreadExited,	129	resizeEpoch,
124	}: ThreadTerminalDrawerProps) {	130	drawerHeight,
125	const [drawerHeight, setDrawerHeight] = useState(() => clampDrawerHeight(height));	131	}: TerminalViewportProps) {
126	const containerRef = useRef<HTMLDivElement>(null);	132	const containerRef = useRef<HTMLDivElement>(null);
127	const terminalRef = useRef<Terminal \| null>(null);	133	const terminalRef = useRef<Terminal \| null>(null);
128	const fitAddonRef = useRef<FitAddon \| null>(null);	134	const fitAddonRef = useRef<FitAddon \| null>(null);
129	const drawerHeightRef = useRef(drawerHeight);
130	const lastSyncedHeightRef = useRef(clampDrawerHeight(height));
131	const onHeightChangeRef = useRef(onHeightChange);
132	const onThreadExitedRef = useRef(onThreadExited);
133	const resizeStateRef = useRef<{
134	pointerId: number;
135	startY: number;
136	startHeight: number;
137	} \| null>(null);
138	const didResizeDuringDragRef = useRef(false);
139
140	useEffect(() => {
141	onHeightChangeRef.current = onHeightChange;
142	}, [onHeightChange]);
143
144	useEffect(() => {
145	onThreadExitedRef.current = onThreadExited;
146	}, [onThreadExited]);
147
148	useEffect(() => {
149	drawerHeightRef.current = drawerHeight;
150	}, [drawerHeight]);
151
152	const syncHeight = useCallback(
153	(nextHeight: number) => {
154	const clampedHeight = clampDrawerHeight(nextHeight);
155	if (lastSyncedHeightRef.current === clampedHeight) return;
156	lastSyncedHeightRef.current = clampedHeight;
157	onHeightChangeRef.current(clampedHeight);
158	},
159	[],
160	);
161
162	const fitAndResizeTerminal = useCallback((preserveBottom = false) => {
163	const activeTerminal = terminalRef.current;
164	const activeFitAddon = fitAddonRef.current;
165	if (!activeTerminal \|\| !activeFitAddon) return;
166	const wasAtBottom =
167	preserveBottom &&
168	activeTerminal.buffer.active.viewportY >= activeTerminal.buffer.active.baseY;
169	activeFitAddon.fit();
170	if (wasAtBottom) {
171	activeTerminal.scrollToBottom();
172	}
173	void api.terminal
174	.resize({
175	threadId,
176	cols: activeTerminal.cols,
177	rows: activeTerminal.rows,
178	})
179	.catch(() => undefined);
180	}, [api, threadId]);
181
182	useEffect(() => {
183	const clampedHeight = clampDrawerHeight(height);
184	setDrawerHeight(clampedHeight);
185	lastSyncedHeightRef.current = clampedHeight;
186	}, [height, threadId]);
187
188	const handleResizePointerDown = useCallback(
189	(event: ReactPointerEvent<HTMLDivElement>) => {
190	if (event.button !== 0) return;
191	event.preventDefault();
192	event.currentTarget.setPointerCapture(event.pointerId);
193	didResizeDuringDragRef.current = false;
194	resizeStateRef.current = {
195	pointerId: event.pointerId,
196	startY: event.clientY,
197	startHeight: drawerHeightRef.current,
198	};
199	},
200	[],
201	);
202
203	const handleResizePointerMove = useCallback(
204	(event: ReactPointerEvent<HTMLDivElement>) => {
205	const resizeState = resizeStateRef.current;
206	if (!resizeState \|\| resizeState.pointerId !== event.pointerId) return;
207	event.preventDefault();
208	const clampedHeight = clampDrawerHeight(
209	resizeState.startHeight + (resizeState.startY - event.clientY),
210	);
211	if (clampedHeight === drawerHeightRef.current) {
212	return;
213	}
214	didResizeDuringDragRef.current = true;
215	drawerHeightRef.current = clampedHeight;
216	setDrawerHeight(clampedHeight);
217	},
218	[],
219	);
220
221	const handleResizePointerEnd = useCallback(
222	(event: ReactPointerEvent<HTMLDivElement>) => {
223	const resizeState = resizeStateRef.current;
224	if (!resizeState \|\| resizeState.pointerId !== event.pointerId) return;
225	resizeStateRef.current = null;
226	if (event.currentTarget.hasPointerCapture(event.pointerId)) {
227	event.currentTarget.releasePointerCapture(event.pointerId);
228	}
229	if (!didResizeDuringDragRef.current) {
230	return;
231	}
232	syncHeight(drawerHeightRef.current);
233	fitAndResizeTerminal(true);
234	},
235	[fitAndResizeTerminal, syncHeight],
236	);
237
238	useEffect(() => {
239	const onWindowResize = () => {
240	const clampedHeight = clampDrawerHeight(drawerHeightRef.current);
241	const changed = clampedHeight !== drawerHeightRef.current;
242	if (changed) {
243	setDrawerHeight(clampedHeight);
244	} else {
245	fitAndResizeTerminal(true);
246	}
247	if (!resizeStateRef.current) {
248	syncHeight(clampedHeight);
249	}
250	};
251	window.addEventListener("resize", onWindowResize);
252	return () => {
253	window.removeEventListener("resize", onWindowResize);
254	};
255	}, [fitAndResizeTerminal, syncHeight]);
256
257	useEffect(() => {
258	return () => {
259	syncHeight(drawerHeightRef.current);
260	};
261	}, [syncHeight]);
262		135
263	useEffect(() => {	136	useEffect(() => {
264	const mount = containerRef.current;	137	const mount = containerRef.current;
...	@@ -287,7 +160,7 @@ export default function ThreadTerminalDrawer({	...	@@ -287,7 +160,7 @@ export default function ThreadTerminalDrawer({
287	const activeTerminal = terminalRef.current;	160	const activeTerminal = terminalRef.current;
288	if (!activeTerminal) return;	161	if (!activeTerminal) return;
289	try {	162	try {
290	await api.terminal.write({ threadId, data: "\u000c" });	163	await api.terminal.write({ threadId, terminalId, data: "\u000c" });
291	} catch (error) {	164	} catch (error) {
292	writeSystemMessage(	165	writeSystemMessage(
293	activeTerminal,	166	activeTerminal,
...	@@ -367,7 +240,7 @@ export default function ThreadTerminalDrawer({	...	@@ -367,7 +240,7 @@ export default function ThreadTerminalDrawer({
367		240
368	const inputDisposable = terminal.onData((data) => {	241	const inputDisposable = terminal.onData((data) => {
369	void api.terminal	242	void api.terminal
370	.write({ threadId, data })	243	.write({ threadId, terminalId, data })
371	.catch((err) =>	244	.catch((err) =>
372	writeSystemMessage(	245	writeSystemMessage(
373	terminal,	246	terminal,
...	@@ -395,6 +268,7 @@ export default function ThreadTerminalDrawer({	...	@@ -395,6 +268,7 @@ export default function ThreadTerminalDrawer({
395	activeFitAddon.fit();	268	activeFitAddon.fit();
396	const snapshot = await api.terminal.open({	269	const snapshot = await api.terminal.open({
397	threadId,	270	threadId,
		271	terminalId,
398	cwd,	272	cwd,
399	cols: activeTerminal.cols,	273	cols: activeTerminal.cols,
400	rows: activeTerminal.rows,	274	rows: activeTerminal.rows,
...	@@ -404,9 +278,11 @@ export default function ThreadTerminalDrawer({	...	@@ -404,9 +278,11 @@ export default function ThreadTerminalDrawer({
404	if (snapshot.history.length > 0) {	278	if (snapshot.history.length > 0) {
405	activeTerminal.write(snapshot.history);	279	activeTerminal.write(snapshot.history);
406	}	280	}
407	window.requestAnimationFrame(() => {	281	if (autoFocus) {
408	activeTerminal.focus();	282	window.requestAnimationFrame(() => {
409	});	283	activeTerminal.focus();
		284	});
		285	}
410	} catch (err) {	286	} catch (err) {
411	if (disposed) return;	287	if (disposed) return;
412	writeSystemMessage(	288	writeSystemMessage(
...	@@ -417,7 +293,7 @@ export default function ThreadTerminalDrawer({	...	@@ -417,7 +293,7 @@ export default function ThreadTerminalDrawer({
417	};	293	};
418		294
419	const unsubscribe = api.terminal.onEvent((event) => {	295	const unsubscribe = api.terminal.onEvent((event) => {
420	if (event.threadId !== threadId) return;	296	if (event.threadId !== threadId \|\| event.terminalId !== terminalId) return;
421	const activeTerminal = terminalRef.current;	297	const activeTerminal = terminalRef.current;
422	if (!activeTerminal) return;	298	if (!activeTerminal) return;
423		299
...	@@ -446,12 +322,37 @@ export default function ThreadTerminalDrawer({	...	@@ -446,12 +322,37 @@ export default function ThreadTerminalDrawer({
446	}	322	}
447		323
448	if (event.type === "exited") {	324	if (event.type === "exited") {
449	onThreadExitedRef.current();	325	const details = [
		326	typeof event.exitCode === "number" ? `code ${event.exitCode}` : null,
		327	typeof event.exitSignal === "number" ? `signal ${event.exitSignal}` : null,
		328	]
		329	.filter((value): value is string => value !== null)
		330	.join(", ");
		331	writeSystemMessage(
		332	activeTerminal,
		333	details.length > 0 ? `Process exited (${details})` : "Process exited",
		334	);
450	}	335	}
451	});	336	});
452		337
453	const fitTimer = window.setTimeout(() => {	338	const fitTimer = window.setTimeout(() => {
454	fitAndResizeTerminal(true);	339	const activeTerminal = terminalRef.current;
		340	const activeFitAddon = fitAddonRef.current;
		341	if (!activeTerminal \|\| !activeFitAddon) return;
		342	const wasAtBottom =
		343	activeTerminal.buffer.active.viewportY >= activeTerminal.buffer.active.baseY;
		344	activeFitAddon.fit();
		345	if (wasAtBottom) {
		346	activeTerminal.scrollToBottom();
		347	}
		348	void api.terminal
		349	.resize({
		350	threadId,
		351	terminalId,
		352	cols: activeTerminal.cols,
		353	rows: activeTerminal.rows,
		354	})
		355	.catch(() => undefined);
455	}, 30);	356	}, 30);
456	void openTerminal();	357	void openTerminal();
457		358
...	@@ -466,9 +367,10 @@ export default function ThreadTerminalDrawer({	...	@@ -466,9 +367,10 @@ export default function ThreadTerminalDrawer({
466	fitAddonRef.current = null;	367	fitAddonRef.current = null;
467	terminal.dispose();	368	terminal.dispose();
468	};	369	};
469	}, [api, cwd, fitAndResizeTerminal, threadId]);	370	}, [api, autoFocus, cwd, terminalId, threadId]);
470		371
471	useEffect(() => {	372	useEffect(() => {
		373	if (!autoFocus) return;
472	const terminal = terminalRef.current;	374	const terminal = terminalRef.current;
473	if (!terminal) return;	375	if (!terminal) return;
474	const frame = window.requestAnimationFrame(() => {	376	const frame = window.requestAnimationFrame(() => {
...	@@ -477,7 +379,7 @@ export default function ThreadTerminalDrawer({	...	@@ -477,7 +379,7 @@ export default function ThreadTerminalDrawer({
477	return () => {	379	return () => {
478	window.cancelAnimationFrame(frame);	380	window.cancelAnimationFrame(frame);
479	};	381	};
480	}, [focusRequestId]);	382	}, [autoFocus, focusRequestId]);
481		383
482	useEffect(() => {	384	useEffect(() => {
483	const terminal = terminalRef.current;	385	const terminal = terminalRef.current;
...	@@ -492,6 +394,7 @@ export default function ThreadTerminalDrawer({	...	@@ -492,6 +394,7 @@ export default function ThreadTerminalDrawer({
492	void api.terminal	394	void api.terminal
493	.resize({	395	.resize({
494	threadId,	396	threadId,
		397	terminalId,
495	cols: terminal.cols,	398	cols: terminal.cols,
496	rows: terminal.rows,	399	rows: terminal.rows,
497	})	400	})
...	@@ -500,7 +403,176 @@ export default function ThreadTerminalDrawer({	...	@@ -500,7 +403,176 @@ export default function ThreadTerminalDrawer({
500	return () => {	403	return () => {
501	window.cancelAnimationFrame(frame);	404	window.cancelAnimationFrame(frame);
502	};	405	};
503	}, [api, cwd, drawerHeight, threadId]);	406	}, [api, drawerHeight, resizeEpoch, terminalId, threadId]);
		407
		408	return <div ref={containerRef} className="h-full w-full overflow-hidden rounded-[4px]" />;
		409	}
		410
		411	interface ThreadTerminalDrawerProps {
		412	api: NativeApi;
		413	threadId: string;
		414	cwd: string;
		415	height: number;
		416	terminalIds: string[];
		417	activeTerminalId: string;
		418	terminalLayout: ThreadTerminalLayout;
		419	splitTerminalIds: string[];
		420	focusRequestId: number;
		421	onSplitTerminal: () => void;
		422	onNewTerminal: () => void;
		423	onActiveTerminalChange: (terminalId: string) => void;
		424	onHeightChange: (height: number) => void;
		425	}
		426
		427	export default function ThreadTerminalDrawer({
		428	api,
		429	threadId,
		430	cwd,
		431	height,
		432	terminalIds,
		433	activeTerminalId,
		434	terminalLayout,
		435	splitTerminalIds,
		436	focusRequestId,
		437	onSplitTerminal,
		438	onNewTerminal,
		439	onActiveTerminalChange,
		440	onHeightChange,
		441	}: ThreadTerminalDrawerProps) {
		442	const [drawerHeight, setDrawerHeight] = useState(() => clampDrawerHeight(height));
		443	const [resizeEpoch, setResizeEpoch] = useState(0);
		444	const drawerHeightRef = useRef(drawerHeight);
		445	const lastSyncedHeightRef = useRef(clampDrawerHeight(height));
		446	const onHeightChangeRef = useRef(onHeightChange);
		447	const resizeStateRef = useRef<{
		448	pointerId: number;
		449	startY: number;
		450	startHeight: number;
		451	} \| null>(null);
		452	const didResizeDuringDragRef = useRef(false);
		453
		454	const normalizedTerminalIds = useMemo(() => {
		455	const cleaned = [...new Set(terminalIds.map((id) => id.trim()).filter((id) => id.length > 0))];
		456	return cleaned.length > 0 ? cleaned : [DEFAULT_THREAD_TERMINAL_ID];
		457	}, [terminalIds]);
		458
		459	const resolvedActiveTerminalId = normalizedTerminalIds.includes(activeTerminalId)
		460	? activeTerminalId
		461	: (normalizedTerminalIds[0] ?? DEFAULT_THREAD_TERMINAL_ID);
		462
		463	const resolvedSplitTerminalIds = useMemo(() => {
		464	if (terminalLayout !== "split") return [];
		465	const validSplitIds = [...new Set(splitTerminalIds)].filter((id) =>
		466	normalizedTerminalIds.includes(id),
		467	);
		468	if (validSplitIds.length >= 2) {
		469	return validSplitIds.slice(0, 2);
		470	}
		471
		472	const fallbackPartner = normalizedTerminalIds.find((id) => id !== resolvedActiveTerminalId);
		473	if (!fallbackPartner) {
		474	return [];
		475	}
		476	return [resolvedActiveTerminalId, fallbackPartner];
		477	}, [normalizedTerminalIds, resolvedActiveTerminalId, splitTerminalIds, terminalLayout]);
		478
		479	const visibleTerminalIds =
		480	terminalLayout === "split" && resolvedSplitTerminalIds.length === 2
		481	? resolvedSplitTerminalIds
		482	: [resolvedActiveTerminalId];
		483
		484	const showTabBar = terminalLayout === "tabs" && normalizedTerminalIds.length > 1;
		485
		486	useEffect(() => {
		487	onHeightChangeRef.current = onHeightChange;
		488	}, [onHeightChange]);
		489
		490	useEffect(() => {
		491	drawerHeightRef.current = drawerHeight;
		492	}, [drawerHeight]);
		493
		494	const syncHeight = useCallback((nextHeight: number) => {
		495	const clampedHeight = clampDrawerHeight(nextHeight);
		496	if (lastSyncedHeightRef.current === clampedHeight) return;
		497	lastSyncedHeightRef.current = clampedHeight;
		498	onHeightChangeRef.current(clampedHeight);
		499	}, []);
		500
		501	useEffect(() => {
		502	const clampedHeight = clampDrawerHeight(height);
		503	setDrawerHeight(clampedHeight);
		504	drawerHeightRef.current = clampedHeight;
		505	lastSyncedHeightRef.current = clampedHeight;
		506	}, [height, threadId]);
		507
		508	const handleResizePointerDown = useCallback((event: ReactPointerEvent<HTMLDivElement>) => {
		509	if (event.button !== 0) return;
		510	event.preventDefault();
		511	event.currentTarget.setPointerCapture(event.pointerId);
		512	didResizeDuringDragRef.current = false;
		513	resizeStateRef.current = {
		514	pointerId: event.pointerId,
		515	startY: event.clientY,
		516	startHeight: drawerHeightRef.current,
		517	};
		518	}, []);
		519
		520	const handleResizePointerMove = useCallback((event: ReactPointerEvent<HTMLDivElement>) => {
		521	const resizeState = resizeStateRef.current;
		522	if (!resizeState \|\| resizeState.pointerId !== event.pointerId) return;
		523	event.preventDefault();
		524	const clampedHeight = clampDrawerHeight(
		525	resizeState.startHeight + (resizeState.startY - event.clientY),
		526	);
		527	if (clampedHeight === drawerHeightRef.current) {
		528	return;
		529	}
		530	didResizeDuringDragRef.current = true;
		531	drawerHeightRef.current = clampedHeight;
		532	setDrawerHeight(clampedHeight);
		533	}, []);
		534
		535	const handleResizePointerEnd = useCallback(
		536	(event: ReactPointerEvent<HTMLDivElement>) => {
		537	const resizeState = resizeStateRef.current;
		538	if (!resizeState \|\| resizeState.pointerId !== event.pointerId) return;
		539	resizeStateRef.current = null;
		540	if (event.currentTarget.hasPointerCapture(event.pointerId)) {
		541	event.currentTarget.releasePointerCapture(event.pointerId);
		542	}
		543	if (!didResizeDuringDragRef.current) {
		544	return;
		545	}
		546	syncHeight(drawerHeightRef.current);
		547	setResizeEpoch((value) => value + 1);
		548	},
		549	[syncHeight],
		550	);
		551
		552	useEffect(() => {
		553	const onWindowResize = () => {
		554	const clampedHeight = clampDrawerHeight(drawerHeightRef.current);
		555	const changed = clampedHeight !== drawerHeightRef.current;
		556	if (changed) {
		557	setDrawerHeight(clampedHeight);
		558	drawerHeightRef.current = clampedHeight;
		559	}
		560	if (!resizeStateRef.current) {
		561	syncHeight(clampedHeight);
		562	}
		563	setResizeEpoch((value) => value + 1);
		564	};
		565	window.addEventListener("resize", onWindowResize);
		566	return () => {
		567	window.removeEventListener("resize", onWindowResize);
		568	};
		569	}, [syncHeight]);
		570
		571	useEffect(() => {
		572	return () => {
		573	syncHeight(drawerHeightRef.current);
		574	};
		575	}, [syncHeight]);
504		576
505	return (	577	return (
506	<aside	578	<aside
...	@@ -516,11 +588,83 @@ export default function ThreadTerminalDrawer({	...	@@ -516,11 +588,83 @@ export default function ThreadTerminalDrawer({
516	>	588	>
517	<div className="h-px w-10 rounded-full bg-border/80" />	589	<div className="h-px w-10 rounded-full bg-border/80" />
518	</div>	590	</div>
		591
		592	<div className="flex items-center gap-2 px-2 pb-1">
		593	{showTabBar ? (
		594	<div className="min-w-0 flex-1 overflow-x-auto">
		595	<div className="inline-flex rounded-md border border-border/80 bg-muted/40 p-0.5">
		596	{normalizedTerminalIds.map((terminalId, index) => {
		597	const isActive = terminalId === resolvedActiveTerminalId;
		598	return (
		599	<button
		600	key={terminalId}
		601	type="button"
		602	className={`rounded px-2.5 py-1 text-xs transition-colors ${
		603	isActive
		604	? "bg-background text-foreground shadow-sm"
		605	: "text-muted-foreground hover:text-foreground"
		606	}`}
		607	onClick={() => onActiveTerminalChange(terminalId)}
		608	>
		609	{`Terminal ${index + 1}`}
		610	</button>
		611	);
		612	})}
		613	</div>
		614	</div>
		615	) : (
		616	<div className="flex-1" />
		617	)}
		618
		619	<div className="inline-flex items-center overflow-hidden rounded-md border border-border/80 bg-muted/30">
		620	<button
		621	type="button"
		622	className="px-2.5 py-1 text-xs text-foreground/90 transition-colors hover:bg-accent"
		623	onClick={onSplitTerminal}
		624	>
		625	Split Terminal
		626	</button>
		627	<div className="h-5 w-px bg-border/80" />
		628	<button
		629	type="button"
		630	className="px-2.5 py-1 text-xs text-foreground/90 transition-colors hover:bg-accent"
		631	onClick={onNewTerminal}
		632	>
		633	New Terminal
		634	</button>
		635	</div>
		636	</div>
		637
519	<div className="min-h-0 w-full flex-1 px-1.5 pb-1">	638	<div className="min-h-0 w-full flex-1 px-1.5 pb-1">
520	<div	639	{terminalLayout === "split" && visibleTerminalIds.length === 2 ? (
521	ref={containerRef}	640	<div className="grid h-full w-full grid-cols-2 gap-1">
522	className="h-full w-full overflow-hidden rounded-[4px]"	641	{visibleTerminalIds.map((terminalId) => (
523	/>	642	<TerminalViewport
		643	key={terminalId}
		644	api={api}
		645	threadId={threadId}
		646	terminalId={terminalId}
		647	cwd={cwd}
		648	focusRequestId={focusRequestId}
		649	autoFocus={terminalId === resolvedActiveTerminalId}
		650	resizeEpoch={resizeEpoch}
		651	drawerHeight={drawerHeight}
		652	/>
		653	))}
		654	</div>
		655	) : (
		656	<TerminalViewport
		657	key={resolvedActiveTerminalId}
		658	api={api}
		659	threadId={threadId}
		660	terminalId={resolvedActiveTerminalId}
		661	cwd={cwd}
		662	focusRequestId={focusRequestId}
		663	autoFocus
		664	resizeEpoch={resizeEpoch}
		665	drawerHeight={drawerHeight}
		666	/>
		667	)}
524	</div>	668	</div>
525	</aside>	669	</aside>
526	);	670	);

apps/web/src/persistenceSchema.test.ts+28-1

 @@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 import { DEFAULT_MODEL } from "./model-logic";
 import { hydratePersistedState, toPersistedState } from "./persistenceSchema";
-import { DEFAULT_THREAD_TERMINAL_HEIGHT } from "./types";
+import { DEFAULT_THREAD_TERMINAL_HEIGHT, DEFAULT_THREAD_TERMINAL_ID } from "./types";
 import type { Thread } from "./types";
 describe("hydratePersistedState", () => {
 @@ -50,6 +50,10 @@ describe("hydratePersistedState", () => {
     expect(hydrated?.threads[0]?.codexThreadId).toBeNull();
     expect(hydrated?.threads[0]?.terminalOpen).toBe(false);
     expect(hydrated?.threads[0]?.terminalHeight).toBe(DEFAULT_THREAD_TERMINAL_HEIGHT);
+    expect(hydrated?.threads[0]?.terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID]);
+    expect(hydrated?.threads[0]?.activeTerminalId).toBe(DEFAULT_THREAD_TERMINAL_ID);
+    expect(hydrated?.threads[0]?.terminalLayout).toBe("single");
+    expect(hydrated?.threads[0]?.splitTerminalIds).toEqual([]);
     expect(hydrated?.threads[0]?.messages[0]?.streaming).toBe(false);
     expect(hydrated?.runtimeMode).toBe("full-access");
   });
 @@ -92,6 +96,10 @@ describe("hydratePersistedState", () => {
     expect(hydrated?.threads[0]?.codexThreadId).toBeNull();
     expect(hydrated?.threads[0]?.terminalOpen).toBe(false);
     expect(hydrated?.threads[0]?.terminalHeight).toBe(DEFAULT_THREAD_TERMINAL_HEIGHT);
+    expect(hydrated?.threads[0]?.terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID]);
+    expect(hydrated?.threads[0]?.activeTerminalId).toBe(DEFAULT_THREAD_TERMINAL_ID);
+    expect(hydrated?.threads[0]?.terminalLayout).toBe("single");
+    expect(hydrated?.threads[0]?.splitTerminalIds).toEqual([]);
     expect(hydrated?.activeThreadId).toBe("t-1");
     expect(hydrated?.runtimeMode).toBe("full-access");
   });
 @@ -139,6 +147,10 @@ describe("hydratePersistedState", () => {
           model: "gpt-5.3-codex",
           terminalOpen: true,
           terminalHeight: 360,
+          terminalIds: [DEFAULT_THREAD_TERMINAL_ID, "term-2"],
+          activeTerminalId: "term-2",
+          terminalLayout: "tabs",
+          splitTerminalIds: [],
           messages: [],
           createdAt: "2026-02-08T10:00:00.000Z",
           lastVisitedAt: "2026-02-08T10:01:00.000Z",
 @@ -150,6 +162,10 @@ describe("hydratePersistedState", () => {
     const hydrated = hydratePersistedState(payload, false);
     expect(hydrated?.threads[0]?.terminalOpen).toBe(true);
     expect(hydrated?.threads[0]?.terminalHeight).toBe(360);
+    expect(hydrated?.threads[0]?.terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID, "term-2"]);
+    expect(hydrated?.threads[0]?.activeTerminalId).toBe("term-2");
+    expect(hydrated?.threads[0]?.terminalLayout).toBe("tabs");
+    expect(hydrated?.threads[0]?.splitTerminalIds).toEqual([]);
     expect(hydrated?.threads[0]?.lastVisitedAt).toBe("2026-02-08T10:01:00.000Z");
   });
 @@ -183,6 +199,9 @@ describe("hydratePersistedState", () => {
     const hydrated = hydratePersistedState(payload, false);
     expect(hydrated?.threads[0]?.terminalHeight).toBe(DEFAULT_THREAD_TERMINAL_HEIGHT);
+    expect(hydrated?.threads[0]?.terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID]);
+    expect(hydrated?.threads[0]?.activeTerminalId).toBe(DEFAULT_THREAD_TERMINAL_ID);
+    expect(hydrated?.threads[0]?.terminalLayout).toBe("single");
   });
 });
 @@ -196,6 +215,10 @@ describe("toPersistedState", () => {
       model: "gpt-5.3-codex",
       terminalOpen: true,
       terminalHeight: 320,
+      terminalIds: [DEFAULT_THREAD_TERMINAL_ID, "term-2"],
+      activeTerminalId: "term-2",
+      terminalLayout: "tabs",
+      splitTerminalIds: [],
       session: null,
       messages: [
         {
 @@ -249,6 +272,10 @@ describe("toPersistedState", () => {
       model: "gpt-5.3-codex",
       terminalOpen: true,
       terminalHeight: 320,
+      terminalIds: [DEFAULT_THREAD_TERMINAL_ID, "term-2"],
+      activeTerminalId: "term-2",
+      terminalLayout: "tabs",
+      splitTerminalIds: [],
       messages: [
         {
           id: "m-1",

apps/web/src/persistenceSchema.ts+40

...	@@ -3,6 +3,7 @@ import { z } from "zod";	...	@@ -3,6 +3,7 @@ import { z } from "zod";
3	import { DEFAULT_MODEL, resolveModelSlug } from "./model-logic";	3	import { DEFAULT_MODEL, resolveModelSlug } from "./model-logic";
4	import {	4	import {
5	DEFAULT_THREAD_TERMINAL_HEIGHT,	5	DEFAULT_THREAD_TERMINAL_HEIGHT,
		6	DEFAULT_THREAD_TERMINAL_ID,
6	DEFAULT_RUNTIME_MODE,	7	DEFAULT_RUNTIME_MODE,
7	type Project,	8	type Project,
8	type RuntimeMode,	9	type RuntimeMode,
...	@@ -48,6 +49,10 @@ const persistedThreadSchema = z.object({	...	@@ -48,6 +49,10 @@ const persistedThreadSchema = z.object({
48	terminalHeight: z.number().int().min(120).max(4_096).default(	49	terminalHeight: z.number().int().min(120).max(4_096).default(
49	DEFAULT_THREAD_TERMINAL_HEIGHT,	50	DEFAULT_THREAD_TERMINAL_HEIGHT,
50	),	51	),
		52	terminalIds: z.array(z.string().trim().min(1)).default([DEFAULT_THREAD_TERMINAL_ID]),
		53	activeTerminalId: z.string().trim().min(1).default(DEFAULT_THREAD_TERMINAL_ID),
		54	terminalLayout: z.enum(["single", "split", "tabs"]).default("single"),
		55	splitTerminalIds: z.array(z.string().trim().min(1)).default([]),
51	messages: z.array(persistedMessageSchema),	56	messages: z.array(persistedMessageSchema),
52	createdAt: z.string().min(1),	57	createdAt: z.string().min(1),
53	lastVisitedAt: z.string().min(1).optional(),	58	lastVisitedAt: z.string().min(1).optional(),
...	@@ -129,6 +134,33 @@ function hydrateThread(	...	@@ -129,6 +134,33 @@ function hydrateThread(
129	thread: z.infer<typeof persistedThreadSchema>,	134	thread: z.infer<typeof persistedThreadSchema>,
130	isLegacyPayload: boolean,	135	isLegacyPayload: boolean,
131	): Thread {	136	): Thread {
		137	const terminalIds = [...new Set(thread.terminalIds)]
		138	.map((id) => id.trim())
		139	.filter((id) => id.length > 0);
		140	const safeTerminalIds =
		141	terminalIds.length > 0 ? terminalIds : [DEFAULT_THREAD_TERMINAL_ID];
		142	const activeTerminalId = safeTerminalIds.includes(thread.activeTerminalId)
		143	? thread.activeTerminalId
		144	: (safeTerminalIds[0] ?? DEFAULT_THREAD_TERMINAL_ID);
		145	let terminalLayout = thread.terminalLayout;
		146	let splitTerminalIds = [...new Set(thread.splitTerminalIds)].filter((id) =>
		147	safeTerminalIds.includes(id),
		148	);
		149	if (terminalLayout === "split") {
		150	splitTerminalIds = splitTerminalIds.slice(0, 2);
		151	if (splitTerminalIds.length < 2) {
		152	terminalLayout = safeTerminalIds.length > 1 ? "tabs" : "single";
		153	splitTerminalIds = [];
		154	}
		155	} else {
		156	splitTerminalIds = [];
		157	}
		158	if (terminalLayout === "single" && safeTerminalIds.length > 1) {
		159	terminalLayout = "tabs";
		160	} else if (terminalLayout === "tabs" && safeTerminalIds.length < 2) {
		161	terminalLayout = "single";
		162	}
		163
132	return {	164	return {
133	id: thread.id,	165	id: thread.id,
134	codexThreadId: thread.codexThreadId,	166	codexThreadId: thread.codexThreadId,
...	@@ -137,6 +169,10 @@ function hydrateThread(	...	@@ -137,6 +169,10 @@ function hydrateThread(
137	model: resolveModelSlug(maybeMigrateLegacyModel(thread.model, isLegacyPayload)),	169	model: resolveModelSlug(maybeMigrateLegacyModel(thread.model, isLegacyPayload)),
138	terminalOpen: thread.terminalOpen ?? false,	170	terminalOpen: thread.terminalOpen ?? false,
139	terminalHeight: thread.terminalHeight ?? DEFAULT_THREAD_TERMINAL_HEIGHT,	171	terminalHeight: thread.terminalHeight ?? DEFAULT_THREAD_TERMINAL_HEIGHT,
		172	terminalIds: safeTerminalIds,
		173	activeTerminalId,
		174	terminalLayout,
		175	splitTerminalIds,
140	session: null,	176	session: null,
141	messages: thread.messages.map((message) => {	177	messages: thread.messages.map((message) => {
142	const hydratedAttachments = message.attachments?.map((attachment) => ({ ...attachment }));	178	const hydratedAttachments = message.attachments?.map((attachment) => ({ ...attachment }));
...	@@ -211,6 +247,10 @@ export function toPersistedState(	...	@@ -211,6 +247,10 @@ export function toPersistedState(
211	model: thread.model,	247	model: thread.model,
212	terminalOpen: thread.terminalOpen,	248	terminalOpen: thread.terminalOpen,
213	terminalHeight: thread.terminalHeight,	249	terminalHeight: thread.terminalHeight,
		250	terminalIds: thread.terminalIds,
		251	activeTerminalId: thread.activeTerminalId,
		252	terminalLayout: thread.terminalLayout,
		253	splitTerminalIds: thread.splitTerminalIds,
214	messages: thread.messages.map((message) => ({	254	messages: thread.messages.map((message) => ({
215	id: message.id,	255	id: message.id,
216	role: message.role,	256	role: message.role,

apps/web/src/store.test.ts+50-1

...	@@ -2,7 +2,7 @@ import type { ProviderEvent, ProviderSession } from "@t3tools/contracts";	...	@@ -2,7 +2,7 @@ import type { ProviderEvent, ProviderSession } from "@t3tools/contracts";
2	import { describe, expect, it } from "vitest";	2	import { describe, expect, it } from "vitest";
3		3
4	import { type AppState, reducer } from "./store";	4	import { type AppState, reducer } from "./store";
5	import { DEFAULT_THREAD_TERMINAL_HEIGHT } from "./types";	5	import { DEFAULT_THREAD_TERMINAL_HEIGHT, DEFAULT_THREAD_TERMINAL_ID } from "./types";
6	import type { Thread } from "./types";	6	import type { Thread } from "./types";
7		7
8	function makeSession(overrides: Partial<ProviderSession> = {}): ProviderSession {	8	function makeSession(overrides: Partial<ProviderSession> = {}): ProviderSession {
...	@@ -37,6 +37,10 @@ function makeThread(overrides: Partial<Thread> = {}): Thread {	...	@@ -37,6 +37,10 @@ function makeThread(overrides: Partial<Thread> = {}): Thread {
37	model: "gpt-5.3-codex",	37	model: "gpt-5.3-codex",
38	terminalOpen: false,	38	terminalOpen: false,
39	terminalHeight: DEFAULT_THREAD_TERMINAL_HEIGHT,	39	terminalHeight: DEFAULT_THREAD_TERMINAL_HEIGHT,
		40	terminalIds: [DEFAULT_THREAD_TERMINAL_ID],
		41	activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,
		42	terminalLayout: "single",
		43	splitTerminalIds: [],
40	session: makeSession(),	44	session: makeSession(),
41	messages: [],	45	messages: [],
42	events: [],	46	events: [],
...	@@ -111,6 +115,51 @@ describe("store reducer thread continuity", () => {	...	@@ -111,6 +115,51 @@ describe("store reducer thread continuity", () => {
111	expect(next.threads[0]?.terminalHeight).toBe(360);	115	expect(next.threads[0]?.terminalHeight).toBe(360);
112	});	116	});
113		117
		118	it("splits the active terminal into side-by-side mode", () => {
		119	const state = makeState(makeThread());
		120	const next = reducer(state, {
		121	type: "SPLIT_THREAD_TERMINAL",
		122	threadId: "thread-local-1",
		123	terminalId: "term-2",
		124	});
		125
		126	expect(next.threads[0]?.terminalLayout).toBe("split");
		127	expect(next.threads[0]?.terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID, "term-2"]);
		128	expect(next.threads[0]?.splitTerminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID, "term-2"]);
		129	expect(next.threads[0]?.activeTerminalId).toBe("term-2");
		130	});
		131
		132	it("creates a new full-width terminal and switches to tab mode", () => {
		133	const state = makeState(makeThread());
		134	const next = reducer(state, {
		135	type: "NEW_THREAD_TERMINAL",
		136	threadId: "thread-local-1",
		137	terminalId: "term-2",
		138	});
		139
		140	expect(next.threads[0]?.terminalLayout).toBe("tabs");
		141	expect(next.threads[0]?.terminalIds).toEqual([DEFAULT_THREAD_TERMINAL_ID, "term-2"]);
		142	expect(next.threads[0]?.activeTerminalId).toBe("term-2");
		143	expect(next.threads[0]?.splitTerminalIds).toEqual([]);
		144	});
		145
		146	it("switches the active tab terminal", () => {
		147	const state = makeState(
		148	makeThread({
		149	terminalIds: [DEFAULT_THREAD_TERMINAL_ID, "term-2"],
		150	activeTerminalId: DEFAULT_THREAD_TERMINAL_ID,
		151	terminalLayout: "tabs",
		152	}),
		153	);
		154	const next = reducer(state, {
		155	type: "SET_THREAD_ACTIVE_TERMINAL",
		156	threadId: "thread-local-1",
		157	terminalId: "term-2",
		158	});
		159
		160	expect(next.threads[0]?.activeTerminalId).toBe("term-2");
		161	});
		162
114	it("backfills codexThreadId from routed provider events", () => {	163	it("backfills codexThreadId from routed provider events", () => {
115	const state = makeState(makeThread({ codexThreadId: null }));	164	const state = makeState(makeThread({ codexThreadId: null }));
116	const next = reducer(state, {	165	const next = reducer(state, {

apps/web/src/store.ts+127-11

...	@@ -14,6 +14,7 @@ import { hydratePersistedState, toPersistedState } from "./persistenceSchema";	...	@@ -14,6 +14,7 @@ import { hydratePersistedState, toPersistedState } from "./persistenceSchema";
14	import { applyEventToMessages, asObject, asString, evolveSession } from "./session-logic";	14	import { applyEventToMessages, asObject, asString, evolveSession } from "./session-logic";
15	import {	15	import {
16	type ChatAttachment,	16	type ChatAttachment,
		17	DEFAULT_THREAD_TERMINAL_ID,
17	DEFAULT_RUNTIME_MODE,	18	DEFAULT_RUNTIME_MODE,
18	type Project,	19	type Project,
19	type RuntimeMode,	20	type RuntimeMode,
...	@@ -31,6 +32,9 @@ type Action =	...	@@ -31,6 +32,9 @@ type Action =
31	\| { type: "TOGGLE_THREAD_TERMINAL"; threadId: string }	32	\| { type: "TOGGLE_THREAD_TERMINAL"; threadId: string }
32	\| { type: "SET_THREAD_TERMINAL_OPEN"; threadId: string; open: boolean }	33	\| { type: "SET_THREAD_TERMINAL_OPEN"; threadId: string; open: boolean }
33	\| { type: "SET_THREAD_TERMINAL_HEIGHT"; threadId: string; height: number }	34	\| { type: "SET_THREAD_TERMINAL_HEIGHT"; threadId: string; height: number }
		35	\| { type: "SPLIT_THREAD_TERMINAL"; threadId: string; terminalId: string }
		36	\| { type: "NEW_THREAD_TERMINAL"; threadId: string; terminalId: string }
		37	\| { type: "SET_THREAD_ACTIVE_TERMINAL"; threadId: string; terminalId: string }
34	\| { type: "TOGGLE_DIFF" }	38	\| { type: "TOGGLE_DIFF" }
35	\| {	39	\| {
36	type: "APPLY_EVENT";	40	type: "APPLY_EVENT";
...	@@ -133,6 +137,58 @@ function updateThread(	...	@@ -133,6 +137,58 @@ function updateThread(
133	return threads.map((t) => (t.id === threadId ? updater(t) : t));	137	return threads.map((t) => (t.id === threadId ? updater(t) : t));
134	}	138	}
135		139
		140	function normalizeTerminalIds(terminalIds: string[]): string[] {
		141	const ids = terminalIds
		142	.map((id) => id.trim())
		143	.filter((id) => id.length > 0);
		144	const unique = [...new Set(ids)];
		145	if (unique.length > 0) {
		146	return unique;
		147	}
		148	return [DEFAULT_THREAD_TERMINAL_ID];
		149	}
		150
		151	function normalizeThreadTerminals(thread: Thread): Thread {
		152	const terminalIds = normalizeTerminalIds(thread.terminalIds);
		153	const activeTerminalId = terminalIds.includes(thread.activeTerminalId)
		154	? thread.activeTerminalId
		155	: (terminalIds[0] ?? DEFAULT_THREAD_TERMINAL_ID);
		156
		157	if (thread.terminalLayout === "split") {
		158	const validSplitIds = [...new Set(thread.splitTerminalIds)].filter((id) =>
		159	terminalIds.includes(id),
		160	);
		161	if (validSplitIds.length >= 2) {
		162	const splitTerminalIds = validSplitIds.slice(0, 2);
		163	const splitActiveTerminalId = splitTerminalIds.includes(activeTerminalId)
		164	? activeTerminalId
		165	: (splitTerminalIds[1] ?? splitTerminalIds[0] ?? activeTerminalId);
		166	return {
		167	...thread,
		168	terminalIds,
		169	activeTerminalId: splitActiveTerminalId,
		170	terminalLayout: "split",
		171	splitTerminalIds,
		172	};
		173	}
		174	}
		175
		176	const terminalLayout =
		177	terminalIds.length > 1 && thread.terminalLayout === "single"
		178	? "tabs"
		179	: (thread.terminalLayout === "tabs" && terminalIds.length < 2
		180	? "single"
		181	: thread.terminalLayout);
		182
		183	return {
		184	...thread,
		185	terminalIds,
		186	activeTerminalId,
		187	terminalLayout,
		188	splitTerminalIds: [],
		189	};
		190	}
		191
136	function findThreadBySessionId(threads: Thread[], sessionId: string): Thread \| undefined {	192	function findThreadBySessionId(threads: Thread[], sessionId: string): Thread \| undefined {
137	return threads.find((t) => t.session?.sessionId === sessionId);	193	return threads.find((t) => t.session?.sessionId === sessionId);
138	}	194	}
...	@@ -259,10 +315,10 @@ export function reducer(state: AppState, action: Action): AppState {	...	@@ -259,10 +315,10 @@ export function reducer(state: AppState, action: Action): AppState {
259	if (!previousProject) return null;	315	if (!previousProject) return null;
260	const mappedProjectId = nextProjectIdByCwd.get(previousProject.cwd);	316	const mappedProjectId = nextProjectIdByCwd.get(previousProject.cwd);
261	if (!mappedProjectId) return null;	317	if (!mappedProjectId) return null;
262	return {	318	return normalizeThreadTerminals({
263	...thread,	319	...thread,
264	projectId: mappedProjectId,	320	projectId: mappedProjectId,
265	};	321	});
266	})	322	})
267	.filter((thread): thread is Thread => thread !== null);	323	.filter((thread): thread is Thread => thread !== null);
268	const activeThreadId = nextThreads.some((thread) => thread.id === state.activeThreadId)	324	const activeThreadId = nextThreads.some((thread) => thread.id === state.activeThreadId)
...	@@ -285,19 +341,18 @@ export function reducer(state: AppState, action: Action): AppState {	...	@@ -285,19 +341,18 @@ export function reducer(state: AppState, action: Action): AppState {
285	),	341	),
286	};	342	};
287		343
288	case "ADD_THREAD":	344	case "ADD_THREAD": {
		345	const nextThread = normalizeThreadTerminals({
		346	...action.thread,
		347	model: resolveModelSlug(action.thread.model),
		348	lastVisitedAt: action.thread.lastVisitedAt ?? action.thread.createdAt,
		349	});
289	return {	350	return {
290	...state,	351	...state,
291	threads: [	352	threads: [...state.threads, nextThread],
292	...state.threads,
293	{
294	...action.thread,
295	model: resolveModelSlug(action.thread.model),
296	lastVisitedAt: action.thread.lastVisitedAt ?? action.thread.createdAt,
297	},
298	],
299	activeThreadId: action.thread.id,	353	activeThreadId: action.thread.id,
300	};	354	};
		355	}
301		356
302	case "SET_ACTIVE_THREAD": {	357	case "SET_ACTIVE_THREAD": {
303	const visitedAt = new Date().toISOString();	358	const visitedAt = new Date().toISOString();
...	@@ -338,6 +393,67 @@ export function reducer(state: AppState, action: Action): AppState {	...	@@ -338,6 +393,67 @@ export function reducer(state: AppState, action: Action): AppState {
338	})),	393	})),
339	};	394	};
340		395
		396	case "SPLIT_THREAD_TERMINAL":
		397	return {
		398	...state,
		399	threads: updateThread(state.threads, action.threadId, (thread) => {
		400	const terminalIds = thread.terminalIds.includes(action.terminalId)
		401	? thread.terminalIds
		402	: [...thread.terminalIds, action.terminalId];
		403	const firstTerminalId =
		404	terminalIds.includes(thread.activeTerminalId)
		405	? thread.activeTerminalId
		406	: (terminalIds[0] ?? DEFAULT_THREAD_TERMINAL_ID);
		407	const secondTerminalId =
		408	action.terminalId === firstTerminalId
		409	? (terminalIds.find((id) => id !== firstTerminalId) ?? firstTerminalId)
		410	: action.terminalId;
		411	const splitTerminalIds =
		412	firstTerminalId === secondTerminalId
		413	? []
		414	: [firstTerminalId, secondTerminalId];
		415
		416	return normalizeThreadTerminals({
		417	...thread,
		418	terminalIds,
		419	activeTerminalId: secondTerminalId,
		420	terminalLayout: splitTerminalIds.length === 2 ? "split" : "single",
		421	splitTerminalIds,
		422	});
		423	}),
		424	};
		425
		426	case "NEW_THREAD_TERMINAL":
		427	return {
		428	...state,
		429	threads: updateThread(state.threads, action.threadId, (thread) => {
		430	const terminalIds = thread.terminalIds.includes(action.terminalId)
		431	? thread.terminalIds
		432	: [...thread.terminalIds, action.terminalId];
		433	return normalizeThreadTerminals({
		434	...thread,
		435	terminalIds,
		436	activeTerminalId: action.terminalId,
		437	terminalLayout: "tabs",
		438	splitTerminalIds: [],
		439	});
		440	}),
		441	};
		442
		443	case "SET_THREAD_ACTIVE_TERMINAL":
		444	return {
		445	...state,
		446	threads: updateThread(state.threads, action.threadId, (thread) => {
		447	if (!thread.terminalIds.includes(action.terminalId)) {
		448	return thread;
		449	}
		450	return normalizeThreadTerminals({
		451	...thread,
		452	activeTerminalId: action.terminalId,
		453	});
		454	}),
		455	};
		456
341	case "TOGGLE_DIFF":	457	case "TOGGLE_DIFF":
342	return { ...state, diffOpen: !state.diffOpen };	458	return { ...state, diffOpen: !state.diffOpen };
343		459

apps/web/src/types.ts+6

 @@ -4,6 +4,8 @@ export type SessionPhase = "disconnected" | "connecting" | "ready" | "running";
 export type RuntimeMode = "approval-required" | "full-access";
 export const DEFAULT_RUNTIME_MODE: RuntimeMode = "full-access";
 export const DEFAULT_THREAD_TERMINAL_HEIGHT = 280;
+export const DEFAULT_THREAD_TERMINAL_ID = "default";
+export type ThreadTerminalLayout = "single" | "split" | "tabs";
 export interface ChatImageAttachment {
   type: "image";
 @@ -41,6 +43,10 @@ export interface Thread {
   model: string;
   terminalOpen: boolean;
   terminalHeight: number;
+  terminalIds: string[];
+  activeTerminalId: string;
+  terminalLayout: ThreadTerminalLayout;
+  splitTerminalIds: string[];
   session: ProviderSession | null;
   messages: ChatMessage[];
   events: ProviderEvent[];

packages/contracts/src/ipc.ts+2-2

 @@ -30,12 +30,12 @@ import type {
   ProjectRemoveInput,
 } from "./project";
 import type {
+  TerminalClearInput,
   TerminalCloseInput,
   TerminalEvent,
   TerminalOpenInput,
   TerminalResizeInput,
   TerminalSessionSnapshot,
-  TerminalThreadInput,
   TerminalWriteInput,
 } from "./terminal";
 import type { NewTodoInput, Todo } from "./todo";
 @@ -61,7 +61,7 @@ export interface NativeApi {
     open: (input: TerminalOpenInput) => Promise<TerminalSessionSnapshot>;
     write: (input: TerminalWriteInput) => Promise<void>;
     resize: (input: TerminalResizeInput) => Promise<void>;
-    clear: (input: TerminalThreadInput) => Promise<void>;
+    clear: (input: TerminalClearInput) => Promise<void>;
     restart: (input: TerminalOpenInput) => Promise<TerminalSessionSnapshot>;
     close: (input: TerminalCloseInput) => Promise<void>;
     onEvent: (callback: (event: TerminalEvent) => void) => () => void;

packages/contracts/src/terminal.test.ts+24

 @@ -1,6 +1,8 @@
 import { describe, expect, it } from "vitest";
 import {
+  DEFAULT_TERMINAL_ID,
+  terminalClearInputSchema,
   terminalCloseInputSchema,
   terminalEventSchema,
   terminalOpenInputSchema,
 @@ -30,6 +32,16 @@ describe("terminalOpenInputSchema", () => {
     });
     expect(result.success).toBe(false);
   });
+  it("defaults terminalId when missing", () => {
+    const parsed = terminalOpenInputSchema.parse({
+      threadId: "thread-1",
+      cwd: "/tmp/project",
+      cols: 100,
+      rows: 24,
+    });
+    expect(parsed.terminalId).toBe(DEFAULT_TERMINAL_ID);
+  });
 });
 describe("terminalWriteInputSchema", () => {
 @@ -68,6 +80,15 @@ describe("terminalResizeInputSchema", () => {
   });
 });
+describe("terminalClearInputSchema", () => {
+  it("defaults terminal id", () => {
+    const parsed = terminalClearInputSchema.parse({
+      threadId: "thread-1",
+    });
+    expect(parsed.terminalId).toBe(DEFAULT_TERMINAL_ID);
+  });
+});
 describe("terminalCloseInputSchema", () => {
   it("accepts optional deleteHistory", () => {
     const result = terminalCloseInputSchema.safeParse({
 @@ -82,6 +103,7 @@ describe("terminalSessionSnapshotSchema", () => {
   it("accepts running snapshots", () => {
     const result = terminalSessionSnapshotSchema.safeParse({
       threadId: "thread-1",
+      terminalId: DEFAULT_TERMINAL_ID,
       cwd: "/tmp/project",
       status: "running",
       pid: 1234,
 @@ -99,6 +121,7 @@ describe("terminalEventSchema", () => {
     const result = terminalEventSchema.safeParse({
       type: "output",
       threadId: "thread-1",
+      terminalId: DEFAULT_TERMINAL_ID,
       createdAt: new Date().toISOString(),
       data: "line\n",
     });
 @@ -109,6 +132,7 @@ describe("terminalEventSchema", () => {
     const result = terminalEventSchema.safeParse({
       type: "exited",
       threadId: "thread-1",
+      terminalId: DEFAULT_TERMINAL_ID,
       createdAt: new Date().toISOString(),
       exitCode: 0,
       exitSignal: null,

packages/contracts/src/terminal.ts+17-3

 @@ -1,28 +1,38 @@
 import { z } from "zod";
+export const DEFAULT_TERMINAL_ID = "default";
 const terminalColsSchema = z.number().int().min(20).max(400);
 const terminalRowsSchema = z.number().int().min(5).max(200);
+const terminalIdSchema = z.string().trim().min(1).max(128);
 export const terminalThreadInputSchema = z.object({
   threadId: z.string().trim().min(1),
 });
-export const terminalOpenInputSchema = terminalThreadInputSchema.extend({
+export const terminalSessionInputSchema = terminalThreadInputSchema.extend({
+  terminalId: terminalIdSchema.default(DEFAULT_TERMINAL_ID),
+});
+export const terminalOpenInputSchema = terminalSessionInputSchema.extend({
   cwd: z.string().trim().min(1),
   cols: terminalColsSchema,
   rows: terminalRowsSchema,
 });
-export const terminalWriteInputSchema = terminalThreadInputSchema.extend({
+export const terminalWriteInputSchema = terminalSessionInputSchema.extend({
   data: z.string().min(1).max(65_536),
 });
-export const terminalResizeInputSchema = terminalThreadInputSchema.extend({
+export const terminalResizeInputSchema = terminalSessionInputSchema.extend({
   cols: terminalColsSchema,
   rows: terminalRowsSchema,
 });
+export const terminalClearInputSchema = terminalSessionInputSchema;
 export const terminalCloseInputSchema = terminalThreadInputSchema.extend({
+  terminalId: terminalIdSchema.optional(),
   deleteHistory: z.boolean().optional(),
 });
 @@ -35,6 +45,7 @@ export const terminalSessionStatusSchema = z.enum([
 export const terminalSessionSnapshotSchema = z.object({
   threadId: z.string().min(1),
+  terminalId: z.string().min(1),
   cwd: z.string().min(1),
   status: terminalSessionStatusSchema,
   pid: z.number().int().positive().nullable(),
 @@ -46,6 +57,7 @@ export const terminalSessionSnapshotSchema = z.object({
 const terminalEventBaseSchema = z.object({
   threadId: z.string().min(1),
+  terminalId: z.string().min(1),
   createdAt: z.string().datetime(),
 });
 @@ -89,9 +101,11 @@ export const terminalEventSchema = z.discriminatedUnion("type", [
 ]);
 export type TerminalThreadInput = z.input<typeof terminalThreadInputSchema>;
+export type TerminalSessionInput = z.input<typeof terminalSessionInputSchema>;
 export type TerminalOpenInput = z.input<typeof terminalOpenInputSchema>;
 export type TerminalWriteInput = z.input<typeof terminalWriteInputSchema>;
 export type TerminalResizeInput = z.input<typeof terminalResizeInputSchema>;
+export type TerminalClearInput = z.input<typeof terminalClearInputSchema>;
 export type TerminalCloseInput = z.input<typeof terminalCloseInputSchema>;
 export type TerminalSessionStatus = z.infer<typeof terminalSessionStatusSchema>;
 export type TerminalSessionSnapshot = z.infer<typeof terminalSessionSnapshotSchema>;

author	Julius Marminge <julius0216@outlook.com> 2026-02-12 20:13:10-08:00
committer	Julius Marminge <jmarminge@gmail.com> 2026-02-12 21:24:49-08:00
log	800eb3b547aa5e073248f1db9272efe556df6928
tree	622219eb2ba6bced6903e3c65e480aa772d2b352
parent	854068dc565bdbe8b9e7c6183eb4914674816fc3

Add per-thread multi-terminal sessions and UI state