lael-labs/t3code

apps/desktop/src/main.ts+9−0

 const UPDATE_INSTALL_CHANNEL = "desktop:update-install";
 const UPDATE_CHECK_CHANNEL = "desktop:update-check";
 const GET_WS_URL_CHANNEL = "desktop:get-ws-url";
+const GET_LOCAL_ENVIRONMENT_BOOTSTRAP_CHANNEL = "desktop:get-local-environment-bootstrap";
 const BASE_DIR = process.env.T3CODE_HOME?.trim() || Path.join(OS.homedir(), ".t3");
 const STATE_DIR = Path.join(BASE_DIR, "userdata");
 const DESKTOP_SCHEME = "t3";
     event.returnValue = backendWsUrl;
   });
+  ipcMain.removeAllListeners(GET_LOCAL_ENVIRONMENT_BOOTSTRAP_CHANNEL);
+  ipcMain.on(GET_LOCAL_ENVIRONMENT_BOOTSTRAP_CHANNEL, (event) => {
+    event.returnValue = {
+      label: "Local environment",
+      wsUrl: backendWsUrl || null,
+    } as const;
+  });
   ipcMain.removeHandler(PICK_FOLDER_CHANNEL);
   ipcMain.handle(PICK_FOLDER_CHANNEL, async () => {
     const owner = BrowserWindow.getFocusedWindow() ?? mainWindow;

apps/desktop/src/preload.ts+8−0

 const UPDATE_DOWNLOAD_CHANNEL = "desktop:update-download";
 const UPDATE_INSTALL_CHANNEL = "desktop:update-install";
 const GET_WS_URL_CHANNEL = "desktop:get-ws-url";
+const GET_LOCAL_ENVIRONMENT_BOOTSTRAP_CHANNEL = "desktop:get-local-environment-bootstrap";
 contextBridge.exposeInMainWorld("desktopBridge", {
   getWsUrl: () => {
     const result = ipcRenderer.sendSync(GET_WS_URL_CHANNEL);
     return typeof result === "string" ? result : null;
   },
+  getLocalEnvironmentBootstrap: () => {
+    const result = ipcRenderer.sendSync(GET_LOCAL_ENVIRONMENT_BOOTSTRAP_CHANNEL);
+    if (typeof result !== "object" || result === null) {
+      return null;
+    }
+    return result as ReturnType<DesktopBridge["getLocalEnvironmentBootstrap"]>;
+  },
   pickFolder: () => ipcRenderer.invoke(PICK_FOLDER_CHANNEL),
   confirm: (message) => ipcRenderer.invoke(CONFIRM_CHANNEL, message),
   setTheme: (theme) => ipcRenderer.invoke(SET_THEME_CHANNEL, theme),

apps/server/integration/OrchestrationEngineHarness.integration.ts+2−0

 import { ProviderService } from "../src/provider/Services/ProviderService.ts";
 import { AnalyticsService } from "../src/telemetry/Services/AnalyticsService.ts";
 import { CheckpointReactorLive } from "../src/orchestration/Layers/CheckpointReactor.ts";
+import { RepositoryIdentityResolverLive } from "../src/project/Layers/RepositoryIdentityResolver.ts";
 import { OrchestrationEngineLive } from "../src/orchestration/Layers/OrchestrationEngine.ts";
 import { OrchestrationProjectionPipelineLive } from "../src/orchestration/Layers/ProjectionPipeline.ts";
 import { OrchestrationProjectionSnapshotQueryLive } from "../src/orchestration/Layers/ProjectionSnapshotQuery.ts";
       Layer.provideMerge(runtimeServicesLayer),
       Layer.provideMerge(orchestrationReactorLayer),
       Layer.provide(persistenceLayer),
+      Layer.provideMerge(RepositoryIdentityResolverLive),
       Layer.provideMerge(ServerSettingsService.layerTest()),
       Layer.provideMerge(ServerConfig.layerTest(workspaceDir, rootDir)),
       Layer.provideMerge(NodeServices.layer),

apps/server/src/config.ts+2−0

   readonly providerEventLogPath: string;
   readonly terminalLogsDir: string;
   readonly anonymousIdPath: string;
+  readonly environmentIdPath: string;
 }
 /**
     providerEventLogPath: join(providerLogsDir, "events.log"),
     terminalLogsDir: join(logsDir, "terminals"),
     anonymousIdPath: join(stateDir, "anonymous-id"),
+    environmentIdPath: join(stateDir, "environment-id"),
   };
 });

apps/server/src/environment/Layers/ServerEnvironment.test.ts+124−0

@@ -0,0 +1,124 @@
	1	import * as nodePath from "node:path";
	2	import * as NodeServices from "@effect/platform-node/NodeServices";
	3	import { expect, it } from "@effect/vitest";
	4	import { Effect, Exit, FileSystem, Layer, PlatformError } from "effect";
	5
	6	import { deriveServerPaths, ServerConfig, type ServerConfigShape } from "../../config.ts";
	7	import { ServerEnvironment } from "../Services/ServerEnvironment.ts";
	8	import { ServerEnvironmentLive } from "./ServerEnvironment.ts";
	9
	10	const makeServerEnvironmentLayer = (baseDir: string) =>
	11	ServerEnvironmentLive.pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), baseDir)));
	12
	13	const makeServerConfig = Effect.fn(function* (baseDir: string) {
	14	const derivedPaths = yield* deriveServerPaths(baseDir, undefined);
	15
	16	return {
	17	...derivedPaths,
	18	logLevel: "Error",
	19	traceMinLevel: "Info",
	20	traceTimingEnabled: true,
	21	traceBatchWindowMs: 200,
	22	traceMaxBytes: 10 * 1024 * 1024,
	23	traceMaxFiles: 10,
	24	otlpTracesUrl: undefined,
	25	otlpMetricsUrl: undefined,
	26	otlpExportIntervalMs: 10_000,
	27	otlpServiceName: "t3-server",
	28	cwd: process.cwd(),
	29	baseDir,
	30	mode: "web",
	31	autoBootstrapProjectFromCwd: false,
	32	logWebSocketEvents: false,
	33	port: 0,
	34	host: undefined,
	35	authToken: undefined,
	36	staticDir: undefined,
	37	devUrl: undefined,
	38	noBrowser: false,
	39	} satisfies ServerConfigShape;
	40	});
	41
	42	it.layer(NodeServices.layer)("ServerEnvironmentLive", (it) => {
	43	it.effect("persists the environment id across service restarts", () =>
	44	Effect.gen(function* () {
	45	const fileSystem = yield* FileSystem.FileSystem;
	46	const baseDir = yield* fileSystem.makeTempDirectoryScoped({
	47	prefix: "t3-server-environment-test-",
	48	});
	49
	50	const first = yield* Effect.gen(function* () {
	51	const serverEnvironment = yield* ServerEnvironment;
	52	return yield* serverEnvironment.getDescriptor;
	53	}).pipe(Effect.provide(makeServerEnvironmentLayer(baseDir)));
	54	const second = yield* Effect.gen(function* () {
	55	const serverEnvironment = yield* ServerEnvironment;
	56	return yield* serverEnvironment.getDescriptor;
	57	}).pipe(Effect.provide(makeServerEnvironmentLayer(baseDir)));
	58
	59	expect(first.environmentId).toBe(second.environmentId);
	60	expect(second.capabilities.repositoryIdentity).toBe(true);
	61	}),
	62	);
	63
	64	it.effect("fails instead of overwriting a persisted id when reading the file errors", () =>
	65	Effect.gen(function* () {
	66	const fileSystem = yield* FileSystem.FileSystem;
	67	const baseDir = yield* fileSystem.makeTempDirectoryScoped({
	68	prefix: "t3-server-environment-read-error-test-",
	69	});
	70	const serverConfig = yield* makeServerConfig(baseDir);
	71	const environmentIdPath = serverConfig.environmentIdPath;
	72	yield* fileSystem.makeDirectory(nodePath.dirname(environmentIdPath), { recursive: true });
	73	yield* fileSystem.writeFileString(environmentIdPath, "persisted-environment-id\n");
	74	const writeAttempts: string[] = [];
	75	const failingFileSystemLayer = FileSystem.layerNoop({
	76	exists: (path) => Effect.succeed(path === environmentIdPath),
	77	readFileString: (path) =>
	78	path === environmentIdPath
	79	? Effect.fail(
	80	PlatformError.systemError({
	81	_tag: "PermissionDenied",
	82	module: "FileSystem",
	83	method: "readFileString",
	84	description: "permission denied",
	85	pathOrDescriptor: path,
	86	}),
	87	)
	88	: Effect.fail(
	89	PlatformError.systemError({
	90	_tag: "NotFound",
	91	module: "FileSystem",
	92	method: "readFileString",
	93	description: "not found",
	94	pathOrDescriptor: path,
	95	}),
	96	),
	97	writeFileString: (path) => {
	98	writeAttempts.push(path);
	99	return Effect.void;
	100	},
	101	});
	102
	103	const exit = yield* Effect.gen(function* () {
	104	const serverEnvironment = yield* ServerEnvironment;
	105	return yield* serverEnvironment.getDescriptor;
	106	}).pipe(
	107	Effect.provide(
	108	ServerEnvironmentLive.pipe(
	109	Layer.provide(
	110	Layer.merge(Layer.succeed(ServerConfig, serverConfig), failingFileSystemLayer),
	111	),
	112	),
	113	),
	114	Effect.exit,
	115	);
	116
	117	expect(Exit.isFailure(exit)).toBe(true);
	118	expect(writeAttempts).toEqual([]);
	119	expect(yield* fileSystem.readFileString(environmentIdPath)).toBe(
	120	"persisted-environment-id\n",
	121	);
	122	}),
	123	);
	124	});

apps/server/src/environment/Layers/ServerEnvironment.ts+94−0

@@ -0,0 +1,94 @@
	1	import { EnvironmentId, type ExecutionEnvironmentDescriptor } from "@t3tools/contracts";
	2	import { Effect, FileSystem, Layer, Path, Random } from "effect";
	3
	4	import { ServerConfig } from "../../config.ts";
	5	import { ServerEnvironment, type ServerEnvironmentShape } from "../Services/ServerEnvironment.ts";
	6	import { version } from "../../../package.json" with { type: "json" };
	7
	8	function platformOs(): ExecutionEnvironmentDescriptor["platform"]["os"] {
	9	switch (process.platform) {
	10	case "darwin":
	11	return "darwin";
	12	case "linux":
	13	return "linux";
	14	case "win32":
	15	return "windows";
	16	default:
	17	return "unknown";
	18	}
	19	}
	20
	21	function platformArch(): ExecutionEnvironmentDescriptor["platform"]["arch"] {
	22	switch (process.arch) {
	23	case "arm64":
	24	return "arm64";
	25	case "x64":
	26	return "x64";
	27	default:
	28	return "other";
	29	}
	30	}
	31
	32	export const makeServerEnvironment = Effect.fn("makeServerEnvironment")(function* () {
	33	const fileSystem = yield* FileSystem.FileSystem;
	34	const path = yield* Path.Path;
	35	const serverConfig = yield* ServerConfig;
	36
	37	const readPersistedEnvironmentId = Effect.gen(function* () {
	38	const exists = yield* fileSystem
	39	.exists(serverConfig.environmentIdPath)
	40	.pipe(Effect.orElseSucceed(() => false));
	41	if (!exists) {
	42	return null;
	43	}
	44
	45	const raw = yield* fileSystem
	46	.readFileString(serverConfig.environmentIdPath)
	47	.pipe(Effect.map((value) => value.trim()));
	48
	49	return raw.length > 0 ? raw : null;
	50	});
	51
	52	const persistEnvironmentId = (value: string) =>
	53	fileSystem.writeFileString(serverConfig.environmentIdPath, `${value}\n`);
	54
	55	const environmentIdRaw = yield* Effect.gen(function* () {
	56	const persisted = yield* readPersistedEnvironmentId;
	57	if (persisted) {
	58	return persisted;
	59	}
	60
	61	const generated = yield* Random.nextUUIDv4;
	62	yield* persistEnvironmentId(generated);
	63	return generated;
	64	});
	65
	66	const environmentId = EnvironmentId.makeUnsafe(environmentIdRaw);
	67	const cwdBaseName = path.basename(serverConfig.cwd).trim();
	68	const label =
	69	serverConfig.mode === "desktop"
	70	? "Local environment"
	71	: cwdBaseName.length > 0
	72	? cwdBaseName
	73	: "T3 environment";
	74
	75	const descriptor: ExecutionEnvironmentDescriptor = {
	76	environmentId,
	77	label,
	78	platform: {
	79	os: platformOs(),
	80	arch: platformArch(),
	81	},
	82	serverVersion: version,
	83	capabilities: {
	84	repositoryIdentity: true,
	85	},
	86	};
	87
	88	return {
	89	getEnvironmentId: Effect.succeed(environmentId),
	90	getDescriptor: Effect.succeed(descriptor),
	91	} satisfies ServerEnvironmentShape;
	92	});
	93
	94	export const ServerEnvironmentLive = Layer.effect(ServerEnvironment, makeServerEnvironment());

apps/server/src/environment/Services/ServerEnvironment.ts+13−0

@@ -0,0 +1,13 @@
	1	import type { EnvironmentId, ExecutionEnvironmentDescriptor } from "@t3tools/contracts";
	2	import { ServiceMap } from "effect";
	3	import type { Effect } from "effect";
	4
	5	export interface ServerEnvironmentShape {
	6	readonly getEnvironmentId: Effect.Effect<EnvironmentId>;
	7	readonly getDescriptor: Effect.Effect<ExecutionEnvironmentDescriptor>;
	8	}
	9
	10	export class ServerEnvironment extends ServiceMap.Service<
	11	ServerEnvironment,
	12	ServerEnvironmentShape
	13	>()("t3/environment/Services/ServerEnvironment") {}

apps/server/src/git/Layers/GitManager.test.ts+3−3

@@ -854,7 +854,7 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => { · 853 unmodified lines
854	"pr list --head jasonLaster:statemachine --state all --limit 20 --json number,title,url,baseRefName,headRefName,state,mergedAt,updatedAt,isCrossRepository,headRepository,headRepositoryOwner",	854	"pr list --head jasonLaster:statemachine --state all --limit 20 --json number,title,url,baseRefName,headRefName,state,mergedAt,updatedAt,isCrossRepository,headRepository,headRepositoryOwner",
855	);	855	);
856	}),	856	}),
857	12_000,	857	20_000,
858	);	858	);
859		859
860	it.effect(	860	it.effect(
@@ -962,7 +962,7 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => { · 101 unmodified lines
962	),	962	),
963	).toBe(false);	963	).toBe(false);
964	}),	964	}),
965	12_000,	965	20_000,
966	);	966	);
967		967
968	it.effect("status returns merged PR state when latest PR was merged", () =>	968	it.effect("status returns merged PR state when latest PR was merged", () =>
@@ -1685,7 +1685,7 @@ it.layer(GitManagerTestLayer)("GitManager", (it) => { · 716 unmodified lines
1685	false,	1685	false,
1686	);	1686	);
1687	}),	1687	}),
1688	12_000,	1688	20_000,
1689	);	1689	);
1690		1690
1691	it.effect(	1691	it.effect(

apps/server/src/orchestration/Layers/CheckpointReactor.test.ts+2−0

 import { CheckpointStoreLive } from "../../checkpointing/Layers/CheckpointStore.ts";
 import { CheckpointStore } from "../../checkpointing/Services/CheckpointStore.ts";
 import { GitCoreLive } from "../../git/Layers/GitCore.ts";
+import { RepositoryIdentityResolverLive } from "../../project/Layers/RepositoryIdentityResolver.ts";
 import { CheckpointReactorLive } from "./CheckpointReactor.ts";
 import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
 import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
       Layer.provide(OrchestrationProjectionPipelineLive),
       Layer.provide(OrchestrationEventStoreLive),
       Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+      Layer.provide(RepositoryIdentityResolverLive),
       Layer.provide(SqlitePersistenceMemory),
     );

apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts+5−0

   OrchestrationEventStore,
   type OrchestrationEventStoreShape,
 } from "../../persistence/Services/OrchestrationEventStore.ts";
+import { RepositoryIdentityResolverLive } from "../../project/Layers/RepositoryIdentityResolver.ts";
 import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
 import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
 import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts";
     Layer.provide(OrchestrationProjectionPipelineLive),
     Layer.provide(OrchestrationEventStoreLive),
     Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+    Layer.provide(RepositoryIdentityResolverLive),
     Layer.provide(SqlitePersistenceMemory),
     Layer.provideMerge(ServerConfigLayer),
     Layer.provideMerge(NodeServices.layer),
         Layer.provide(OrchestrationProjectionPipelineLive),
         Layer.provide(Layer.succeed(OrchestrationEventStore, flakyStore)),
         Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+        Layer.provide(RepositoryIdentityResolverLive),
         Layer.provide(SqlitePersistenceMemory),
         Layer.provideMerge(ServerConfigLayer),
         Layer.provideMerge(NodeServices.layer),
         Layer.provide(Layer.succeed(OrchestrationProjectionPipeline, flakyProjectionPipeline)),
         Layer.provide(OrchestrationEventStoreLive),
         Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+        Layer.provide(RepositoryIdentityResolverLive),
         Layer.provide(SqlitePersistenceMemory),
       ),
     );
         Layer.provide(Layer.succeed(OrchestrationProjectionPipeline, flakyProjectionPipeline)),
         Layer.provide(Layer.succeed(OrchestrationEventStore, nonTransactionalStore)),
         Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+        Layer.provide(RepositoryIdentityResolverLive),
         Layer.provide(SqlitePersistenceMemory),
       ),
     );

apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts+2−0

   SqlitePersistenceMemory,
 } from "../../persistence/Layers/Sqlite.ts";
 import { OrchestrationEventStore } from "../../persistence/Services/OrchestrationEventStore.ts";
+import { RepositoryIdentityResolverLive } from "../../project/Layers/RepositoryIdentityResolver.ts";
 import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
 import {
   ORCHESTRATION_PROJECTOR_NAMES,
     Layer.provide(OrchestrationProjectionPipelineLive),
     Layer.provide(OrchestrationEventStoreLive),
     Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+    Layer.provide(RepositoryIdentityResolverLive),
     Layer.provideMerge(SqlitePersistenceMemory),
     Layer.provideMerge(
       ServerConfig.layerTest(process.cwd(), {

apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts+6−1

 import * as SqlClient from "effect/unstable/sql/SqlClient";
 import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";
+import { RepositoryIdentityResolverLive } from "../../project/Layers/RepositoryIdentityResolver.ts";
 import { ORCHESTRATION_PROJECTOR_NAMES } from "./ProjectionPipeline.ts";
 import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts";
 import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts";
 const asCheckpointRef = (value: string): CheckpointRef => CheckpointRef.makeUnsafe(value);
 const projectionSnapshotLayer = it.layer(
-  OrchestrationProjectionSnapshotQueryLive.pipe(Layer.provideMerge(SqlitePersistenceMemory)),
+  OrchestrationProjectionSnapshotQueryLive.pipe(
+    Layer.provideMerge(RepositoryIdentityResolverLive),
+    Layer.provideMerge(SqlitePersistenceMemory),
+  ),
 );
 projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
           id: asProjectId("project-1"),
           title: "Project 1",
           workspaceRoot: "/tmp/project-1",
+          repositoryIdentity: null,
           defaultModelSelection: {
             provider: "codex",
             model: "gpt-5-codex",

apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts+278−256

@@ -38,6 +38,7 @@ import { ProjectionThreadMessage } from "../../persistence/Services/ProjectionTh · 37 unmodified lines
38	import { ProjectionThreadProposedPlan } from "../../persistence/Services/ProjectionThreadProposedPlans.ts";	38	import { ProjectionThreadProposedPlan } from "../../persistence/Services/ProjectionThreadProposedPlans.ts";
39	import { ProjectionThreadSession } from "../../persistence/Services/ProjectionThreadSessions.ts";	39	import { ProjectionThreadSession } from "../../persistence/Services/ProjectionThreadSessions.ts";
40	import { ProjectionThread } from "../../persistence/Services/ProjectionThreads.ts";	40	import { ProjectionThread } from "../../persistence/Services/ProjectionThreads.ts";
		41	import { RepositoryIdentityResolver } from "../../project/Services/RepositoryIdentityResolver.ts";
41	import { ORCHESTRATION_PROJECTOR_NAMES } from "./ProjectionPipeline.ts";	42	import { ORCHESTRATION_PROJECTOR_NAMES } from "./ProjectionPipeline.ts";
42	import {	43	import {
43	ProjectionSnapshotQuery,	44	ProjectionSnapshotQuery,
@@ -163,6 +164,8 @@ function toPersistenceSqlOrDecodeError(sqlOperation: string, decodeOperation: st · 119 unmodified lines
163		164
164	const makeProjectionSnapshotQuery = Effect.gen(function* () {	165	const makeProjectionSnapshotQuery = Effect.gen(function* () {
165	const sql = yield* SqlClient.SqlClient;	166	const sql = yield* SqlClient.SqlClient;
		167	const repositoryIdentityResolver = yield* RepositoryIdentityResolver;
		168	const repositoryIdentityResolutionConcurrency = 4;
166		169
167	const listProjectRows = SqlSchema.findAll({	170	const listProjectRows = SqlSchema.findAll({
168	Request: Schema.Void,	171	Request: Schema.Void,
@@ -436,269 +439,283 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { · 267 unmodified lines
436	const getSnapshot: ProjectionSnapshotQueryShape["getSnapshot"] = () =>	439	const getSnapshot: ProjectionSnapshotQueryShape["getSnapshot"] = () =>
437	sql	440	sql
438	.withTransaction(	441	.withTransaction(
439	Effect.gen(function* () {	442	Effect.all([
440	const [	443	listProjectRows(undefined).pipe(
441	projectRows,	444	Effect.mapError(
442	threadRows,	445	toPersistenceSqlOrDecodeError(
443	messageRows,	446	"ProjectionSnapshotQuery.getSnapshot:listProjects:query",
444	proposedPlanRows,	447	"ProjectionSnapshotQuery.getSnapshot:listProjects:decodeRows",
445	activityRows,
446	sessionRows,
447	checkpointRows,
448	latestTurnRows,
449	stateRows,
450	] = yield* Effect.all([
451	listProjectRows(undefined).pipe(
452	Effect.mapError(
453	toPersistenceSqlOrDecodeError(
454	"ProjectionSnapshotQuery.getSnapshot:listProjects:query",
455	"ProjectionSnapshotQuery.getSnapshot:listProjects:decodeRows",
456	),
457	),
458	),
459	listThreadRows(undefined).pipe(
460	Effect.mapError(
461	toPersistenceSqlOrDecodeError(
462	"ProjectionSnapshotQuery.getSnapshot:listThreads:query",
463	"ProjectionSnapshotQuery.getSnapshot:listThreads:decodeRows",
464	),
465	),	448	),
466	),	449	),
467	listThreadMessageRows(undefined).pipe(	450	),
468	Effect.mapError(	451	listThreadRows(undefined).pipe(
469	toPersistenceSqlOrDecodeError(	452	Effect.mapError(
470	"ProjectionSnapshotQuery.getSnapshot:listThreadMessages:query",	453	toPersistenceSqlOrDecodeError(
471	"ProjectionSnapshotQuery.getSnapshot:listThreadMessages:decodeRows",	454	"ProjectionSnapshotQuery.getSnapshot:listThreads:query",
472	),	455	"ProjectionSnapshotQuery.getSnapshot:listThreads:decodeRows",
473	),	456	),
474	),	457	),
475	listThreadProposedPlanRows(undefined).pipe(	458	),
476	Effect.mapError(	459	listThreadMessageRows(undefined).pipe(
477	toPersistenceSqlOrDecodeError(	460	Effect.mapError(
478	"ProjectionSnapshotQuery.getSnapshot:listThreadProposedPlans:query",	461	toPersistenceSqlOrDecodeError(
479	"ProjectionSnapshotQuery.getSnapshot:listThreadProposedPlans:decodeRows",	462	"ProjectionSnapshotQuery.getSnapshot:listThreadMessages:query",
480	),	463	"ProjectionSnapshotQuery.getSnapshot:listThreadMessages:decodeRows",
481	),	464	),
482	),	465	),
483	listThreadActivityRows(undefined).pipe(	466	),
484	Effect.mapError(	467	listThreadProposedPlanRows(undefined).pipe(
485	toPersistenceSqlOrDecodeError(	468	Effect.mapError(
486	"ProjectionSnapshotQuery.getSnapshot:listThreadActivities:query",	469	toPersistenceSqlOrDecodeError(
487	"ProjectionSnapshotQuery.getSnapshot:listThreadActivities:decodeRows",	470	"ProjectionSnapshotQuery.getSnapshot:listThreadProposedPlans:query",
488	),	471	"ProjectionSnapshotQuery.getSnapshot:listThreadProposedPlans:decodeRows",
489	),	472	),
490	),	473	),
491	listThreadSessionRows(undefined).pipe(	474	),
492	Effect.mapError(	475	listThreadActivityRows(undefined).pipe(
493	toPersistenceSqlOrDecodeError(	476	Effect.mapError(
494	"ProjectionSnapshotQuery.getSnapshot:listThreadSessions:query",	477	toPersistenceSqlOrDecodeError(
495	"ProjectionSnapshotQuery.getSnapshot:listThreadSessions:decodeRows",	478	"ProjectionSnapshotQuery.getSnapshot:listThreadActivities:query",
496	),	479	"ProjectionSnapshotQuery.getSnapshot:listThreadActivities:decodeRows",
497	),	480	),
498	),	481	),
499	listCheckpointRows(undefined).pipe(	482	),
500	Effect.mapError(	483	listThreadSessionRows(undefined).pipe(
501	toPersistenceSqlOrDecodeError(	484	Effect.mapError(
502	"ProjectionSnapshotQuery.getSnapshot:listCheckpoints:query",	485	toPersistenceSqlOrDecodeError(
503	"ProjectionSnapshotQuery.getSnapshot:listCheckpoints:decodeRows",	486	"ProjectionSnapshotQuery.getSnapshot:listThreadSessions:query",
504	),	487	"ProjectionSnapshotQuery.getSnapshot:listThreadSessions:decodeRows",
505	),	488	),
506	),	489	),
507	listLatestTurnRows(undefined).pipe(	490	),
508	Effect.mapError(	491	listCheckpointRows(undefined).pipe(
509	toPersistenceSqlOrDecodeError(	492	Effect.mapError(
510	"ProjectionSnapshotQuery.getSnapshot:listLatestTurns:query",	493	toPersistenceSqlOrDecodeError(
511	"ProjectionSnapshotQuery.getSnapshot:listLatestTurns:decodeRows",	494	"ProjectionSnapshotQuery.getSnapshot:listCheckpoints:query",
512	),	495	"ProjectionSnapshotQuery.getSnapshot:listCheckpoints:decodeRows",
513	),	496	),
514	),	497	),
515	listProjectionStateRows(undefined).pipe(	498	),
516	Effect.mapError(	499	listLatestTurnRows(undefined).pipe(
517	toPersistenceSqlOrDecodeError(	500	Effect.mapError(
518	"ProjectionSnapshotQuery.getSnapshot:listProjectionState:query",	501	toPersistenceSqlOrDecodeError(
519	"ProjectionSnapshotQuery.getSnapshot:listProjectionState:decodeRows",	502	"ProjectionSnapshotQuery.getSnapshot:listLatestTurns:query",
520	),	503	"ProjectionSnapshotQuery.getSnapshot:listLatestTurns:decodeRows",
521	),	504	),
522	),	505	),
523	]);	506	),
524		507	listProjectionStateRows(undefined).pipe(
525	const messagesByThread = new Map<string, Array<OrchestrationMessage>>();
526	const proposedPlansByThread = new Map<string, Array<OrchestrationProposedPlan>>();
527	const activitiesByThread = new Map<string, Array<OrchestrationThreadActivity>>();
528	const checkpointsByThread = new Map<string, Array<OrchestrationCheckpointSummary>>();
529	const sessionsByThread = new Map<string, OrchestrationSession>();
530	const latestTurnByThread = new Map<string, OrchestrationLatestTurn>();
531
532	let updatedAt: string \| null = null;
533
534	for (const row of projectRows) {
535	updatedAt = maxIso(updatedAt, row.updatedAt);
536	}
537	for (const row of threadRows) {
538	updatedAt = maxIso(updatedAt, row.updatedAt);
539	}
540	for (const row of stateRows) {
541	updatedAt = maxIso(updatedAt, row.updatedAt);
542	}
543
544	for (const row of messageRows) {
545	updatedAt = maxIso(updatedAt, row.updatedAt);
546	const threadMessages = messagesByThread.get(row.threadId) ?? [];
547	threadMessages.push({
548	id: row.messageId,
549	role: row.role,
550	text: row.text,
551	...(row.attachments !== null ? { attachments: row.attachments } : {}),
552	turnId: row.turnId,
553	streaming: row.isStreaming === 1,
554	createdAt: row.createdAt,
555	updatedAt: row.updatedAt,
556	});
557	messagesByThread.set(row.threadId, threadMessages);
558	}
559
560	for (const row of proposedPlanRows) {
561	updatedAt = maxIso(updatedAt, row.updatedAt);
562	const threadProposedPlans = proposedPlansByThread.get(row.threadId) ?? [];
563	threadProposedPlans.push({
564	id: row.planId,
565	turnId: row.turnId,
566	planMarkdown: row.planMarkdown,
567	implementedAt: row.implementedAt,
568	implementationThreadId: row.implementationThreadId,
569	createdAt: row.createdAt,
570	updatedAt: row.updatedAt,
571	});
572	proposedPlansByThread.set(row.threadId, threadProposedPlans);
573	}
574
575	for (const row of activityRows) {
576	updatedAt = maxIso(updatedAt, row.createdAt);
577	const threadActivities = activitiesByThread.get(row.threadId) ?? [];
578	threadActivities.push({
579	id: row.activityId,
580	tone: row.tone,
581	kind: row.kind,
582	summary: row.summary,
583	payload: row.payload,
584	turnId: row.turnId,
585	...(row.sequence !== null ? { sequence: row.sequence } : {}),
586	createdAt: row.createdAt,
587	});
588	activitiesByThread.set(row.threadId, threadActivities);
589	}
590
591	for (const row of checkpointRows) {
592	updatedAt = maxIso(updatedAt, row.completedAt);
593	const threadCheckpoints = checkpointsByThread.get(row.threadId) ?? [];
594	threadCheckpoints.push({
595	turnId: row.turnId,
596	checkpointTurnCount: row.checkpointTurnCount,
597	checkpointRef: row.checkpointRef,
598	status: row.status,
599	files: row.files,
600	assistantMessageId: row.assistantMessageId,
601	completedAt: row.completedAt,
602	});
603	checkpointsByThread.set(row.threadId, threadCheckpoints);
604	}
605
606	for (const row of latestTurnRows) {
607	updatedAt = maxIso(updatedAt, row.requestedAt);
608	if (row.startedAt !== null) {
609	updatedAt = maxIso(updatedAt, row.startedAt);
610	}
611	if (row.completedAt !== null) {
612	updatedAt = maxIso(updatedAt, row.completedAt);
613	}
614	if (latestTurnByThread.has(row.threadId)) {
615	continue;
616	}
617	latestTurnByThread.set(row.threadId, {
618	turnId: row.turnId,
619	state:
620	row.state === "error"
621	? "error"
622	: row.state === "interrupted"
623	? "interrupted"
624	: row.state === "completed"
625	? "completed"
626	: "running",
627	requestedAt: row.requestedAt,
628	startedAt: row.startedAt,
629	completedAt: row.completedAt,
630	assistantMessageId: row.assistantMessageId,
631	...(row.sourceProposedPlanThreadId !== null && row.sourceProposedPlanId !== null
632	? {
633	sourceProposedPlan: {
634	threadId: row.sourceProposedPlanThreadId,
635	planId: row.sourceProposedPlanId,
636	},
637	}
638	: {}),
639	});
640	}
641
642	for (const row of sessionRows) {
643	updatedAt = maxIso(updatedAt, row.updatedAt);
644	sessionsByThread.set(row.threadId, {
645	threadId: row.threadId,
646	status: row.status,
647	providerName: row.providerName,
648	runtimeMode: row.runtimeMode,
649	activeTurnId: row.activeTurnId,
650	lastError: row.lastError,
651	updatedAt: row.updatedAt,
652	});
653	}
654
655	const projects: ReadonlyArray<OrchestrationProject> = projectRows.map((row) => ({
656	id: row.projectId,
657	title: row.title,
658	workspaceRoot: row.workspaceRoot,
659	defaultModelSelection: row.defaultModelSelection,
660	scripts: row.scripts,
661	createdAt: row.createdAt,
662	updatedAt: row.updatedAt,
663	deletedAt: row.deletedAt,
664	}));
665
666	const threads: ReadonlyArray<OrchestrationThread> = threadRows.map((row) => ({
667	id: row.threadId,
668	projectId: row.projectId,
669	title: row.title,
670	modelSelection: row.modelSelection,
671	runtimeMode: row.runtimeMode,
672	interactionMode: row.interactionMode,
673	branch: row.branch,
674	worktreePath: row.worktreePath,
675	latestTurn: latestTurnByThread.get(row.threadId) ?? null,
676	createdAt: row.createdAt,
677	updatedAt: row.updatedAt,
678	archivedAt: row.archivedAt,
679	deletedAt: row.deletedAt,
680	messages: messagesByThread.get(row.threadId) ?? [],
681	proposedPlans: proposedPlansByThread.get(row.threadId) ?? [],
682	activities: activitiesByThread.get(row.threadId) ?? [],
683	checkpoints: checkpointsByThread.get(row.threadId) ?? [],
684	session: sessionsByThread.get(row.threadId) ?? null,
685	}));
686
687	const snapshot = {
688	snapshotSequence: computeSnapshotSequence(stateRows),
689	projects,
690	threads,
691	updatedAt: updatedAt ?? new Date(0).toISOString(),
692	};
693
694	return yield* decodeReadModel(snapshot).pipe(
695	Effect.mapError(	508	Effect.mapError(
696	toPersistenceDecodeError("ProjectionSnapshotQuery.getSnapshot:decodeReadModel"),	509	toPersistenceSqlOrDecodeError(
		510	"ProjectionSnapshotQuery.getSnapshot:listProjectionState:query",
		511	"ProjectionSnapshotQuery.getSnapshot:listProjectionState:decodeRows",
		512	),
697	),	513	),
698	);	514	),
699	}),	515	]),
700	)	516	)
701	.pipe(	517	.pipe(
		518	Effect.flatMap(
		519	([
		520	projectRows,
		521	threadRows,
		522	messageRows,
		523	proposedPlanRows,
		524	activityRows,
		525	sessionRows,
		526	checkpointRows,
		527	latestTurnRows,
		528	stateRows,
		529	]) =>
		530	Effect.gen(function* () {
		531	const messagesByThread = new Map<string, Array<OrchestrationMessage>>();
		532	const proposedPlansByThread = new Map<string, Array<OrchestrationProposedPlan>>();
		533	const activitiesByThread = new Map<string, Array<OrchestrationThreadActivity>>();
		534	const checkpointsByThread = new Map<string, Array<OrchestrationCheckpointSummary>>();
		535	const sessionsByThread = new Map<string, OrchestrationSession>();
		536	const latestTurnByThread = new Map<string, OrchestrationLatestTurn>();
		537
		538	let updatedAt: string \| null = null;
		539
		540	for (const row of projectRows) {
		541	updatedAt = maxIso(updatedAt, row.updatedAt);
		542	}
		543	for (const row of threadRows) {
		544	updatedAt = maxIso(updatedAt, row.updatedAt);
		545	}
		546	for (const row of stateRows) {
		547	updatedAt = maxIso(updatedAt, row.updatedAt);
		548	}
		549
		550	for (const row of messageRows) {
		551	updatedAt = maxIso(updatedAt, row.updatedAt);
		552	const threadMessages = messagesByThread.get(row.threadId) ?? [];
		553	threadMessages.push({
		554	id: row.messageId,
		555	role: row.role,
		556	text: row.text,
		557	...(row.attachments !== null ? { attachments: row.attachments } : {}),
		558	turnId: row.turnId,
		559	streaming: row.isStreaming === 1,
		560	createdAt: row.createdAt,
		561	updatedAt: row.updatedAt,
		562	});
		563	messagesByThread.set(row.threadId, threadMessages);
		564	}
		565
		566	for (const row of proposedPlanRows) {
		567	updatedAt = maxIso(updatedAt, row.updatedAt);
		568	const threadProposedPlans = proposedPlansByThread.get(row.threadId) ?? [];
		569	threadProposedPlans.push({
		570	id: row.planId,
		571	turnId: row.turnId,
		572	planMarkdown: row.planMarkdown,
		573	implementedAt: row.implementedAt,
		574	implementationThreadId: row.implementationThreadId,
		575	createdAt: row.createdAt,
		576	updatedAt: row.updatedAt,
		577	});
		578	proposedPlansByThread.set(row.threadId, threadProposedPlans);
		579	}
		580
		581	for (const row of activityRows) {
		582	updatedAt = maxIso(updatedAt, row.createdAt);
		583	const threadActivities = activitiesByThread.get(row.threadId) ?? [];
		584	threadActivities.push({
		585	id: row.activityId,
		586	tone: row.tone,
		587	kind: row.kind,
		588	summary: row.summary,
		589	payload: row.payload,
		590	turnId: row.turnId,
		591	...(row.sequence !== null ? { sequence: row.sequence } : {}),
		592	createdAt: row.createdAt,
		593	});
		594	activitiesByThread.set(row.threadId, threadActivities);
		595	}
		596
		597	for (const row of checkpointRows) {
		598	updatedAt = maxIso(updatedAt, row.completedAt);
		599	const threadCheckpoints = checkpointsByThread.get(row.threadId) ?? [];
		600	threadCheckpoints.push({
		601	turnId: row.turnId,
		602	checkpointTurnCount: row.checkpointTurnCount,
		603	checkpointRef: row.checkpointRef,
		604	status: row.status,
		605	files: row.files,
		606	assistantMessageId: row.assistantMessageId,
		607	completedAt: row.completedAt,
		608	});
		609	checkpointsByThread.set(row.threadId, threadCheckpoints);
		610	}
		611
		612	for (const row of latestTurnRows) {
		613	updatedAt = maxIso(updatedAt, row.requestedAt);
		614	if (row.startedAt !== null) {
		615	updatedAt = maxIso(updatedAt, row.startedAt);
		616	}
		617	if (row.completedAt !== null) {
		618	updatedAt = maxIso(updatedAt, row.completedAt);
		619	}
		620	if (latestTurnByThread.has(row.threadId)) {
		621	continue;
		622	}
		623	latestTurnByThread.set(row.threadId, {
		624	turnId: row.turnId,
		625	state:
		626	row.state === "error"
		627	? "error"
		628	: row.state === "interrupted"
		629	? "interrupted"
		630	: row.state === "completed"
		631	? "completed"
		632	: "running",
		633	requestedAt: row.requestedAt,
		634	startedAt: row.startedAt,
		635	completedAt: row.completedAt,
		636	assistantMessageId: row.assistantMessageId,
		637	...(row.sourceProposedPlanThreadId !== null && row.sourceProposedPlanId !== null
		638	? {
		639	sourceProposedPlan: {
		640	threadId: row.sourceProposedPlanThreadId,
		641	planId: row.sourceProposedPlanId,
		642	},
		643	}
		644	: {}),
		645	});
		646	}
		647
		648	for (const row of sessionRows) {
		649	updatedAt = maxIso(updatedAt, row.updatedAt);
		650	sessionsByThread.set(row.threadId, {
		651	threadId: row.threadId,
		652	status: row.status,
		653	providerName: row.providerName,
		654	runtimeMode: row.runtimeMode,
		655	activeTurnId: row.activeTurnId,
		656	lastError: row.lastError,
		657	updatedAt: row.updatedAt,
		658	});
		659	}
		660
		661	const repositoryIdentities = new Map(
		662	yield* Effect.forEach(
		663	projectRows,
		664	(row) =>
		665	repositoryIdentityResolver
		666	.resolve(row.workspaceRoot)
		667	.pipe(Effect.map((identity) => [row.projectId, identity] as const)),
		668	{ concurrency: repositoryIdentityResolutionConcurrency },
		669	),
		670	);
		671
		672	const projects: ReadonlyArray<OrchestrationProject> = projectRows.map((row) => ({
		673	id: row.projectId,
		674	title: row.title,
		675	workspaceRoot: row.workspaceRoot,
		676	repositoryIdentity: repositoryIdentities.get(row.projectId) ?? null,
		677	defaultModelSelection: row.defaultModelSelection,
		678	scripts: row.scripts,
		679	createdAt: row.createdAt,
		680	updatedAt: row.updatedAt,
		681	deletedAt: row.deletedAt,
		682	}));
		683
		684	const threads: ReadonlyArray<OrchestrationThread> = threadRows.map((row) => ({
		685	id: row.threadId,
		686	projectId: row.projectId,
		687	title: row.title,
		688	modelSelection: row.modelSelection,
		689	runtimeMode: row.runtimeMode,
		690	interactionMode: row.interactionMode,
		691	branch: row.branch,
		692	worktreePath: row.worktreePath,
		693	latestTurn: latestTurnByThread.get(row.threadId) ?? null,
		694	createdAt: row.createdAt,
		695	updatedAt: row.updatedAt,
		696	archivedAt: row.archivedAt,
		697	deletedAt: row.deletedAt,
		698	messages: messagesByThread.get(row.threadId) ?? [],
		699	proposedPlans: proposedPlansByThread.get(row.threadId) ?? [],
		700	activities: activitiesByThread.get(row.threadId) ?? [],
		701	checkpoints: checkpointsByThread.get(row.threadId) ?? [],
		702	session: sessionsByThread.get(row.threadId) ?? null,
		703	}));
		704
		705	const snapshot = {
		706	snapshotSequence: computeSnapshotSequence(stateRows),
		707	projects,
		708	threads,
		709	updatedAt: updatedAt ?? new Date(0).toISOString(),
		710	};
		711
		712	return yield* decodeReadModel(snapshot).pipe(
		713	Effect.mapError(
		714	toPersistenceDecodeError("ProjectionSnapshotQuery.getSnapshot:decodeReadModel"),
		715	),
		716	);
		717	}),
		718	),
702	Effect.mapError((error) => {	719	Effect.mapError((error) => {
703	if (isPersistenceError(error)) {	720	if (isPersistenceError(error)) {
704	return error;	721	return error;
@@ -732,19 +749,24 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { · 27 unmodified lines
732	"ProjectionSnapshotQuery.getActiveProjectByWorkspaceRoot:decodeRow",	749	"ProjectionSnapshotQuery.getActiveProjectByWorkspaceRoot:decodeRow",
733	),	750	),
734	),	751	),
735	Effect.map(	752	Effect.flatMap((option) =>
736	Option.map(	753	Option.isNone(option)
737	(row): OrchestrationProject => ({	754	? Effect.succeed(Option.none<OrchestrationProject>())
738	id: row.projectId,	755	: repositoryIdentityResolver.resolve(option.value.workspaceRoot).pipe(
739	title: row.title,	756	Effect.map((repositoryIdentity) =>
740	workspaceRoot: row.workspaceRoot,	757	Option.some({
741	defaultModelSelection: row.defaultModelSelection,	758	id: option.value.projectId,
742	scripts: row.scripts,	759	title: option.value.title,
743	createdAt: row.createdAt,	760	workspaceRoot: option.value.workspaceRoot,
744	updatedAt: row.updatedAt,	761	repositoryIdentity,
745	deletedAt: row.deletedAt,	762	defaultModelSelection: option.value.defaultModelSelection,
746	}),	763	scripts: option.value.scripts,
747	),	764	createdAt: option.value.createdAt,
		765	updatedAt: option.value.updatedAt,
		766	deletedAt: option.value.deletedAt,
		767	} satisfies OrchestrationProject),
		768	),
		769	),
748	),	770	),
749	);	771	);
750		772

apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts+2−0

 } from "../../provider/Services/ProviderService.ts";
 import { GitCore, type GitCoreShape } from "../../git/Services/GitCore.ts";
 import { TextGeneration, type TextGenerationShape } from "../../git/Services/TextGeneration.ts";
+import { RepositoryIdentityResolverLive } from "../../project/Layers/RepositoryIdentityResolver.ts";
 import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
 import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
 import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts";
       Layer.provide(OrchestrationProjectionPipelineLive),
       Layer.provide(OrchestrationEventStoreLive),
       Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+      Layer.provide(RepositoryIdentityResolverLive),
       Layer.provide(SqlitePersistenceMemory),
     );
     const layer = ProviderCommandReactorLive.pipe(

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts+2−0

   ProviderService,
   type ProviderServiceShape,
 } from "../../provider/Services/ProviderService.ts";
+import { RepositoryIdentityResolverLive } from "../../project/Layers/RepositoryIdentityResolver.ts";
 import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";
 import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts";
 import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts";
       Layer.provide(OrchestrationProjectionPipelineLive),
       Layer.provide(OrchestrationEventStoreLive),
       Layer.provide(OrchestrationCommandReceiptRepositoryLive),
+      Layer.provide(RepositoryIdentityResolverLive),
       Layer.provide(SqlitePersistenceMemory),
     );
     const layer = ProviderRuntimeIngestionLive.pipe(

apps/server/src/project/Layers/RepositoryIdentityResolver.test.ts+193−0

@@ -0,0 +1,193 @@
	1	import * as NodeServices from "@effect/platform-node/NodeServices";
	2	import { expect, it } from "@effect/vitest";
	3	import { Duration, Effect, FileSystem, Layer } from "effect";
	4	import { TestClock } from "effect/testing";
	5
	6	import { runProcess } from "../../processRunner.ts";
	7	import { RepositoryIdentityResolver } from "../Services/RepositoryIdentityResolver.ts";
	8	import {
	9	makeRepositoryIdentityResolver,
	10	RepositoryIdentityResolverLive,
	11	} from "./RepositoryIdentityResolver.ts";
	12
	13	const git = (cwd: string, args: ReadonlyArray<string>) =>
	14	Effect.promise(() => runProcess("git", ["-C", cwd, ...args]));
	15
	16	const makeRepositoryIdentityResolverTestLayer = (options: {
	17	readonly positiveCacheTtl?: Duration.Input;
	18	readonly negativeCacheTtl?: Duration.Input;
	19	}) =>
	20	Layer.effect(
	21	RepositoryIdentityResolver,
	22	makeRepositoryIdentityResolver({
	23	cacheCapacity: 16,
	24	...options,
	25	}),
	26	);
	27
	28	it.layer(NodeServices.layer)("RepositoryIdentityResolverLive", (it) => {
	29	it.effect("normalizes equivalent GitHub remotes into a stable repository identity", () =>
	30	Effect.gen(function* () {
	31	const fileSystem = yield* FileSystem.FileSystem;
	32	const cwd = yield* fileSystem.makeTempDirectoryScoped({
	33	prefix: "t3-repository-identity-test-",
	34	});
	35
	36	yield* git(cwd, ["init"]);
	37	yield* git(cwd, ["remote", "add", "origin", "git@github.com:T3Tools/t3code.git"]);
	38
	39	const resolver = yield* RepositoryIdentityResolver;
	40	const identity = yield* resolver.resolve(cwd);
	41
	42	expect(identity).not.toBeNull();
	43	expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code");
	44	expect(identity?.displayName).toBe("t3tools/t3code");
	45	expect(identity?.provider).toBe("github");
	46	expect(identity?.owner).toBe("t3tools");
	47	expect(identity?.name).toBe("t3code");
	48	}).pipe(Effect.provide(RepositoryIdentityResolverLive)),
	49	);
	50
	51	it.effect("returns null for non-git folders and repos without remotes", () =>
	52	Effect.gen(function* () {
	53	const fileSystem = yield* FileSystem.FileSystem;
	54	const nonGitDir = yield* fileSystem.makeTempDirectoryScoped({
	55	prefix: "t3-repository-identity-non-git-",
	56	});
	57	const gitDir = yield* fileSystem.makeTempDirectoryScoped({
	58	prefix: "t3-repository-identity-no-remote-",
	59	});
	60
	61	yield* git(gitDir, ["init"]);
	62
	63	const resolver = yield* RepositoryIdentityResolver;
	64	const nonGitIdentity = yield* resolver.resolve(nonGitDir);
	65	const noRemoteIdentity = yield* resolver.resolve(gitDir);
	66
	67	expect(nonGitIdentity).toBeNull();
	68	expect(noRemoteIdentity).toBeNull();
	69	}).pipe(Effect.provide(RepositoryIdentityResolverLive)),
	70	);
	71
	72	it.effect("prefers upstream over origin when both remotes are configured", () =>
	73	Effect.gen(function* () {
	74	const fileSystem = yield* FileSystem.FileSystem;
	75	const cwd = yield* fileSystem.makeTempDirectoryScoped({
	76	prefix: "t3-repository-identity-upstream-test-",
	77	});
	78
	79	yield* git(cwd, ["init"]);
	80	yield* git(cwd, ["remote", "add", "origin", "git@github.com:julius/t3code.git"]);
	81	yield* git(cwd, ["remote", "add", "upstream", "git@github.com:T3Tools/t3code.git"]);
	82
	83	const resolver = yield* RepositoryIdentityResolver;
	84	const identity = yield* resolver.resolve(cwd);
	85
	86	expect(identity).not.toBeNull();
	87	expect(identity?.locator.remoteName).toBe("upstream");
	88	expect(identity?.canonicalKey).toBe("github.com/t3tools/t3code");
	89	expect(identity?.displayName).toBe("t3tools/t3code");
	90	}).pipe(Effect.provide(RepositoryIdentityResolverLive)),
	91	);
	92
	93	it.effect("uses the last remote path segment as the repository name for nested groups", () =>
	94	Effect.gen(function* () {
	95	const fileSystem = yield* FileSystem.FileSystem;
	96	const cwd = yield* fileSystem.makeTempDirectoryScoped({
	97	prefix: "t3-repository-identity-nested-group-test-",
	98	});
	99
	100	yield* git(cwd, ["init"]);
	101	yield* git(cwd, ["remote", "add", "origin", "git@gitlab.com:T3Tools/platform/t3code.git"]);
	102
	103	const resolver = yield* RepositoryIdentityResolver;
	104	const identity = yield* resolver.resolve(cwd);
	105
	106	expect(identity).not.toBeNull();
	107	expect(identity?.canonicalKey).toBe("gitlab.com/t3tools/platform/t3code");
	108	expect(identity?.displayName).toBe("t3tools/platform/t3code");
	109	expect(identity?.owner).toBe("t3tools");
	110	expect(identity?.name).toBe("t3code");
	111	}).pipe(Effect.provide(RepositoryIdentityResolverLive)),
	112	);
	113
	114	it.effect(
	115	"refreshes cached null identities after the negative TTL when a remote is configured later",
	116	() =>
	117	Effect.gen(function* () {
	118	const fileSystem = yield* FileSystem.FileSystem;
	119	const cwd = yield* fileSystem.makeTempDirectoryScoped({
	120	prefix: "t3-repository-identity-late-remote-test-",
	121	});
	122
	123	yield* git(cwd, ["init"]);
	124
	125	const resolver = yield* RepositoryIdentityResolver;
	126	const initialIdentity = yield* resolver.resolve(cwd);
	127	expect(initialIdentity).toBeNull();
	128
	129	yield* git(cwd, ["remote", "add", "origin", "git@github.com:T3Tools/t3code.git"]);
	130
	131	const cachedIdentity = yield* resolver.resolve(cwd);
	132	expect(cachedIdentity).toBeNull();
	133
	134	yield* TestClock.adjust(Duration.millis(120));
	135
	136	const refreshedIdentity = yield* resolver.resolve(cwd);
	137	expect(refreshedIdentity).not.toBeNull();
	138	expect(refreshedIdentity?.canonicalKey).toBe("github.com/t3tools/t3code");
	139	expect(refreshedIdentity?.name).toBe("t3code");
	140	}).pipe(
	141	Effect.provide(
	142	Layer.merge(
	143	TestClock.layer(),
	144	makeRepositoryIdentityResolverTestLayer({
	145	negativeCacheTtl: Duration.millis(50),
	146	positiveCacheTtl: Duration.seconds(1),
	147	}),
	148	),
	149	),
	150	),
	151	);
	152
	153	it.effect("refreshes cached identities after the positive TTL when a remote changes", () =>
	154	Effect.gen(function* () {
	155	const fileSystem = yield* FileSystem.FileSystem;
	156	const cwd = yield* fileSystem.makeTempDirectoryScoped({
	157	prefix: "t3-repository-identity-remote-change-test-",
	158	});
	159
	160	yield* git(cwd, ["init"]);
	161	yield* git(cwd, ["remote", "add", "origin", "git@github.com:T3Tools/t3code.git"]);
	162
	163	const resolver = yield* RepositoryIdentityResolver;
	164	const initialIdentity = yield* resolver.resolve(cwd);
	165	expect(initialIdentity).not.toBeNull();
	166	expect(initialIdentity?.canonicalKey).toBe("github.com/t3tools/t3code");
	167
	168	yield* git(cwd, ["remote", "set-url", "origin", "git@github.com:T3Tools/t3code-next.git"]);
	169
	170	const cachedIdentity = yield* resolver.resolve(cwd);
	171	expect(cachedIdentity).not.toBeNull();
	172	expect(cachedIdentity?.canonicalKey).toBe("github.com/t3tools/t3code");
	173
	174	yield* TestClock.adjust(Duration.millis(180));
	175
	176	const refreshedIdentity = yield* resolver.resolve(cwd);
	177	expect(refreshedIdentity).not.toBeNull();
	178	expect(refreshedIdentity?.canonicalKey).toBe("github.com/t3tools/t3code-next");
	179	expect(refreshedIdentity?.displayName).toBe("t3tools/t3code-next");
	180	expect(refreshedIdentity?.name).toBe("t3code-next");
	181	}).pipe(
	182	Effect.provide(
	183	Layer.merge(
	184	TestClock.layer(),
	185	makeRepositoryIdentityResolverTestLayer({
	186	negativeCacheTtl: Duration.millis(50),
	187	positiveCacheTtl: Duration.millis(100),
	188	}),
	189	),
	190	),
	191	),
	192	);
	193	});

apps/server/src/project/Layers/RepositoryIdentityResolver.ts+147−0

@@ -0,0 +1,147 @@
	1	import type { RepositoryIdentity } from "@t3tools/contracts";
	2	import { Cache, Duration, Effect, Exit, Layer } from "effect";
	3	import { detectGitHostingProviderFromRemoteUrl, normalizeGitRemoteUrl } from "@t3tools/shared/git";
	4
	5	import { runProcess } from "../../processRunner.ts";
	6	import {
	7	RepositoryIdentityResolver,
	8	type RepositoryIdentityResolverShape,
	9	} from "../Services/RepositoryIdentityResolver.ts";
	10
	11	function parseRemoteFetchUrls(stdout: string): Map<string, string> {
	12	const remotes = new Map<string, string>();
	13	for (const line of stdout.split("\n")) {
	14	const trimmed = line.trim();
	15	if (trimmed.length === 0) continue;
	16	const match = /^(\S+)\s+(\S+)\s+$(fetch\|push)$$/.exec(trimmed);
	17	if (!match) continue;
	18	const [, remoteName = "", remoteUrl = "", direction = ""] = match;
	19	if (direction !== "fetch" \|\| remoteName.length === 0 \|\| remoteUrl.length === 0) {
	20	continue;
	21	}
	22	remotes.set(remoteName, remoteUrl);
	23	}
	24	return remotes;
	25	}
	26
	27	function pickPrimaryRemote(
	28	remotes: ReadonlyMap<string, string>,
	29	): { readonly remoteName: string; readonly remoteUrl: string } \| null {
	30	for (const preferredRemoteName of ["upstream", "origin"] as const) {
	31	const remoteUrl = remotes.get(preferredRemoteName);
	32	if (remoteUrl) {
	33	return { remoteName: preferredRemoteName, remoteUrl };
	34	}
	35	}
	36
	37	const [remoteName, remoteUrl] =
	38	[...remotes.entries()].toSorted(([left], [right]) => left.localeCompare(right))[0] ?? [];
	39	return remoteName && remoteUrl ? { remoteName, remoteUrl } : null;
	40	}
	41
	42	function buildRepositoryIdentity(input: {
	43	readonly remoteName: string;
	44	readonly remoteUrl: string;
	45	}): RepositoryIdentity {
	46	const canonicalKey = normalizeGitRemoteUrl(input.remoteUrl);
	47	const hostingProvider = detectGitHostingProviderFromRemoteUrl(input.remoteUrl);
	48	const repositoryPath = canonicalKey.split("/").slice(1).join("/");
	49	const repositoryPathSegments = repositoryPath.split("/").filter((segment) => segment.length > 0);
	50	const [owner] = repositoryPathSegments;
	51	const repositoryName = repositoryPathSegments.at(-1);
	52
	53	return {
	54	canonicalKey,
	55	locator: {
	56	source: "git-remote",
	57	remoteName: input.remoteName,
	58	remoteUrl: input.remoteUrl,
	59	},
	60	...(repositoryPath ? { displayName: repositoryPath } : {}),
	61	...(hostingProvider ? { provider: hostingProvider.kind } : {}),
	62	...(owner ? { owner } : {}),
	63	...(repositoryName ? { name: repositoryName } : {}),
	64	};
	65	}
	66
	67	const DEFAULT_REPOSITORY_IDENTITY_CACHE_CAPACITY = 512;
	68	const DEFAULT_POSITIVE_CACHE_TTL = Duration.minutes(1);
	69	const DEFAULT_NEGATIVE_CACHE_TTL = Duration.seconds(10);
	70
	71	interface RepositoryIdentityResolverOptions {
	72	readonly cacheCapacity?: number;
	73	readonly positiveCacheTtl?: Duration.Input;
	74	readonly negativeCacheTtl?: Duration.Input;
	75	}
	76
	77	async function resolveRepositoryIdentityCacheKey(cwd: string): Promise<string> {
	78	let cacheKey = cwd;
	79
	80	try {
	81	const topLevelResult = await runProcess("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
	82	allowNonZeroExit: true,
	83	});
	84	if (topLevelResult.code !== 0) {
	85	return cacheKey;
	86	}
	87
	88	const candidate = topLevelResult.stdout.trim();
	89	if (candidate.length > 0) {
	90	cacheKey = candidate;
	91	}
	92	} catch {
	93	return cacheKey;
	94	}
	95
	96	return cacheKey;
	97	}
	98
	99	async function resolveRepositoryIdentityFromCacheKey(
	100	cacheKey: string,
	101	): Promise<RepositoryIdentity \| null> {
	102	try {
	103	const remoteResult = await runProcess("git", ["-C", cacheKey, "remote", "-v"], {
	104	allowNonZeroExit: true,
	105	});
	106	if (remoteResult.code !== 0) {
	107	return null;
	108	}
	109
	110	const remote = pickPrimaryRemote(parseRemoteFetchUrls(remoteResult.stdout));
	111	return remote ? buildRepositoryIdentity(remote) : null;
	112	} catch {
	113	return null;
	114	}
	115	}
	116
	117	export const makeRepositoryIdentityResolver = Effect.fn("makeRepositoryIdentityResolver")(
	118	function* (options: RepositoryIdentityResolverOptions = {}) {
	119	const repositoryIdentityCache = yield* Cache.makeWith<string, RepositoryIdentity \| null>({
	120	capacity: options.cacheCapacity ?? DEFAULT_REPOSITORY_IDENTITY_CACHE_CAPACITY,
	121	lookup: (cacheKey) => Effect.promise(() => resolveRepositoryIdentityFromCacheKey(cacheKey)),
	122	timeToLive: Exit.match({
	123	onSuccess: (value) =>
	124	value === null
	125	? (options.negativeCacheTtl ?? DEFAULT_NEGATIVE_CACHE_TTL)
	126	: (options.positiveCacheTtl ?? DEFAULT_POSITIVE_CACHE_TTL),
	127	onFailure: () => Duration.zero,
	128	}),
	129	});
	130
	131	const resolve: RepositoryIdentityResolverShape["resolve"] = Effect.fn(
	132	"RepositoryIdentityResolver.resolve",
	133	)(function* (cwd) {
	134	const cacheKey = yield* Effect.promise(() => resolveRepositoryIdentityCacheKey(cwd));
	135	return yield* Cache.get(repositoryIdentityCache, cacheKey);
	136	});
	137
	138	return {
	139	resolve,
	140	} satisfies RepositoryIdentityResolverShape;
	141	},
	142	);
	143
	144	export const RepositoryIdentityResolverLive = Layer.effect(
	145	RepositoryIdentityResolver,
	146	makeRepositoryIdentityResolver(),
	147	);

apps/server/src/project/Services/RepositoryIdentityResolver.ts+12−0

@@ -0,0 +1,12 @@
	1	import type { RepositoryIdentity } from "@t3tools/contracts";
	2	import { ServiceMap } from "effect";
	3	import type { Effect } from "effect";
	4
	5	export interface RepositoryIdentityResolverShape {
	6	readonly resolve: (cwd: string) => Effect.Effect<RepositoryIdentity \| null>;
	7	}
	8
	9	export class RepositoryIdentityResolver extends ServiceMap.Service<
	10	RepositoryIdentityResolver,
	11	RepositoryIdentityResolverShape
	12	>()("t3/project/Services/RepositoryIdentityResolver") {}

apps/server/src/server.test.ts+245−1

@@ -5,6 +5,8 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; · 4 unmodified lines
5	import {	5	import {
6	CommandId,	6	CommandId,
7	DEFAULT_SERVER_SETTINGS,	7	DEFAULT_SERVER_SETTINGS,
		8	EnvironmentId,
		9	EventId,
8	GitCommandError,	10	GitCommandError,
9	KeybindingRule,	11	KeybindingRule,
10	MessageId,	12	MessageId,
@@ -83,6 +85,14 @@ import { · 72 unmodified lines
83	ProjectSetupScriptRunner,	85	ProjectSetupScriptRunner,
84	type ProjectSetupScriptRunnerShape,	86	type ProjectSetupScriptRunnerShape,
85	} from "./project/Services/ProjectSetupScriptRunner.ts";	87	} from "./project/Services/ProjectSetupScriptRunner.ts";
		88	import {
		89	RepositoryIdentityResolver,
		90	type RepositoryIdentityResolverShape,
		91	} from "./project/Services/RepositoryIdentityResolver.ts";
		92	import {
		93	ServerEnvironment,
		94	type ServerEnvironmentShape,
		95	} from "./environment/Services/ServerEnvironment.ts";
86	import { WorkspaceEntriesLive } from "./workspace/Layers/WorkspaceEntries.ts";	96	import { WorkspaceEntriesLive } from "./workspace/Layers/WorkspaceEntries.ts";
87	import { WorkspaceFileSystemLive } from "./workspace/Layers/WorkspaceFileSystem.ts";	97	import { WorkspaceFileSystemLive } from "./workspace/Layers/WorkspaceFileSystem.ts";
88	import { WorkspacePathsLive } from "./workspace/Layers/WorkspacePaths.ts";	98	import { WorkspacePathsLive } from "./workspace/Layers/WorkspacePaths.ts";
@@ -93,6 +103,18 @@ const defaultModelSelection = { · 4 unmodified lines
93	provider: "codex",	103	provider: "codex",
94	model: "gpt-5-codex",	104	model: "gpt-5-codex",
95	} as const;	105	} as const;
		106	const testEnvironmentDescriptor = {
		107	environmentId: EnvironmentId.makeUnsafe("environment-test"),
		108	label: "Test environment",
		109	platform: {
		110	os: "darwin" as const,
		111	arch: "arm64" as const,
		112	},
		113	serverVersion: "0.0.0-test",
		114	capabilities: {
		115	repositoryIdentity: true,
		116	},
		117	};
96		118
97	const makeDefaultOrchestrationReadModel = () => {	119	const makeDefaultOrchestrationReadModel = () => {
98	const now = new Date().toISOString();	120	const now = new Date().toISOString();
@@ -270,6 +292,8 @@ const buildAppUnderTest = (options?: { · 171 unmodified lines
270	browserTraceCollector?: Partial<BrowserTraceCollectorShape>;	292	browserTraceCollector?: Partial<BrowserTraceCollectorShape>;
271	serverLifecycleEvents?: Partial<ServerLifecycleEventsShape>;	293	serverLifecycleEvents?: Partial<ServerLifecycleEventsShape>;
272	serverRuntimeStartup?: Partial<ServerRuntimeStartupShape>;	294	serverRuntimeStartup?: Partial<ServerRuntimeStartupShape>;
		295	serverEnvironment?: Partial<ServerEnvironmentShape>;
		296	repositoryIdentityResolver?: Partial<RepositoryIdentityResolverShape>;
273	};	297	};
274	}) =>	298	}) =>
275	Effect.gen(function* () {	299	Effect.gen(function* () {
@@ -416,6 +440,19 @@ const buildAppUnderTest = (options?: { · 140 unmodified lines
416	...options?.layers?.serverRuntimeStartup,	440	...options?.layers?.serverRuntimeStartup,
417	}),	441	}),
418	),	442	),
		443	Layer.provide(
		444	Layer.mock(ServerEnvironment)({
		445	getEnvironmentId: Effect.succeed(testEnvironmentDescriptor.environmentId),
		446	getDescriptor: Effect.succeed(testEnvironmentDescriptor),
		447	...options?.layers?.serverEnvironment,
		448	}),
		449	),
		450	Layer.provide(
		451	Layer.mock(RepositoryIdentityResolver)({
		452	resolve: () => Effect.succeed(null),
		453	...options?.layers?.repositoryIdentityResolver,
		454	}),
		455	),
419	Layer.provide(workspaceAndProjectServicesLayer),	456	Layer.provide(workspaceAndProjectServicesLayer),
420	Layer.provideMerge(FetchHttpClient.layer),	457	Layer.provideMerge(FetchHttpClient.layer),
421	Layer.provide(layerConfig),	458	Layer.provide(layerConfig),
@@ -1069,6 +1106,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { · 647 unmodified lines
1069	sequence: 1,	1106	sequence: 1,
1070	type: "welcome" as const,	1107	type: "welcome" as const,
1071	payload: {	1108	payload: {
		1109	environment: testEnvironmentDescriptor,
1072	cwd: "/tmp/project",	1110	cwd: "/tmp/project",
1073	projectName: "project",	1111	projectName: "project",
1074	},	1112	},
@@ -1078,7 +1116,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { · 3 unmodified lines
1078	version: 1 as const,	1116	version: 1 as const,
1079	sequence: 2,	1117	sequence: 2,
1080	type: "ready" as const,	1118	type: "ready" as const,
1081	payload: { at: new Date().toISOString() },	1119	payload: { at: new Date().toISOString(), environment: testEnvironmentDescriptor },
1082	});	1120	});
1083		1121
1084	yield* buildAppUnderTest({	1122	yield* buildAppUnderTest({
@@ -1996,6 +2034,73 @@ it.layer(NodeServices.layer)("server router seam", (it) => { · 911 unmodified lines
1996	}).pipe(Effect.provide(NodeHttpServer.layerTest)),	2034	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
1997	);	2035	);
1998		2036
		2037	it.effect("enriches replayed project events with repository identity metadata", () =>
		2038	Effect.gen(function* () {
		2039	const repositoryIdentity = {
		2040	canonicalKey: "github.com/t3tools/t3code",
		2041	locator: {
		2042	source: "git-remote" as const,
		2043	remoteName: "origin",
		2044	remoteUrl: "git@github.com:T3Tools/t3code.git",
		2045	},
		2046	displayName: "T3Tools/t3code",
		2047	provider: "github",
		2048	owner: "T3Tools",
		2049	name: "t3code",
		2050	};
		2051
		2052	yield* buildAppUnderTest({
		2053	layers: {
		2054	orchestrationEngine: {
		2055	readEvents: (_fromSequenceExclusive) =>
		2056	Stream.make({
		2057	sequence: 1,
		2058	eventId: EventId.makeUnsafe("event-1"),
		2059	aggregateKind: "project",
		2060	aggregateId: defaultProjectId,
		2061	occurredAt: "2026-04-05T00:00:00.000Z",
		2062	commandId: null,
		2063	causationEventId: null,
		2064	correlationId: null,
		2065	metadata: {},
		2066	type: "project.created",
		2067	payload: {
		2068	projectId: defaultProjectId,
		2069	title: "Default Project",
		2070	workspaceRoot: "/tmp/default-project",
		2071	defaultModelSelection,
		2072	scripts: [],
		2073	createdAt: "2026-04-05T00:00:00.000Z",
		2074	updatedAt: "2026-04-05T00:00:00.000Z",
		2075	},
		2076	} satisfies Extract<OrchestrationEvent, { type: "project.created" }>),
		2077	},
		2078	repositoryIdentityResolver: {
		2079	resolve: () => Effect.succeed(repositoryIdentity),
		2080	},
		2081	},
		2082	});
		2083
		2084	const wsUrl = yield* getWsServerUrl("/ws");
		2085	const replayResult = yield* Effect.scoped(
		2086	withWsRpcClient(wsUrl, (client) =>
		2087	client[ORCHESTRATION_WS_METHODS.replayEvents]({
		2088	fromSequenceExclusive: 0,
		2089	}),
		2090	),
		2091	);
		2092
		2093	const replayedEvent = replayResult[0];
		2094	assert.equal(replayedEvent?.type, "project.created");
		2095	assert.deepEqual(
		2096	replayedEvent && replayedEvent.type === "project.created"
		2097	? replayedEvent.payload.repositoryIdentity
		2098	: null,
		2099	repositoryIdentity,
		2100	);
		2101	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
		2102	);
		2103
1999	it.effect("closes thread terminals after a successful archive command", () =>	2104	it.effect("closes thread terminals after a successful archive command", () =>
2000	Effect.gen(function* () {	2105	Effect.gen(function* () {
2001	const threadId = ThreadId.makeUnsafe("thread-archive");	2106	const threadId = ThreadId.makeUnsafe("thread-archive");
@@ -2498,6 +2603,145 @@ it.layer(NodeServices.layer)("server router seam", (it) => { · 496 unmodified lines
2498	}).pipe(Effect.provide(NodeHttpServer.layerTest)),	2603	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
2499	);	2604	);
2500		2605
		2606	it.effect("enriches replayed project events only once before streaming them to subscribers", () =>
		2607	Effect.gen(function* () {
		2608	let resolveCalls = 0;
		2609	const repositoryIdentity = {
		2610	canonicalKey: "github.com/t3tools/t3code",
		2611	locator: {
		2612	source: "git-remote" as const,
		2613	remoteName: "origin",
		2614	remoteUrl: "git@github.com:t3tools/t3code.git",
		2615	},
		2616	displayName: "t3tools/t3code",
		2617	provider: "github" as const,
		2618	owner: "t3tools",
		2619	name: "t3code",
		2620	};
		2621
		2622	yield* buildAppUnderTest({
		2623	layers: {
		2624	orchestrationEngine: {
		2625	getReadModel: () =>
		2626	Effect.succeed({
		2627	...makeDefaultOrchestrationReadModel(),
		2628	snapshotSequence: 0,
		2629	}),
		2630	readEvents: () =>
		2631	Stream.make({
		2632	sequence: 1,
		2633	eventId: EventId.makeUnsafe("event-1"),
		2634	aggregateKind: "project",
		2635	aggregateId: defaultProjectId,
		2636	occurredAt: "2026-04-06T00:00:00.000Z",
		2637	commandId: null,
		2638	causationEventId: null,
		2639	correlationId: null,
		2640	metadata: {},
		2641	type: "project.meta-updated",
		2642	payload: {
		2643	projectId: defaultProjectId,
		2644	title: "Replayed Project",
		2645	updatedAt: "2026-04-06T00:00:00.000Z",
		2646	},
		2647	} satisfies Extract<OrchestrationEvent, { type: "project.meta-updated" }>),
		2648	streamDomainEvents: Stream.empty,
		2649	},
		2650	repositoryIdentityResolver: {
		2651	resolve: () => {
		2652	resolveCalls += 1;
		2653	return Effect.succeed(repositoryIdentity);
		2654	},
		2655	},
		2656	},
		2657	});
		2658
		2659	const wsUrl = yield* getWsServerUrl("/ws");
		2660	const events = yield* Effect.scoped(
		2661	withWsRpcClient(wsUrl, (client) =>
		2662	client[WS_METHODS.subscribeOrchestrationDomainEvents]({}).pipe(
		2663	Stream.take(1),
		2664	Stream.runCollect,
		2665	),
		2666	),
		2667	);
		2668
		2669	const event = Array.from(events)[0];
		2670	assert.equal(resolveCalls, 1);
		2671	assert.equal(event?.type, "project.meta-updated");
		2672	assert.deepEqual(
		2673	event && event.type === "project.meta-updated" ? event.payload.repositoryIdentity : null,
		2674	repositoryIdentity,
		2675	);
		2676	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
		2677	);
		2678
		2679	it.effect("enriches subscribed project meta updates with repository identity metadata", () =>
		2680	Effect.gen(function* () {
		2681	const repositoryIdentity = {
		2682	canonicalKey: "github.com/t3tools/t3code",
		2683	locator: {
		2684	source: "git-remote" as const,
		2685	remoteName: "upstream",
		2686	remoteUrl: "git@github.com:T3Tools/t3code.git",
		2687	},
		2688	displayName: "T3Tools/t3code",
		2689	provider: "github",
		2690	owner: "T3Tools",
		2691	name: "t3code",
		2692	};
		2693
		2694	yield* buildAppUnderTest({
		2695	layers: {
		2696	orchestrationEngine: {
		2697	getReadModel: () =>
		2698	Effect.succeed({
		2699	...makeDefaultOrchestrationReadModel(),
		2700	snapshotSequence: 0,
		2701	}),
		2702	streamDomainEvents: Stream.make({
		2703	sequence: 1,
		2704	eventId: EventId.makeUnsafe("event-1"),
		2705	aggregateKind: "project",
		2706	aggregateId: defaultProjectId,
		2707	occurredAt: "2026-04-05T00:00:00.000Z",
		2708	commandId: null,
		2709	causationEventId: null,
		2710	correlationId: null,
		2711	metadata: {},
		2712	type: "project.meta-updated",
		2713	payload: {
		2714	projectId: defaultProjectId,
		2715	title: "Renamed Project",
		2716	updatedAt: "2026-04-05T00:00:00.000Z",
		2717	},
		2718	} satisfies Extract<OrchestrationEvent, { type: "project.meta-updated" }>),
		2719	},
		2720	repositoryIdentityResolver: {
		2721	resolve: () => Effect.succeed(repositoryIdentity),
		2722	},
		2723	},
		2724	});
		2725
		2726	const wsUrl = yield* getWsServerUrl("/ws");
		2727	const events = yield* Effect.scoped(
		2728	withWsRpcClient(wsUrl, (client) =>
		2729	client[WS_METHODS.subscribeOrchestrationDomainEvents]({}).pipe(
		2730	Stream.take(1),
		2731	Stream.runCollect,
		2732	),
		2733	),
		2734	);
		2735
		2736	const event = Array.from(events)[0];
		2737	assert.equal(event?.type, "project.meta-updated");
		2738	assert.deepEqual(
		2739	event && event.type === "project.meta-updated" ? event.payload.repositoryIdentity : null,
		2740	repositoryIdentity,
		2741	);
		2742	}).pipe(Effect.provide(NodeHttpServer.layerTest)),
		2743	);
		2744
2501	it.effect("routes websocket rpc orchestration.getSnapshot errors", () =>	2745	it.effect("routes websocket rpc orchestration.getSnapshot errors", () =>
2502	Effect.gen(function* () {	2746	Effect.gen(function* () {
2503	yield* buildAppUnderTest({	2747	yield* buildAppUnderTest({

apps/server/src/server.ts+4−0

 import { ProviderRegistryLive } from "./provider/Layers/ProviderRegistry";
 import { ServerSettingsLive } from "./serverSettings";
 import { ProjectFaviconResolverLive } from "./project/Layers/ProjectFaviconResolver";
+import { RepositoryIdentityResolverLive } from "./project/Layers/RepositoryIdentityResolver";
 import { WorkspaceEntriesLive } from "./workspace/Layers/WorkspaceEntries";
 import { WorkspaceFileSystemLive } from "./workspace/Layers/WorkspaceFileSystem";
 import { WorkspacePathsLive } from "./workspace/Layers/WorkspacePaths";
 import { ProjectSetupScriptRunnerLive } from "./project/Layers/ProjectSetupScriptRunner";
 import { ObservabilityLive } from "./observability/Layers/Observability";
+import { ServerEnvironmentLive } from "./environment/Layers/ServerEnvironment";
 const PtyAdapterLive = Layer.unwrap(
   Effect.gen(function* () {
   Layer.provideMerge(ServerSettingsLive),
   Layer.provideMerge(WorkspaceLayerLive),
   Layer.provideMerge(ProjectFaviconResolverLive),
+  Layer.provideMerge(RepositoryIdentityResolverLive),
+  Layer.provideMerge(ServerEnvironmentLive),
   // Misc.
   Layer.provideMerge(AnalyticsServiceLayerLive),

apps/server/src/serverLifecycleEvents.test.ts+10−0

+import { EnvironmentId } from "@t3tools/contracts";
 import { assert, it } from "@effect/vitest";
 import { assertTrue } from "@effect/vitest/utils";
 import { Effect, Option } from "effect";
   () =>
     Effect.gen(function* () {
       const lifecycleEvents = yield* ServerLifecycleEvents;
+      const environment = {
+        environmentId: EnvironmentId.makeUnsafe("environment-test"),
+        label: "Test environment",
+        platform: { os: "darwin" as const, arch: "arm64" as const },
+        serverVersion: "0.0.0-test",
+        capabilities: { repositoryIdentity: true },
+      };
       const welcome = yield* lifecycleEvents
         .publish({
           version: 1,
           type: "welcome",
           payload: {
+            environment,
             cwd: "/tmp/project",
             projectName: "project",
           },
           type: "ready",
           payload: {
             at: new Date().toISOString(),
+            environment,
           },
         })
         .pipe(Effect.timeoutOption("50 millis"));

apps/server/src/serverRuntimeStartup.ts+12−2

 import { OrchestrationReactor } from "./orchestration/Services/OrchestrationReactor";
 import { ServerLifecycleEvents } from "./serverLifecycleEvents";
 import { ServerSettingsService } from "./serverSettings";
+import { ServerEnvironment } from "./environment/Services/ServerEnvironment";
 import { AnalyticsService } from "./telemetry/Services/AnalyticsService";
 const isWildcardHost = (host: string | undefined): boolean =>
   const orchestrationReactor = yield* OrchestrationReactor;
   const lifecycleEvents = yield* ServerLifecycleEvents;
   const serverSettings = yield* ServerSettingsService;
+  const serverEnvironment = yield* ServerEnvironment;
   const commandGate = yield* makeCommandGate;
   const httpListening = yield* Deferred.make<void>();
     yield* Effect.logDebug("startup phase: preparing welcome payload");
     const welcome = yield* runStartupPhase("welcome.prepare", autoBootstrapWelcome);
+    const environment = yield* serverEnvironment.getDescriptor;
     yield* Effect.logDebug("startup phase: publishing welcome event", {
+      environmentId: environment.environmentId,
       cwd: welcome.cwd,
       projectName: welcome.projectName,
       bootstrapProjectId: welcome.bootstrapProjectId,
       lifecycleEvents.publish({
         version: 1,
         type: "welcome",
-        payload: welcome,
+        payload: {
+          environment,
+          ...welcome,
+        },
       }),
     );
   }).pipe(
         lifecycleEvents.publish({
           version: 1,
           type: "ready",
-          payload: { at: new Date().toISOString() },
+          payload: {
+            at: new Date().toISOString(),
+            environment: yield* serverEnvironment.getDescriptor,
+          },
         }),
       );

apps/server/src/ws.ts+55−1

@@ -47,6 +47,8 @@ import { WorkspaceEntries } from "./workspace/Services/WorkspaceEntries"; · 46 unmodified lines
47	import { WorkspaceFileSystem } from "./workspace/Services/WorkspaceFileSystem";	47	import { WorkspaceFileSystem } from "./workspace/Services/WorkspaceFileSystem";
48	import { WorkspacePathOutsideRootError } from "./workspace/Services/WorkspacePaths";	48	import { WorkspacePathOutsideRootError } from "./workspace/Services/WorkspacePaths";
49	import { ProjectSetupScriptRunner } from "./project/Services/ProjectSetupScriptRunner";	49	import { ProjectSetupScriptRunner } from "./project/Services/ProjectSetupScriptRunner";
		50	import { RepositoryIdentityResolver } from "./project/Services/RepositoryIdentityResolver";
		51	import { ServerEnvironment } from "./environment/Services/ServerEnvironment";
50		52
51	const WsRpcLayer = WsRpcGroup.toLayer(	53	const WsRpcLayer = WsRpcGroup.toLayer(
52	Effect.gen(function* () {	54	Effect.gen(function* () {
@@ -67,6 +69,8 @@ const WsRpcLayer = WsRpcGroup.toLayer( · 14 unmodified lines
67	const workspaceEntries = yield* WorkspaceEntries;	69	const workspaceEntries = yield* WorkspaceEntries;
68	const workspaceFileSystem = yield* WorkspaceFileSystem;	70	const workspaceFileSystem = yield* WorkspaceFileSystem;
69	const projectSetupScriptRunner = yield* ProjectSetupScriptRunner;	71	const projectSetupScriptRunner = yield* ProjectSetupScriptRunner;
		72	const repositoryIdentityResolver = yield* RepositoryIdentityResolver;
		73	const serverEnvironment = yield* ServerEnvironment;
70	const serverCommandId = (tag: string) =>	74	const serverCommandId = (tag: string) =>
71	CommandId.makeUnsafe(`server:${tag}:${crypto.randomUUID()}`);	75	CommandId.makeUnsafe(`server:${tag}:${crypto.randomUUID()}`);
72		76
@@ -113,6 +117,49 @@ const WsRpcLayer = WsRpcGroup.toLayer( · 40 unmodified lines
113	});	117	});
114	};	118	};
115		119
		120	const enrichProjectEvent = (
		121	event: OrchestrationEvent,
		122	): Effect.Effect<OrchestrationEvent, never, never> => {
		123	switch (event.type) {
		124	case "project.created":
		125	return repositoryIdentityResolver.resolve(event.payload.workspaceRoot).pipe(
		126	Effect.map((repositoryIdentity) => ({
		127	...event,
		128	payload: {
		129	...event.payload,
		130	repositoryIdentity,
		131	},
		132	})),
		133	);
		134	case "project.meta-updated":
		135	return Effect.gen(function* () {
		136	const workspaceRoot =
		137	event.payload.workspaceRoot ??
		138	(yield* orchestrationEngine.getReadModel()).projects.find(
		139	(project) => project.id === event.payload.projectId,
		140	)?.workspaceRoot ??
		141	null;
		142	if (workspaceRoot === null) {
		143	return event;
		144	}
		145
		146	const repositoryIdentity = yield* repositoryIdentityResolver.resolve(workspaceRoot);
		147	return {
		148	...event,
		149	payload: {
		150	...event.payload,
		151	repositoryIdentity,
		152	},
		153	} satisfies OrchestrationEvent;
		154	});
		155	default:
		156	return Effect.succeed(event);
		157	}
		158	};
		159
		160	const enrichOrchestrationEvents = (events: ReadonlyArray<OrchestrationEvent>) =>
		161	Effect.forEach(events, enrichProjectEvent, { concurrency: 4 });
		162
116	const dispatchBootstrapTurnStart = (	163	const dispatchBootstrapTurnStart = (
117	command: Extract<OrchestrationCommand, { type: "thread.turn.start" }>,	164	command: Extract<OrchestrationCommand, { type: "thread.turn.start" }>,
118	): Effect.Effect<{ readonly sequence: number }, OrchestrationDispatchCommandError> =>	165	): Effect.Effect<{ readonly sequence: number }, OrchestrationDispatchCommandError> =>
@@ -329,8 +376,10 @@ const WsRpcLayer = WsRpcGroup.toLayer( · 210 unmodified lines
329	const keybindingsConfig = yield* keybindings.loadConfigState;	376	const keybindingsConfig = yield* keybindings.loadConfigState;
330	const providers = yield* providerRegistry.getProviders;	377	const providers = yield* providerRegistry.getProviders;
331	const settings = yield* serverSettings.getSettings;	378	const settings = yield* serverSettings.getSettings;
		379	const environment = yield* serverEnvironment.getDescriptor;
332		380
333	return {	381	return {
		382	environment,
334	cwd: config.cwd,	383	cwd: config.cwd,
335	keybindingsConfigPath: config.keybindingsConfigPath,	384	keybindingsConfigPath: config.keybindingsConfigPath,
336	keybindings: keybindingsConfig.keybindings,	385	keybindings: keybindingsConfig.keybindings,
@@ -435,6 +484,7 @@ const WsRpcLayer = WsRpcGroup.toLayer( · 98 unmodified lines
435	),	484	),
436	).pipe(	485	).pipe(
437	Effect.map((events) => Array.from(events)),	486	Effect.map((events) => Array.from(events)),
		487	Effect.flatMap(enrichOrchestrationEvents),
438	Effect.mapError(	488	Effect.mapError(
439	(cause) =>	489	(cause) =>
440	new OrchestrationReplayEventsError({	490	new OrchestrationReplayEventsError({
@@ -455,10 +505,14 @@ const WsRpcLayer = WsRpcGroup.toLayer( · 14 unmodified lines
455	orchestrationEngine.readEvents(fromSequenceExclusive),	505	orchestrationEngine.readEvents(fromSequenceExclusive),
456	).pipe(	506	).pipe(
457	Effect.map((events) => Array.from(events)),	507	Effect.map((events) => Array.from(events)),
		508	Effect.flatMap(enrichOrchestrationEvents),
458	Effect.catch(() => Effect.succeed([] as Array<OrchestrationEvent>)),	509	Effect.catch(() => Effect.succeed([] as Array<OrchestrationEvent>)),
459	);	510	);
460	const replayStream = Stream.fromIterable(replayEvents);	511	const replayStream = Stream.fromIterable(replayEvents);
461	const source = Stream.merge(replayStream, orchestrationEngine.streamDomainEvents);	512	const liveStream = orchestrationEngine.streamDomainEvents.pipe(
		513	Stream.mapEffect(enrichProjectEvent),
		514	);
		515	const source = Stream.merge(replayStream, liveStream);
462	type SequenceState = {	516	type SequenceState = {
463	readonly nextSequence: number;	517	readonly nextSequence: number;
464	readonly pendingBySequence: Map<number, OrchestrationEvent>;	518	readonly pendingBySequence: Map<number, OrchestrationEvent>;

apps/web/index.html+1−0

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	rel="stylesheet"	12	rel="stylesheet"
13	/>	13	/>
14	<title>T3 Code (Alpha)</title>	14	<title>T3 Code (Alpha)</title>
		15	<script crossorigin="anonymous" src="//unpkg.com/react-scan/dist/auto.global.js"></script>
15	</head>	16	</head>
16	<body>	17	<body>
17	<div id="root"></div>	18	<div id="root"></div>

apps/web/package.json+1−0

@@ -23,6 +23,7 @@ · 22 unmodified lines
23	"@formkit/auto-animate": "^0.9.0",	23	"@formkit/auto-animate": "^0.9.0",
24	"@lexical/react": "^0.41.0",	24	"@lexical/react": "^0.41.0",
25	"@pierre/diffs": "^1.1.0-beta.16",	25	"@pierre/diffs": "^1.1.0-beta.16",
		26	"@t3tools/client-runtime": "workspace:*",
26	"@t3tools/contracts": "workspace:*",	27	"@t3tools/contracts": "workspace:*",
27	"@t3tools/shared": "workspace:*",	28	"@t3tools/shared": "workspace:*",
28	"@tanstack/react-pacer": "^0.19.4",	29	"@tanstack/react-pacer": "^0.19.4",

apps/web/src/components/BranchToolbar.tsx+36−14

-import type { ThreadId } from "@t3tools/contracts";
+import { scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime";
+import type { EnvironmentId, ThreadId } from "@t3tools/contracts";
 import { FolderIcon, GitForkIcon } from "lucide-react";
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
+import { useComposerDraftStore, type DraftId } from "../composerDraftStore";
+import { readEnvironmentApi } from "../environmentApi";
 import { newCommandId } from "../lib/utils";
-import { readNativeApi } from "../nativeApi";
-import { useComposerDraftStore } from "../composerDraftStore";
 import { useStore } from "../store";
+import { createProjectSelectorByRef, createThreadSelectorByRef } from "../storeSelectors";
 import {
   EnvMode,
   resolveDraftEnvModeAfterBranchChange,
 ] as const;
 interface BranchToolbarProps {
+  environmentId: EnvironmentId;
   threadId: ThreadId;
+  draftId?: DraftId;
   onEnvModeChange: (mode: EnvMode) => void;
   envLocked: boolean;
   onCheckoutPullRequestRequest?: (reference: string) => void;
 }
 export default function BranchToolbar({
+  environmentId,
   threadId,
+  draftId,
   onEnvModeChange,
   envLocked,
   onCheckoutPullRequestRequest,
   onComposerFocusRequest,
 }: BranchToolbarProps) {
-  const serverThread = useStore((store) => store.threadShellById[threadId]);
+  const threadRef = useMemo(
-  const serverSession = useStore((store) => store.threadSessionById[threadId] ?? null);
+    () => scopeThreadRef(environmentId, threadId),
+    [environmentId, threadId],
+  );
+  const serverThreadSelector = useMemo(() => createThreadSelectorByRef(threadRef), [threadRef]);
+  const serverThread = useStore(serverThreadSelector);
+  const serverSession = serverThread?.session ?? null;
   const setThreadBranchAction = useStore((store) => store.setThreadBranch);
-  const draftThread = useComposerDraftStore((store) => store.getDraftThread(threadId));
+  const draftThread = useComposerDraftStore((store) => store.getDraftThreadByRef(threadRef));
   const setDraftThreadContext = useComposerDraftStore((store) => store.setDraftThreadContext);
-  const activeProjectId = serverThread?.projectId ?? draftThread?.projectId ?? null;
+  const activeProjectRef = serverThread
-  const activeProject = useStore((store) =>
+    ? scopeProjectRef(serverThread.environmentId, serverThread.projectId)
-    activeProjectId ? store.projectById[activeProjectId] : undefined,
+    : draftThread
+      ? scopeProjectRef(draftThread.environmentId, draftThread.projectId)
+      : null;
+  const activeProjectSelector = useMemo(
+    () => createProjectSelectorByRef(activeProjectRef),
+    [activeProjectRef],
   );
+  const activeProject = useStore(activeProjectSelector);
   const activeThreadId = serverThread?.id ?? (draftThread ? threadId : undefined);
   const activeThreadBranch = serverThread?.branch ?? draftThread?.branch ?? null;
   const activeWorktreePath = serverThread?.worktreePath ?? draftThread?.worktreePath ?? null;
   const setThreadBranch = useCallback(
     (branch: string | null, worktreePath: string | null) => {
-      if (!activeThreadId) return;
+      if (!activeThreadId || !activeProject) return;
-      const api = readNativeApi();
+      const api = readEnvironmentApi(environmentId);
       // If the effective cwd is about to change, stop the running session so the
       // next message creates a new one with the correct cwd.
       if (serverSession && worktreePath !== activeWorktreePath && api) {
         currentWorktreePath: activeWorktreePath,
         effectiveEnvMode,
       });
-      setDraftThreadContext(threadId, {
+      setDraftThreadContext(draftId ?? threadRef, {
         branch,
         worktreePath,
         envMode: nextDraftEnvMode,
+        projectRef: scopeProjectRef(environmentId, activeProject.id),
       });
     },
     [
       activeThreadId,
+      activeProject,
       serverSession,
       activeWorktreePath,
       hasServerThread,
       setThreadBranchAction,
       setDraftThreadContext,
-      threadId,
+      draftId,
+      threadRef,
+      environmentId,
       effectiveEnvMode,
     ],
   );
       )}
       <BranchToolbarBranchSelector
+        environmentId={environmentId}
         activeProjectCwd={activeProject.cwd}
         activeThreadBranch={activeThreadBranch}
         activeWorktreePath={activeWorktreePath}

apps/web/src/components/BranchToolbarBranchSelector.tsx+13−10

-import type { GitBranch } from "@t3tools/contracts";
+import type { EnvironmentId, GitBranch } from "@t3tools/contracts";
 import { useInfiniteQuery, useQueryClient } from "@tanstack/react-query";
 import { useVirtualizer } from "@tanstack/react-virtual";
 import { ChevronDownIcon } from "lucide-react";
 import { gitBranchSearchInfiniteQueryOptions, gitQueryKeys } from "../lib/gitReactQuery";
 import { useGitStatus } from "../lib/gitStatusState";
-import { readNativeApi } from "../nativeApi";
+import { readEnvironmentApi } from "../environmentApi";
 import { parsePullRequestReference } from "../pullRequestReference";
 import {
   deriveLocalBranchNameFromRemoteRef,
 import { toastManager } from "./ui/toast";
 interface BranchToolbarBranchSelectorProps {
+  environmentId: EnvironmentId;
   activeProjectCwd: string;
   activeThreadBranch: string | null;
   activeWorktreePath: string | null;
 }
 export function BranchToolbarBranchSelector({
+  environmentId,
   activeProjectCwd,
   activeThreadBranch,
   activeWorktreePath,
   const [branchQuery, setBranchQuery] = useState("");
   const deferredBranchQuery = useDeferredValue(branchQuery);
-  const branchStatusQuery = useGitStatus(branchCwd);
+  const branchStatusQuery = useGitStatus({ environmentId, cwd: branchCwd });
   const trimmedBranchQuery = branchQuery.trim();
   const deferredTrimmedBranchQuery = deferredBranchQuery.trim();
   useEffect(() => {
     if (!branchCwd) return;
     void queryClient.prefetchInfiniteQuery(
-      gitBranchSearchInfiniteQueryOptions({ cwd: branchCwd, query: "" }),
+      gitBranchSearchInfiniteQueryOptions({ environmentId, cwd: branchCwd, query: "" }),
     );
-  }, [branchCwd, queryClient]);
+  }, [branchCwd, environmentId, queryClient]);
   const {
     data: branchesSearchData,
     isPending: isBranchesSearchPending,
   } = useInfiniteQuery(
     gitBranchSearchInfiniteQueryOptions({
+      environmentId,
       cwd: branchCwd,
       query: deferredTrimmedBranchQuery,
     }),
     startBranchActionTransition(async () => {
       await action().catch(() => undefined);
       await queryClient
-        .invalidateQueries({ queryKey: gitQueryKeys.branches(branchCwd) })
+        .invalidateQueries({ queryKey: gitQueryKeys.branches(environmentId, branchCwd) })
         .catch(() => undefined);
     });
   };
   const selectBranch = (branch: GitBranch) => {
-    const api = readNativeApi();
+    const api = readEnvironmentApi(environmentId);
     if (!api || !branchCwd || isBranchActionPending) return;
     // In new-worktree mode, selecting a branch sets the base branch.
   const createBranch = (rawName: string) => {
     const name = rawName.trim();
-    const api = readNativeApi();
+    const api = readEnvironmentApi(environmentId);
     if (!api || !branchCwd || !name || isBranchActionPending) return;
     setIsBranchMenuOpen(false);
         return;
       }
       void queryClient.invalidateQueries({
-        queryKey: gitQueryKeys.branches(branchCwd),
+        queryKey: gitQueryKeys.branches(environmentId, branchCwd),
       });
     },
-    [branchCwd, queryClient],
+    [branchCwd, environmentId, queryClient],
   );
   const branchListScrollElementRef = useRef<HTMLDivElement | null>(null);

apps/web/src/components/ChatMarkdown.tsx+2−2

@@ -22,7 +22,7 @@ import { fnv1a32 } from "../lib/diffRendering"; · 21 unmodified lines
22	import { LRUCache } from "../lib/lruCache";	22	import { LRUCache } from "../lib/lruCache";
23	import { useTheme } from "../hooks/useTheme";	23	import { useTheme } from "../hooks/useTheme";
24	import { resolveMarkdownFileLinkTarget } from "../markdown-links";	24	import { resolveMarkdownFileLinkTarget } from "../markdown-links";
25	import { readNativeApi } from "../nativeApi";	25	import { readLocalApi } from "../localApi";
26		26
27	class CodeHighlightErrorBoundary extends React.Component<	27	class CodeHighlightErrorBoundary extends React.Component<
28	{ fallback: ReactNode; children: ReactNode },	28	{ fallback: ReactNode; children: ReactNode },
@@ -253,7 +253,7 @@ function ChatMarkdown({ text, cwd, isStreaming = false }: ChatMarkdownProps) { · 224 unmodified lines
253	onClick={(event) => {	253	onClick={(event) => {
254	event.preventDefault();	254	event.preventDefault();
255	event.stopPropagation();	255	event.stopPropagation();
256	const api = readNativeApi();	256	const api = readLocalApi();
257	if (api) {	257	if (api) {
258	void openInPreferredEditor(api, targetPath);	258	void openInPreferredEditor(api, targetPath);
259	} else {	259	} else {

apps/web/src/components/ChatView.browser.tsx+330−229

 import {
   EventId,
   ORCHESTRATION_WS_METHODS,
+  EnvironmentId,
   type MessageId,
   type OrchestrationEvent,
   type OrchestrationReadModel,
   type ServerLifecycleWelcomePayload,
   type ThreadId,
   type TurnId,
-  type UserInputQuestion,
   WS_METHODS,
   OrchestrationSessionStatus,
   DEFAULT_SERVER_SETTINGS,
 } from "@t3tools/contracts";
+import {
+  scopedProjectKey,
+  scopedThreadKey,
+  scopeProjectRef,
+  scopeThreadRef,
+} from "@t3tools/client-runtime";
 import { RouterProvider, createMemoryHistory } from "@tanstack/react-router";
 import { HttpResponse, http, ws } from "msw";
 import { setupWorker } from "msw/browser";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { render } from "vitest-browser-react";
-import { useComposerDraftStore } from "../composerDraftStore";
+import { useComposerDraftStore, DraftId } from "../composerDraftStore";
 import {
   INLINE_TERMINAL_CONTEXT_PLACEHOLDER,
   type TerminalContextDraft,
   removeInlineTerminalContextPlaceholder,
 } from "../lib/terminalContext";
 import { isMacPlatform } from "../lib/utils";
-import { __resetNativeApiForTests } from "../nativeApi";
+import { __resetLocalApiForTests } from "../localApi";
 import { AppAtomRegistryProvider } from "../rpc/atomRegistry";
 import { getServerConfig } from "../rpc/serverState";
 import { getRouter } from "../router";
-import { useStore } from "../store";
+import { selectBootstrapCompleteForActiveEnvironment, useStore } from "../store";
 import { useTerminalStateStore } from "../terminalStateStore";
+import { useUiStateStore } from "../uiStateStore";
 import { BrowserWsRpcHarness, type NormalizedWsRpcRequestBody } from "../../test/wsRpcHarness";
 import { estimateTimelineMessageHeight } from "./timelineHeight";
 import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
 }));
 const THREAD_ID = "thread-browser-test" as ThreadId;
-const UUID_ROUTE_RE = /^\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 const PROJECT_ID = "project-1" as ProjectId;
+const LOCAL_ENVIRONMENT_ID = EnvironmentId.makeUnsafe("environment-local");
+const THREAD_REF = scopeThreadRef(LOCAL_ENVIRONMENT_ID, THREAD_ID);
+const THREAD_KEY = scopedThreadKey(THREAD_REF);
+const UUID_ROUTE_RE = /^\/draft\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const PROJECT_DRAFT_KEY = `${LOCAL_ENVIRONMENT_ID}:${PROJECT_ID}`;
+const PROJECT_KEY = scopedProjectKey(scopeProjectRef(LOCAL_ENVIRONMENT_ID, PROJECT_ID));
 const NOW_ISO = "2026-03-04T12:00:00.000Z";
 const BASE_TIME_MS = Date.parse(NOW_ISO);
 const ATTACHMENT_SVG = "<svg xmlns='http://www.w3.org/2000/svg' width='120' height='120'></svg>";
 function createBaseServerConfig(): ServerConfig {
   return {
+    environment: {
+      environmentId: EnvironmentId.makeUnsafe("environment-local"),
+      label: "Local environment",
+      platform: { os: "darwin" as const, arch: "arm64" as const },
+      serverVersion: "0.0.0-test",
+      capabilities: { repositoryIdentity: true },
+    },
     cwd: "/repo/project",
     keybindingsConfigPath: "/repo/project/.t3code-keybindings.json",
     keybindings: [],
     snapshot,
     serverConfig: createBaseServerConfig(),
     welcome: {
+      environment: {
+        environmentId: EnvironmentId.makeUnsafe("environment-local"),
+        label: "Local environment",
+        platform: { os: "darwin" as const, arch: "arm64" as const },
+        serverVersion: "0.0.0-test",
+        capabilities: { repositoryIdentity: true },
+      },
       cwd: "/repo/project",
       projectName: "Project",
       bootstrapProjectId: PROJECT_ID,
   };
 }
+function createThreadSessionSetEvent(threadId: ThreadId, sequence: number): OrchestrationEvent {
+  return {
+    sequence,
+    eventId: EventId.makeUnsafe(`event-thread-session-set-${sequence}`),
+    aggregateKind: "thread",
+    aggregateId: threadId,
+    occurredAt: NOW_ISO,
+    commandId: null,
+    causationEventId: null,
+    correlationId: null,
+    metadata: {},
+    type: "thread.session-set",
+    payload: {
+      threadId,
+      session: {
+        threadId,
+        status: "running",
+        providerName: "codex",
+        runtimeMode: "full-access",
+        activeTurnId: `turn-${threadId}` as TurnId,
+        lastError: null,
+        updatedAt: NOW_ISO,
+      },
+    },
+  };
+}
 function sendOrchestrationDomainEvent(event: OrchestrationEvent): void {
   rpcHarness.emitStreamValue(WS_METHODS.subscribeOrchestrationDomainEvents, event);
 }
   );
 }
+function threadRefFor(threadId: ThreadId) {
+  return scopeThreadRef(LOCAL_ENVIRONMENT_ID, threadId);
+}
+function threadKeyFor(threadId: ThreadId): string {
+  return scopedThreadKey(threadRefFor(threadId));
+}
+function composerDraftFor(target: string) {
+  const { draftsByThreadKey } = useComposerDraftStore.getState();
+  return draftsByThreadKey[target] ?? draftsByThreadKey[threadKeyFor(target as ThreadId)];
+}
+function draftIdFromPath(pathname: string) {
+  const segments = pathname.split("/");
+  const draftId = segments[segments.length - 1];
+  if (!draftId) {
+    throw new Error(`Expected thread path, received "${pathname}".`);
+  }
+  return DraftId.makeUnsafe(draftId);
+}
+function draftThreadIdFor(draftId: ReturnType<typeof draftIdFromPath>): ThreadId {
+  const draftSession = useComposerDraftStore.getState().getDraftSession(draftId);
+  if (!draftSession) {
+    throw new Error(`Expected draft session for "${draftId}".`);
+  }
+  return draftSession.threadId;
+}
+function serverThreadPath(threadId: ThreadId): string {
+  return `/${LOCAL_ENVIRONMENT_ID}/${threadId}`;
+}
 async function waitForAppBootstrap(): Promise<void> {
   await vi.waitFor(
     () => {
       expect(getServerConfig()).not.toBeNull();
-      expect(useStore.getState().bootstrapComplete).toBe(true);
+      expect(selectBootstrapCompleteForActiveEnvironment(useStore.getState())).toBe(true);
     },
     { timeout: 8_000, interval: 16 },
   );
 }
-async function promoteDraftThreadViaDomainEvent(threadId: ThreadId): Promise<void> {
+async function materializePromotedDraftThreadViaDomainEvent(threadId: ThreadId): Promise<void> {
   await waitForWsClient();
   fixture.snapshot = addThreadToSnapshot(fixture.snapshot, threadId);
   sendOrchestrationDomainEvent(
     createThreadCreatedEvent(threadId, fixture.snapshot.snapshotSequence),
   );
+}
+async function startPromotedServerThreadViaDomainEvent(threadId: ThreadId): Promise<void> {
+  sendOrchestrationDomainEvent(
+    createThreadSessionSetEvent(threadId, fixture.snapshot.snapshotSequence + 1),
+  );
+}
+async function promoteDraftThreadViaDomainEvent(threadId: ThreadId): Promise<void> {
+  await materializePromotedDraftThreadViaDomainEvent(threadId);
+  await startPromotedServerThreadViaDomainEvent(threadId);
   await vi.waitFor(
     () => {
-      expect(useComposerDraftStore.getState().draftThreadsByThreadId[threadId]).toBeUndefined();
+      expect(useComposerDraftStore.getState().draftThreadsByThreadKey[threadKeyFor(threadId)]).toBe(
+        undefined,
+      );
     },
     { timeout: 8_000, interval: 16 },
   );
 function setDraftThreadWithoutWorktree(): void {
   useComposerDraftStore.setState({
-    draftThreadsByThreadId: {
+    draftThreadsByThreadKey: {
-      [THREAD_ID]: {
+      [THREAD_KEY]: {
+        threadId: THREAD_ID,
+        environmentId: LOCAL_ENVIRONMENT_ID,
         projectId: PROJECT_ID,
+        logicalProjectKey: PROJECT_DRAFT_KEY,
         createdAt: NOW_ISO,
         runtimeMode: "full-access",
         interactionMode: "default",
         envMode: "local",
       },
     },
-    projectDraftThreadIdByProjectId: {
+    logicalProjectDraftThreadKeyByLogicalProjectKey: {
-      [PROJECT_ID]: THREAD_ID,
+      [PROJECT_DRAFT_KEY]: THREAD_KEY,
     },
   });
 }
   };
 }
-function createSnapshotWithPendingUserInput(options?: {
+function createSnapshotWithPendingUserInput(): OrchestrationReadModel {
-  questions?: ReadonlyArray<UserInputQuestion>;
-}): OrchestrationReadModel {
   const snapshot = createSnapshotForTargetUser({
     targetMessageId: "msg-user-pending-input-target" as MessageId,
     targetText: "question thread",
   });
-  const questions =
-    options?.questions ??
-    ([
-      {
-        id: "scope",
-        header: "Scope",
-        question: "What should this change cover?",
-        options: [
-          {
-            label: "Tight",
-            description: "Touch only the footer layout logic.",
-          },
-          {
-            label: "Broad",
-            description: "Also adjust the related composer controls.",
-          },
-        ],
-        multiSelect: false,
-      },
-      {
-        id: "risk",
-        header: "Risk",
-        question: "How aggressive should the imaginary plan be?",
-        options: [
-          {
-            label: "Conservative",
-            description: "Favor reliability and low-risk changes.",
-          },
-          {
-            label: "Balanced",
-            description: "Mix quick wins with one structural improvement.",
-          },
-        ],
-        multiSelect: false,
-      },
-    ] satisfies ReadonlyArray<UserInputQuestion>);
   return {
     ...snapshot,
     threads: snapshot.threads.map((thread) =>
                 summary: "User input requested",
                 payload: {
                   requestId: "req-browser-user-input",
-                  questions,
+                  questions: [
+                    {
+                      id: "scope",
+                      header: "Scope",
+                      question: "What should this change cover?",
+                      options: [
+                        {
+                          label: "Tight",
+                          description: "Touch only the footer layout logic.",
+                        },
+                        {
+                          label: "Broad",
+                          description: "Also adjust the related composer controls.",
+                        },
+                      ],
+                    },
+                    {
+                      id: "risk",
+                      header: "Risk",
+                      question: "How aggressive should the imaginary plan be?",
+                      options: [
+                        {
+                          label: "Conservative",
+                          description: "Favor reliability and low-risk changes.",
+                        },
+                        {
+                          label: "Balanced",
+                          description: "Mix quick wins with one structural improvement.",
+                        },
+                      ],
+                    },
+                  ],
                 },
                 turnId: null,
                 sequence: 1,
   const router = getRouter(
     createMemoryHistory({
-      initialEntries: [`/${THREAD_ID}`],
+      initialEntries: [`/${LOCAL_ENVIRONMENT_ID}/${THREAD_ID}`],
     }),
   );
         return [];
       },
     });
-    await __resetNativeApiForTests();
+    await __resetLocalApiForTests();
     await setViewport(DEFAULT_VIEWPORT);
     localStorage.clear();
     document.body.innerHTML = "";
     wsRequests.length = 0;
     customWsRpcResolver = null;
     useComposerDraftStore.setState({
-      draftsByThreadId: {},
+      draftsByThreadKey: {},
-      draftThreadsByThreadId: {},
+      draftThreadsByThreadKey: {},
-      projectDraftThreadIdByProjectId: {},
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
       stickyModelSelectionByProvider: {},
       stickyActiveProvider: null,
     });
     useStore.setState({
-      projectIds: [],
+      activeEnvironmentId: null,
-      projectById: {},
+      environmentStateById: {},
-      threadIds: [],
+    });
-      threadIdsByProjectId: {},
+    useUiStateStore.setState({
-      threadShellById: {},
+      projectExpandedById: {},
-      threadSessionById: {},
+      projectOrder: [],
-      threadTurnStateById: {},
+      threadLastVisitedAtById: {},
-      messageIdsByThreadId: {},
-      messageByThreadId: {},
-      activityIdsByThreadId: {},
-      activityByThreadId: {},
-      proposedPlanIdsByThreadId: {},
-      proposedPlanByThreadId: {},
-      turnDiffIdsByThreadId: {},
-      turnDiffSummaryByThreadId: {},
-      sidebarThreadSummaryById: {},
-      bootstrapComplete: false,
     });
     useTerminalStateStore.persist.clearStorage();
     useTerminalStateStore.setState({
-      terminalStateByThreadId: {},
+      terminalStateByThreadKey: {},
-      terminalLaunchContextByThreadId: {},
+      terminalLaunchContextByThreadKey: {},
       terminalEventEntriesByKey: {},
       nextTerminalEventId: 1,
     });
     },
   );
+  it("re-expands the bootstrap project using its scoped key", async () => {
+    useUiStateStore.setState({
+      projectExpandedById: {
+        [PROJECT_KEY]: false,
+      },
+      projectOrder: [PROJECT_KEY],
+      threadLastVisitedAtById: {},
+    });
+    const mounted = await mountChatView({
+      viewport: DEFAULT_VIEWPORT,
+      snapshot: createSnapshotForTargetUser({
+        targetMessageId: "msg-user-bootstrap-project-expand" as MessageId,
+        targetText: "bootstrap project expand",
+      }),
+    });
+    try {
+      await vi.waitFor(
+        () => {
+          expect(useUiStateStore.getState().projectExpandedById[PROJECT_KEY]).toBe(true);
+        },
+        { timeout: 8_000, interval: 16 },
+      );
+    } finally {
+      await mounted.cleanup();
+    }
+  });
   it("tracks wrapping parity while resizing an existing ChatView across the viewport matrix", async () => {
     const userText = "x".repeat(3_200);
     const targetMessageId = "msg-user-target-resize" as MessageId;
     }
     useTerminalStateStore.setState({
-      terminalStateByThreadId: {
+      terminalStateByThreadKey: {
-        [THREAD_ID]: {
+        [THREAD_KEY]: {
           terminalOpen: true,
           terminalHeight: 280,
           terminalIds: ["default"],
           activeTerminalGroupId: "group-default",
         },
       },
-      terminalLaunchContextByThreadId: {
+      terminalLaunchContextByThreadKey: {
-        [THREAD_ID]: {
+        [THREAD_KEY]: {
           cwd: "/repo/project",
           worktreePath: null,
         },
   it("runs project scripts from local draft threads at the project cwd", async () => {
     useComposerDraftStore.setState({
-      draftThreadsByThreadId: {
+      draftThreadsByThreadKey: {
-        [THREAD_ID]: {
+        [THREAD_KEY]: {
+          threadId: THREAD_ID,
+          environmentId: LOCAL_ENVIRONMENT_ID,
           projectId: PROJECT_ID,
+          logicalProjectKey: PROJECT_DRAFT_KEY,
           createdAt: NOW_ISO,
           runtimeMode: "full-access",
           interactionMode: "default",
           envMode: "local",
         },
       },
-      projectDraftThreadIdByProjectId: {
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {
-        [PROJECT_ID]: THREAD_ID,
+        [PROJECT_DRAFT_KEY]: THREAD_KEY,
       },
     });
   it("runs project scripts from worktree draft threads at the worktree cwd", async () => {
     useComposerDraftStore.setState({
-      draftThreadsByThreadId: {
+      draftThreadsByThreadKey: {
-        [THREAD_ID]: {
+        [THREAD_KEY]: {
+          threadId: THREAD_ID,
+          environmentId: LOCAL_ENVIRONMENT_ID,
           projectId: PROJECT_ID,
+          logicalProjectKey: PROJECT_DRAFT_KEY,
           createdAt: NOW_ISO,
           runtimeMode: "full-access",
           interactionMode: "default",
           envMode: "worktree",
         },
       },
-      projectDraftThreadIdByProjectId: {
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {
-        [PROJECT_ID]: THREAD_ID,
+        [PROJECT_DRAFT_KEY]: THREAD_KEY,
       },
     });
   it("lets the server own setup after preparing a pull request worktree thread", async () => {
     useComposerDraftStore.setState({
-      draftThreadsByThreadId: {
+      draftThreadsByThreadKey: {
-        [THREAD_ID]: {
+        [THREAD_KEY]: {
+          threadId: THREAD_ID,
+          environmentId: LOCAL_ENVIRONMENT_ID,
           projectId: PROJECT_ID,
+          logicalProjectKey: PROJECT_DRAFT_KEY,
           createdAt: NOW_ISO,
           runtimeMode: "full-access",
           interactionMode: "default",
           envMode: "local",
         },
       },
-      projectDraftThreadIdByProjectId: {
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {
-        [PROJECT_ID]: THREAD_ID,
+        [PROJECT_DRAFT_KEY]: THREAD_KEY,
       },
     });
   it("sends bootstrap turn-starts and waits for server setup on first-send worktree drafts", async () => {
     useTerminalStateStore.setState({
-      terminalStateByThreadId: {},
+      terminalStateByThreadKey: {},
     });
     useComposerDraftStore.setState({
-      draftThreadsByThreadId: {
+      draftThreadsByThreadKey: {
-        [THREAD_ID]: {
+        [THREAD_KEY]: {
+          threadId: THREAD_ID,
+          environmentId: LOCAL_ENVIRONMENT_ID,
           projectId: PROJECT_ID,
+          logicalProjectKey: PROJECT_DRAFT_KEY,
           createdAt: NOW_ISO,
           runtimeMode: "full-access",
           interactionMode: "default",
           envMode: "worktree",
         },
       },
-      projectDraftThreadIdByProjectId: {
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {
-        [PROJECT_ID]: THREAD_ID,
+        [PROJECT_DRAFT_KEY]: THREAD_KEY,
       },
     });
     });
     try {
-      useComposerDraftStore.getState().setPrompt(THREAD_ID, "Ship it");
+      useComposerDraftStore.getState().setPrompt(THREAD_REF, "Ship it");
       await waitForLayout();
       const sendButton = await waitForSendButton();
   it("shows the send state once bootstrap dispatch is in flight", async () => {
     useTerminalStateStore.setState({
-      terminalStateByThreadId: {},
+      terminalStateByThreadKey: {},
     });
     useComposerDraftStore.setState({
-      draftThreadsByThreadId: {
+      draftThreadsByThreadKey: {
-        [THREAD_ID]: {
+        [THREAD_KEY]: {
+          threadId: THREAD_ID,
+          environmentId: LOCAL_ENVIRONMENT_ID,
           projectId: PROJECT_ID,
+          logicalProjectKey: PROJECT_DRAFT_KEY,
           createdAt: NOW_ISO,
           runtimeMode: "full-access",
           interactionMode: "default",
           envMode: "worktree",
         },
       },
-      projectDraftThreadIdByProjectId: {
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {
-        [PROJECT_ID]: THREAD_ID,
+        [PROJECT_DRAFT_KEY]: THREAD_KEY,
       },
     });
     });
     try {
-      useComposerDraftStore.getState().setPrompt(THREAD_ID, "Ship it");
+      useComposerDraftStore.getState().setPrompt(THREAD_REF, "Ship it");
       await waitForLayout();
       const sendButton = await waitForSendButton();
     const removedLabel = "Terminal 1 lines 1-2";
     const addedLabel = "Terminal 2 lines 9-10";
     useComposerDraftStore.getState().addTerminalContext(
-      THREAD_ID,
+      THREAD_REF,
       createTerminalContext({
         id: "ctx-removed",
         terminalLabel: "Terminal 1",
       );
       const store = useComposerDraftStore.getState();
-      const currentPrompt = store.draftsByThreadId[THREAD_ID]?.prompt ?? "";
+      const currentPrompt = store.draftsByThreadKey[THREAD_KEY]?.prompt ?? "";
       const nextPrompt = removeInlineTerminalContextPlaceholder(currentPrompt, 0);
-      store.setPrompt(THREAD_ID, nextPrompt.prompt);
+      store.setPrompt(THREAD_REF, nextPrompt.prompt);
-      store.removeTerminalContext(THREAD_ID, "ctx-removed");
+      store.removeTerminalContext(THREAD_REF, "ctx-removed");
       await vi.waitFor(
         () => {
-          expect(useComposerDraftStore.getState().draftsByThreadId[THREAD_ID]).toBeUndefined();
+          expect(useComposerDraftStore.getState().draftsByThreadKey[THREAD_KEY]).toBeUndefined();
           expect(document.body.textContent).not.toContain(removedLabel);
         },
         { timeout: 8_000, interval: 16 },
       );
       useComposerDraftStore.getState().addTerminalContext(
-        THREAD_ID,
+        THREAD_REF,
         createTerminalContext({
           id: "ctx-added",
           terminalLabel: "Terminal 2",
       await vi.waitFor(
         () => {
-          const draft = useComposerDraftStore.getState().draftsByThreadId[THREAD_ID];
+          const draft = useComposerDraftStore.getState().draftsByThreadKey[THREAD_KEY];
           expect(draft?.terminalContexts.map((context) => context.id)).toEqual(["ctx-added"]);
           expect(document.body.textContent).toContain(addedLabel);
           expect(document.body.textContent).not.toContain(removedLabel);
   it("disables send when the composer only contains an expired terminal pill", async () => {
     const expiredLabel = "Terminal 1 line 4";
     useComposerDraftStore.getState().addTerminalContext(
-      THREAD_ID,
+      THREAD_REF,
       createTerminalContext({
         id: "ctx-expired-only",
         terminalLabel: "Terminal 1",
   it("warns when sending text while omitting expired terminal pills", async () => {
     const expiredLabel = "Terminal 1 line 4";
     useComposerDraftStore.getState().addTerminalContext(
-      THREAD_ID,
+      THREAD_REF,
       createTerminalContext({
         id: "ctx-expired-send-warning",
         terminalLabel: "Terminal 1",
     );
     useComposerDraftStore
       .getState()
-      .setPrompt(THREAD_ID, `yoo${INLINE_TERMINAL_CONTEXT_PLACEHOLDER}waddup`);
+      .setPrompt(THREAD_REF, `yoo${INLINE_TERMINAL_CONTEXT_PLACEHOLDER}waddup`);
     const mounted = await mountChatView({
       viewport: DEFAULT_VIEWPORT,
     }
   });
-  it("keeps the new thread selected after clicking the new-thread button", async () => {
+  it("canonicalizes promoted draft threads to the server thread route", async () => {
     const mounted = await mountChatView({
       viewport: DEFAULT_VIEWPORT,
       snapshot: createSnapshotForTargetUser({
         (path) => UUID_ROUTE_RE.test(path),
         "Route should have changed to a new draft thread UUID.",
       );
-      const newThreadId = newThreadPath.slice(1) as ThreadId;
+      const newDraftId = draftIdFromPath(newThreadPath);
+      const newThreadId = draftThreadIdFor(newDraftId);
       // The composer editor should be present for the new draft thread.
       await waitForComposerEditor();
-      // Simulate the steady-state promotion path: the server emits
+      // `thread.created` should only mark the draft as promoting; it should
-      // `thread.created`, the client materializes the thread incrementally,
+      // not navigate away until the server thread has actual runtime state.
-      // and the draft is cleared by live batch effects.
+      await materializePromotedDraftThreadViaDomainEvent(newThreadId);
-      await promoteDraftThreadViaDomainEvent(newThreadId);
+      expect(mounted.router.state.location.pathname).toBe(newThreadPath);
+      await expect.element(page.getByTestId("composer-editor")).toBeInTheDocument();
+      // Once the server thread starts, the route should canonicalize.
+      await startPromotedServerThreadViaDomainEvent(newThreadId);
+      await vi.waitFor(
+        () => {
+          expect(useComposerDraftStore.getState().draftThreadsByThreadKey[newDraftId]).toBe(
+            undefined,
+          );
+        },
+        { timeout: 8_000, interval: 16 },
+      );
-      // The route should still be on the new thread — not redirected away.
+      // The route should switch to the canonical server thread path.
       await waitForURL(
         mounted.router,
-        (path) => path === newThreadPath,
+        (path) => path === serverThreadPath(newThreadId),
-        "New thread should remain selected after server thread promotion clears the draft.",
+        "Promoted drafts should canonicalize to the server thread route.",
       );
       // The empty thread view and composer should still be visible.
     }
   });
+  it("canonicalizes stale promoted draft routes to the server thread route", async () => {
+    const mounted = await mountChatView({
+      viewport: DEFAULT_VIEWPORT,
+      snapshot: createSnapshotForTargetUser({
+        targetMessageId: "msg-user-draft-hydration-race-test" as MessageId,
+        targetText: "draft hydration race test",
+      }),
+    });
+    try {
+      const newThreadButton = page.getByTestId("new-thread-button");
+      await expect.element(newThreadButton).toBeInTheDocument();
+      await newThreadButton.click();
+      const newThreadPath = await waitForURL(
+        mounted.router,
+        (path) => UUID_ROUTE_RE.test(path),
+        "Route should have changed to a new draft thread UUID.",
+      );
+      const newDraftId = draftIdFromPath(newThreadPath);
+      const newThreadId = draftThreadIdFor(newDraftId);
+      await promoteDraftThreadViaDomainEvent(newThreadId);
+      await mounted.router.navigate({
+        to: "/draft/$draftId",
+        params: { draftId: newDraftId },
+      });
+      await waitForURL(
+        mounted.router,
+        (path) => path === serverThreadPath(newThreadId),
+        "Stale promoted draft routes should canonicalize to the server thread path.",
+      );
+      await expect.element(page.getByTestId("composer-editor")).toBeInTheDocument();
+    } finally {
+      await mounted.cleanup();
+    }
+  });
   it("snapshots sticky codex settings into a new draft thread", async () => {
     useComposerDraftStore.setState({
       stickyModelSelectionByProvider: {
         (path) => UUID_ROUTE_RE.test(path),
         "Route should have changed to a new draft thread UUID.",
       );
-      const newThreadId = newThreadPath.slice(1) as ThreadId;
+      const newDraftId = draftIdFromPath(newThreadPath);
-      expect(useComposerDraftStore.getState().draftsByThreadId[newThreadId]).toMatchObject({
+      expect(composerDraftFor(newDraftId)).toMatchObject({
         modelSelectionByProvider: {
           codex: {
             provider: "codex",
         (path) => UUID_ROUTE_RE.test(path),
         "Route should have changed to a new sticky claude draft thread UUID.",
       );
-      const newThreadId = newThreadPath.slice(1) as ThreadId;
+      const newDraftId = draftIdFromPath(newThreadPath);
-      expect(useComposerDraftStore.getState().draftsByThreadId[newThreadId]).toMatchObject({
+      expect(composerDraftFor(newDraftId)).toMatchObject({
         modelSelectionByProvider: {
           claudeAgent: {
             provider: "claudeAgent",
         (path) => UUID_ROUTE_RE.test(path),
         "Route should have changed to a new draft thread UUID.",
       );
-      const newThreadId = newThreadPath.slice(1) as ThreadId;
+      const newDraftId = draftIdFromPath(newThreadPath);
-      expect(useComposerDraftStore.getState().draftsByThreadId[newThreadId]).toBeUndefined();
+      expect(composerDraftFor(newDraftId)).toBe(undefined);
     } finally {
       await mounted.cleanup();
     }
         (path) => UUID_ROUTE_RE.test(path),
         "Route should have changed to a sticky draft thread UUID.",
       );
-      const threadId = threadPath.slice(1) as ThreadId;
+      const draftId = draftIdFromPath(threadPath);
-      expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toMatchObject({
+      expect(composerDraftFor(draftId)).toMatchObject({
         modelSelectionByProvider: {
           codex: {
             provider: "codex",
         activeProvider: "codex",
       });
-      useComposerDraftStore.getState().setModelSelection(threadId, {
+      useComposerDraftStore.getState().setModelSelection(draftId, {
         provider: "codex",
         model: "gpt-5.4",
         options: {
         (path) => path === threadPath,
         "New-thread should reuse the existing project draft thread.",
       );
-      expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toMatchObject({
+      expect(composerDraftFor(draftId)).toMatchObject({
         modelSelectionByProvider: {
           codex: {
             provider: "codex",
         (path) => UUID_ROUTE_RE.test(path),
         "Route should have changed to a promoted draft thread UUID.",
       );
-      const promotedThreadId = promotedThreadPath.slice(1) as ThreadId;
+      const promotedDraftId = draftIdFromPath(promotedThreadPath);
+      const promotedThreadId = draftThreadIdFor(promotedDraftId);
       await promoteDraftThreadViaDomainEvent(promotedThreadId);
     }
   });
-  it("does not trigger numeric option shortcuts while the composer is focused", async () => {
+  it("submits pending user input after the final option selection resolves the draft answers", async () => {
     const mounted = await mountChatView({
-      viewport: WIDE_FOOTER_VIEWPORT,
+      viewport: DEFAULT_VIEWPORT,
       snapshot: createSnapshotWithPendingUserInput(),
-    });
-    try {
-      const composerEditor = await waitForComposerEditor();
-      composerEditor.focus();
-      const event = new KeyboardEvent("keydown", {
-        key: "2",
-        bubbles: true,
-        cancelable: true,
-      });
-      composerEditor.dispatchEvent(event);
-      await waitForLayout();
-      expect(event.defaultPrevented).toBe(false);
-      expect(document.body.textContent).toContain("What should this change cover?");
-      expect(document.body.textContent).not.toContain(
-        "How aggressive should the imaginary plan be?",
-      );
-      await waitForButtonByText("Next question");
-    } finally {
-      await mounted.cleanup();
-    }
-  });
-  it("submits multi-select questionnaire answers as arrays", async () => {
-    const mounted = await mountChatView({
-      viewport: WIDE_FOOTER_VIEWPORT,
-      snapshot: createSnapshotWithPendingUserInput({
-        questions: [
-          {
-            id: "scope",
-            header: "Scope",
-            question: "Which areas should this change cover?",
-            options: [
-              {
-                label: "Server",
-                description: "Touch server orchestration.",
-              },
-              {
-                label: "Web",
-                description: "Touch the browser UI.",
-              },
-            ],
-            multiSelect: true,
-          },
-          {
-            id: "risk",
-            header: "Risk",
-            question: "How aggressive should the imaginary plan be?",
-            options: [
-              {
-                label: "Balanced",
-                description: "Mix quick wins with one structural improvement.",
-              },
-            ],
-            multiSelect: false,
-          },
-        ],
-      }),
       resolveRpc: (body) => {
         if (body._tag === ORCHESTRATION_WS_METHODS.dispatchCommand) {
           return {
     });
     try {
-      const serverOption = await waitForButtonContainingText("Server");
+      const firstOption = await waitForButtonContainingText("Tight");
-      serverOption.click();
+      firstOption.click();
-      await waitForLayout();
-      expect(document.body.textContent).toContain("Which areas should this change cover?");
-      const webOption = await waitForButtonContainingText("Web");
-      webOption.click();
-      await waitForLayout();
-      expect(document.body.textContent).toContain("Which areas should this change cover?");
-      const nextButton = await waitForButtonByText("Next question");
-      expect(nextButton.disabled).toBe(false);
-      nextButton.click();
-      await vi.waitFor(
-        () => {
-          expect(document.body.textContent).toContain(
-            "How aggressive should the imaginary plan be?",
-          );
-        },
-        { timeout: 8_000, interval: 16 },
-      );
-      const balancedOption = await waitForButtonContainingText("Balanced");
-      balancedOption.click();
-      const submitButton = await waitForButtonByText("Submit answers");
+      const finalOption = await waitForButtonContainingText("Conservative");
-      expect(submitButton.disabled).toBe(false);
+      finalOption.click();
-      submitButton.click();
       await vi.waitFor(
         () => {
             | {
                 _tag: string;
                 type?: string;
+                requestId?: string;
                 answers?: Record<string, unknown>;
               }
             | undefined;
           expect(dispatchRequest).toMatchObject({
             _tag: ORCHESTRATION_WS_METHODS.dispatchCommand,
             type: "thread.user-input.respond",
+            requestId: "req-browser-user-input",
             answers: {
-              scope: ["Server", "Web"],
+              scope: "Tight",
-              risk: "Balanced",
+              risk: "Conservative",
             },
           });
         },

apps/web/src/components/ChatView.logic.test.ts+57−7

-import { ProjectId, ThreadId, TurnId } from "@t3tools/contracts";
+import { scopeThreadRef } from "@t3tools/client-runtime";
+import { EnvironmentId, ProjectId, ThreadId, TurnId } from "@t3tools/contracts";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { useStore } from "../store";
+import { type EnvironmentState, useStore } from "../store";
 import { type Thread } from "../types";
 import {
   deriveComposerSendState,
   hasServerAcknowledgedLocalDispatch,
   reconcileMountedTerminalThreadIds,
+  shouldWriteThreadErrorToCurrentServerThread,
   waitForStartedServerThread,
 } from "./ChatView.logic";
+const localEnvironmentId = EnvironmentId.makeUnsafe("environment-local");
 describe("deriveComposerSendState", () => {
   it("treats expired terminal pills as non-sendable content", () => {
     const state = deriveComposerSendState({
   });
 });
+describe("shouldWriteThreadErrorToCurrentServerThread", () => {
+  it("routes errors to the active server thread when route and target match", () => {
+    const threadId = ThreadId.makeUnsafe("thread-1");
+    const routeThreadRef = scopeThreadRef(localEnvironmentId, threadId);
+    expect(
+      shouldWriteThreadErrorToCurrentServerThread({
+        serverThread: {
+          environmentId: localEnvironmentId,
+          id: threadId,
+        },
+        routeThreadRef,
+        targetThreadId: threadId,
+      }),
+    ).toBe(true);
+  });
+  it("does not route draft-thread errors into server-backed state", () => {
+    const threadId = ThreadId.makeUnsafe("thread-1");
+    expect(
+      shouldWriteThreadErrorToCurrentServerThread({
+        serverThread: undefined,
+        routeThreadRef: scopeThreadRef(localEnvironmentId, threadId),
+        targetThreadId: threadId,
+      }),
+    ).toBe(false);
+  });
+});
 const makeThread = (input?: {
   id?: ThreadId;
   latestTurn?: {
   } | null;
 }): Thread => ({
   id: input?.id ?? ThreadId.makeUnsafe("thread-1"),
+  environmentId: localEnvironmentId,
   codexThreadId: null,
   projectId: ProjectId.makeUnsafe("project-1"),
   title: "Thread",
 function setStoreThreads(threads: ReadonlyArray<ReturnType<typeof makeThread>>) {
   const projectId = ProjectId.makeUnsafe("project-1");
-  useStore.setState({
+  const environmentState: EnvironmentState = {
     projectIds: [projectId],
     projectById: {
       [projectId]: {
         id: projectId,
+        environmentId: localEnvironmentId,
         name: "Project",
         cwd: "/tmp/project",
         defaultModelSelection: {
         thread.id,
         {
           id: thread.id,
+          environmentId: thread.environmentId,
           codexThreadId: thread.codexThreadId,
           projectId: thread.projectId,
           title: thread.title,
     ),
     sidebarThreadSummaryById: {},
     bootstrapComplete: true,
+  };
+  useStore.setState({
+    activeEnvironmentId: localEnvironmentId,
+    environmentStateById: {
+      [localEnvironmentId]: environmentState,
+    },
   });
 }
       }),
     ]);
-    await expect(waitForStartedServerThread(threadId)).resolves.toBe(true);
+    await expect(
+      waitForStartedServerThread(scopeThreadRef(localEnvironmentId, threadId)),
+    ).resolves.toBe(true);
   });
   it("waits for the thread to start via subscription updates", async () => {
     const threadId = ThreadId.makeUnsafe("thread-wait");
     setStoreThreads([makeThread({ id: threadId })]);
-    const promise = waitForStartedServerThread(threadId, 500);
+    const promise = waitForStartedServerThread(scopeThreadRef(localEnvironmentId, threadId), 500);
     setStoreThreads([
       makeThread({
       return originalSubscribe(listener);
     });
-    await expect(waitForStartedServerThread(threadId, 500)).resolves.toBe(true);
+    await expect(
+      waitForStartedServerThread(scopeThreadRef(localEnvironmentId, threadId), 500),
+    ).resolves.toBe(true);
   });
   it("returns false after the timeout when the thread never starts", async () => {
     const threadId = ThreadId.makeUnsafe("thread-timeout");
     setStoreThreads([makeThread({ id: threadId })]);
-    const promise = waitForStartedServerThread(threadId, 500);
+    const promise = waitForStartedServerThread(scopeThreadRef(localEnvironmentId, threadId), 500);
     await vi.advanceTimersByTimeAsync(500);
   it("does not clear local dispatch before server state changes", () => {
     const localDispatch = createLocalDispatchSnapshot({
       id: ThreadId.makeUnsafe("thread-1"),
+      environmentId: localEnvironmentId,
       codexThreadId: null,
       projectId,
       title: "Thread",
   it("clears local dispatch when a new turn is already settled", () => {
     const localDispatch = createLocalDispatchSnapshot({
       id: ThreadId.makeUnsafe("thread-1"),
+      environmentId: localEnvironmentId,
       codexThreadId: null,
       projectId,
       title: "Thread",
   it("clears local dispatch when the session changes without an observed running phase", () => {
     const localDispatch = createLocalDispatchSnapshot({
       id: ThreadId.makeUnsafe("thread-1"),
+      environmentId: localEnvironmentId,
       codexThreadId: null,
       projectId,
       title: "Thread",

apps/web/src/components/ChatView.logic.ts+36−9

-import { ProjectId, type ModelSelection, type ThreadId, type TurnId } from "@t3tools/contracts";
+import {
+  type EnvironmentId,
+  ProjectId,
+  type ModelSelection,
+  type ScopedThreadRef,
+  type ThreadId,
+  type TurnId,
+} from "@t3tools/contracts";
 import { type ChatMessage, type SessionPhase, type Thread, type ThreadSession } from "../types";
 import { randomUUID } from "~/lib/utils";
 import { type ComposerImageAttachment, type DraftThreadState } from "../composerDraftStore";
 import { Schema } from "effect";
-import { selectThreadById, useStore } from "../store";
+import { selectThreadByRef, useStore } from "../store";
 import {
   filterTerminalContextsWithText,
   stripInlineTerminalContextPlaceholders,
 ): Thread {
   return {
     id: threadId,
+    environmentId: draftThread.environmentId,
     codexThreadId: null,
     projectId: draftThread.projectId,
     title: "New thread",
   };
 }
+export function shouldWriteThreadErrorToCurrentServerThread(input: {
+  serverThread:
+    | {
+        environmentId: EnvironmentId;
+        id: ThreadId;
+      }
+    | null
+    | undefined;
+  routeThreadRef: ScopedThreadRef;
+  targetThreadId: ThreadId;
+}): boolean {
+  return Boolean(
+    input.serverThread &&
+    input.targetThreadId === input.routeThreadRef.threadId &&
+    input.serverThread.environmentId === input.routeThreadRef.environmentId &&
+    input.serverThread.id === input.targetThreadId,
+  );
+}
 export function reconcileMountedTerminalThreadIds(input: {
-  currentThreadIds: ReadonlyArray<ThreadId>;
+  currentThreadIds: ReadonlyArray<string>;
-  openThreadIds: ReadonlyArray<ThreadId>;
+  openThreadIds: ReadonlyArray<string>;
-  activeThreadId: ThreadId | null;
+  activeThreadId: string | null;
   activeThreadTerminalOpen: boolean;
   maxHiddenThreadCount?: number;
-}): ThreadId[] {
+}): string[] {
   const openThreadIdSet = new Set(input.openThreadIds);
   const hiddenThreadIds = input.currentThreadIds.filter(
     (threadId) => threadId !== input.activeThreadId && openThreadIdSet.has(threadId),
 }
 export async function waitForStartedServerThread(
-  threadId: ThreadId,
+  threadRef: ScopedThreadRef,
   timeoutMs = 1_000,
 ): Promise<boolean> {
-  const getThread = () => selectThreadById(threadId)(useStore.getState());
+  const getThread = () => selectThreadByRef(useStore.getState(), threadRef);
   const thread = getThread();
   if (threadHasStarted(thread)) {
     };
     const unsubscribe = useStore.subscribe((state) => {
-      if (!threadHasStarted(selectThreadById(threadId)(state))) {
+      if (!threadHasStarted(selectThreadByRef(state, threadRef))) {
         return;
       }
       finish(true);

apps/web/src/components/ChatView.tsx+522−254

@@ -2,6 +2,7 @@ import { · 1 unmodified line
2	type ApprovalRequestId,	2	type ApprovalRequestId,
3	DEFAULT_MODEL_BY_PROVIDER,	3	DEFAULT_MODEL_BY_PROVIDER,
4	type ClaudeCodeEffort,	4	type ClaudeCodeEffort,
		5	type EnvironmentId,
5	type MessageId,	6	type MessageId,
6	type ModelSelection,	7	type ModelSelection,
7	type ProjectScript,	8	type ProjectScript,
@@ -12,6 +13,7 @@ import { · 4 unmodified lines
12	PROVIDER_SEND_TURN_MAX_ATTACHMENTS,	13	PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
13	PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,	14	PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
14	type ServerProvider,	15	type ServerProvider,
		16	type ScopedThreadRef,
15	type ThreadId,	17	type ThreadId,
16	type TurnId,	18	type TurnId,
17	type KeybindingCommand,	19	type KeybindingCommand,
@@ -20,6 +22,12 @@ import { · 2 unmodified lines
20	RuntimeMode,	22	RuntimeMode,
21	TerminalOpenInput,	23	TerminalOpenInput,
22	} from "@t3tools/contracts";	24	} from "@t3tools/contracts";
		25	import {
		26	parseScopedThreadKey,
		27	scopedThreadKey,
		28	scopeProjectRef,
		29	scopeThreadRef,
		30	} from "@t3tools/client-runtime";
23	import { applyClaudePromptEffortPrefix, normalizeModelSlug } from "@t3tools/shared/model";	31	import { applyClaudePromptEffortPrefix, normalizeModelSlug } from "@t3tools/shared/model";
24	import { projectScriptCwd, projectScriptRuntimeEnv } from "@t3tools/shared/projectScripts";	32	import { projectScriptCwd, projectScriptRuntimeEnv } from "@t3tools/shared/projectScripts";
25	import { truncate } from "@t3tools/shared/String";	33	import { truncate } from "@t3tools/shared/String";
@@ -27,9 +35,12 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr · 1 unmodified line
27	import { useQuery } from "@tanstack/react-query";	35	import { useQuery } from "@tanstack/react-query";
28	import { useDebouncedValue } from "@tanstack/react-pacer";	36	import { useDebouncedValue } from "@tanstack/react-pacer";
29	import { useNavigate, useSearch } from "@tanstack/react-router";	37	import { useNavigate, useSearch } from "@tanstack/react-router";
		38	import { useShallow } from "zustand/react/shallow";
30	import { useGitStatus } from "~/lib/gitStatusState";	39	import { useGitStatus } from "~/lib/gitStatusState";
31	import { projectSearchEntriesQueryOptions } from "~/lib/projectReactQuery";	40	import { projectSearchEntriesQueryOptions } from "~/lib/projectReactQuery";
		41	import { readEnvironmentApi } from "../environmentApi";
32	import { isElectron } from "../env";	42	import { isElectron } from "../env";
		43	import { readLocalApi } from "../localApi";
33	import { parseDiffRouteSearch, stripDiffSearchParams } from "../diffRouteSearch";	44	import { parseDiffRouteSearch, stripDiffSearchParams } from "../diffRouteSearch";
34	import {	45	import {
35	clampCollapsedComposerCursor,	46	clampCollapsedComposerCursor,
@@ -64,8 +75,8 @@ import { · 28 unmodified lines
64	togglePendingUserInputOptionSelection,	75	togglePendingUserInputOptionSelection,
65	type PendingUserInputDraftAnswer,	76	type PendingUserInputDraftAnswer,
66	} from "../pendingUserInput";	77	} from "../pendingUserInput";
67	import { useStore } from "../store";	78	import { selectThreadsAcrossEnvironments, useStore } from "../store";
68	import { createThreadSelector } from "../storeSelectors";	79	import { createProjectSelectorByRef, createThreadSelectorByRef } from "../storeSelectors";
69	import { useUiStateStore } from "../uiStateStore";	80	import { useUiStateStore } from "../uiStateStore";
70	import {	81	import {
71	buildPlanImplementationThreadTitle,	82	buildPlanImplementationThreadTitle,
@@ -114,8 +125,7 @@ import { · 42 unmodified lines
114	projectScriptIdFromCommand,	125	projectScriptIdFromCommand,
115	} from "~/projectScripts";	126	} from "~/projectScripts";
116	import { SidebarTrigger } from "./ui/sidebar";	127	import { SidebarTrigger } from "./ui/sidebar";
117	import { newCommandId, newMessageId, newThreadId } from "~/lib/utils";	128	import { newCommandId, newDraftId, newMessageId, newThreadId } from "~/lib/utils";
118	import { readNativeApi } from "~/nativeApi";
119	import {	129	import {
120	getProviderModelCapabilities,	130	getProviderModelCapabilities,
121	getProviderModels,	131	getProviderModels,
@@ -124,6 +134,8 @@ import { · 2 unmodified lines
124	import { useSettings } from "../hooks/useSettings";	134	import { useSettings } from "../hooks/useSettings";
125	import { resolveAppModelSelection } from "../modelSelection";	135	import { resolveAppModelSelection } from "../modelSelection";
126	import { isTerminalFocused } from "../lib/terminalFocus";	136	import { isTerminalFocused } from "../lib/terminalFocus";
		137	import { deriveLogicalProjectKey } from "../logicalProject";
		138	import { buildDraftThreadRouteParams } from "../threadRoutes";
127	import {	139	import {
128	type ComposerImageAttachment,	140	type ComposerImageAttachment,
129	type DraftThreadEnvMode,	141	type DraftThreadEnvMode,
@@ -131,6 +143,7 @@ import { · 1 unmodified line
131	useComposerDraftStore,	143	useComposerDraftStore,
132	useEffectiveComposerModelState,	144	useEffectiveComposerModelState,
133	useComposerThreadDraft,	145	useComposerThreadDraft,
		146	type DraftId,
134	} from "../composerDraftStore";	147	} from "../composerDraftStore";
135	import {	148	import {
136	appendTerminalContextsToPrompt,	149	appendTerminalContextsToPrompt,
@@ -187,6 +200,7 @@ import { · 50 unmodified lines
187	reconcileMountedTerminalThreadIds,	200	reconcileMountedTerminalThreadIds,
188	revokeBlobPreviewUrl,	201	revokeBlobPreviewUrl,
189	revokeUserMessagePreviewUrls,	202	revokeUserMessagePreviewUrls,
		203	shouldWriteThreadErrorToCurrentServerThread,
190	threadHasStarted,	204	threadHasStarted,
191	waitForStartedServerThread,	205	waitForStartedServerThread,
192	} from "./ChatView.logic";	206	} from "./ChatView.logic";
@@ -203,6 +217,7 @@ const IMAGE_SIZE_LIMIT_LABEL = `${Math.round(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES · 10 unmodified lines
203	const IMAGE_ONLY_BOOTSTRAP_PROMPT =	217	const IMAGE_ONLY_BOOTSTRAP_PROMPT =
204	"[User attached one or more images without additional text. Respond using the conversation context and the attached image(s).]";	218	"[User attached one or more images without additional text. Respond using the conversation context and the attached image(s).]";
205	const EMPTY_ACTIVITIES: OrchestrationThreadActivity[] = [];	219	const EMPTY_ACTIVITIES: OrchestrationThreadActivity[] = [];
		220	const EMPTY_PROPOSED_PLANS: Thread["proposedPlans"] = [];
206	const EMPTY_PROJECT_ENTRIES: ProjectEntry[] = [];	221	const EMPTY_PROJECT_ENTRIES: ProjectEntry[] = [];
207	const EMPTY_PROVIDERS: ServerProvider[] = [];	222	const EMPTY_PROVIDERS: ServerProvider[] = [];
208	const EMPTY_PENDING_USER_INPUT_ANSWERS: Record<string, PendingUserInputDraftAnswer> = {};	223	const EMPTY_PENDING_USER_INPUT_ANSWERS: Record<string, PendingUserInputDraftAnswer> = {};
@@ -210,26 +225,115 @@ const EMPTY_PENDING_USER_INPUT_ANSWERS: Record<string, PendingUserInputDraftAnsw · 1 unmodified line
210	type ThreadPlanCatalogEntry = Pick<Thread, "id" \| "proposedPlans">;	225	type ThreadPlanCatalogEntry = Pick<Thread, "id" \| "proposedPlans">;
211		226
212	function useThreadPlanCatalog(threadIds: readonly ThreadId[]): ThreadPlanCatalogEntry[] {	227	function useThreadPlanCatalog(threadIds: readonly ThreadId[]): ThreadPlanCatalogEntry[] {
213	const threadShellById = useStore((state) => state.threadShellById);	228	return useStore(
214	const proposedPlanIdsByThreadId = useStore((state) => state.proposedPlanIdsByThreadId);	229	useMemo(() => {
215	const proposedPlanByThreadId = useStore((state) => state.proposedPlanByThreadId);	230	let previousThreadIds: readonly ThreadId[] = [];
		231	let previousResult: ThreadPlanCatalogEntry[] = [];
		232	let previousEntries = new Map<
		233	ThreadId,
		234	{
		235	shell: object \| null;
		236	proposedPlanIds: readonly string[] \| undefined;
		237	proposedPlansById: Record<string, Thread["proposedPlans"][number]> \| undefined;
		238	entry: ThreadPlanCatalogEntry;
		239	}
		240	>();
		241
		242	return (state) => {
		243	const sameThreadIds =
		244	previousThreadIds.length === threadIds.length &&
		245	previousThreadIds.every((id, index) => id === threadIds[index]);
		246	const nextEntries = new Map<
		247	ThreadId,
		248	{
		249	shell: object \| null;
		250	proposedPlanIds: readonly string[] \| undefined;
		251	proposedPlansById: Record<string, Thread["proposedPlans"][number]> \| undefined;
		252	entry: ThreadPlanCatalogEntry;
		253	}
		254	>();
		255	const nextResult: ThreadPlanCatalogEntry[] = [];
		256	let changed = !sameThreadIds;
		257
		258	for (const threadId of threadIds) {
		259	let shell: object \| undefined;
		260	let proposedPlanIds: readonly string[] \| undefined;
		261	let proposedPlansById: Record<string, Thread["proposedPlans"][number]> \| undefined;
		262
		263	for (const environmentState of Object.values(state.environmentStateById)) {
		264	const matchedShell = environmentState.threadShellById[threadId];
		265	if (!matchedShell) {
		266	continue;
		267	}
		268	shell = matchedShell;
		269	proposedPlanIds = environmentState.proposedPlanIdsByThreadId[threadId];
		270	proposedPlansById = environmentState.proposedPlanByThreadId[threadId] as
		271	\| Record<string, Thread["proposedPlans"][number]>
		272	\| undefined;
		273	break;
		274	}
216		275
217	return useMemo(	276	if (!shell) {
218	() =>	277	const previous = previousEntries.get(threadId);
219	threadIds.flatMap((threadId) => {	278	if (
220	if (!threadShellById[threadId]) {	279	previous &&
221	return [];	280	previous.shell === null &&
		281	previous.proposedPlanIds === undefined &&
		282	previous.proposedPlansById === undefined
		283	) {
		284	nextEntries.set(threadId, previous);
		285	continue;
		286	}
		287	changed = true;
		288	nextEntries.set(threadId, {
		289	shell: null,
		290	proposedPlanIds: undefined,
		291	proposedPlansById: undefined,
		292	entry: { id: threadId, proposedPlans: EMPTY_PROPOSED_PLANS },
		293	});
		294	continue;
		295	}
		296
		297	const previous = previousEntries.get(threadId);
		298	if (
		299	previous &&
		300	previous.shell === shell &&
		301	previous.proposedPlanIds === proposedPlanIds &&
		302	previous.proposedPlansById === proposedPlansById
		303	) {
		304	nextEntries.set(threadId, previous);
		305	nextResult.push(previous.entry);
		306	continue;
		307	}
		308
		309	changed = true;
		310	const proposedPlans =
		311	proposedPlanIds && proposedPlanIds.length > 0 && proposedPlansById
		312	? proposedPlanIds.flatMap((planId) => {
		313	const proposedPlan = proposedPlansById?.[planId];
		314	return proposedPlan ? [proposedPlan] : [];
		315	})
		316	: EMPTY_PROPOSED_PLANS;
		317	const entry = { id: threadId, proposedPlans };
		318	nextEntries.set(threadId, {
		319	shell,
		320	proposedPlanIds,
		321	proposedPlansById,
		322	entry,
		323	});
		324	nextResult.push(entry);
222	}	325	}
223		326
224	const proposedPlans =	327	if (!changed && previousResult.length === nextResult.length) {
225	proposedPlanIdsByThreadId[threadId]?.flatMap((planId) => {	328	return previousResult;
226	const plan = proposedPlanByThreadId[threadId]?.[planId];	329	}
227	return plan ? [plan] : [];
228	}) ?? [];
229		330
230	return [{ id: threadId, proposedPlans }];	331	previousThreadIds = threadIds;
231	}),	332	previousEntries = nextEntries;
232	[proposedPlanByThreadId, proposedPlanIdsByThreadId, threadIds, threadShellById],	333	previousResult = nextResult;
		334	return nextResult;
		335	};
		336	}, [threadIds]),
233	);	337	);
234	}	338	}
235		339
@@ -278,9 +382,19 @@ const terminalContextIdListsEqual = ( · 42 unmodified lines
278	): boolean =>	382	): boolean =>
279	contexts.length === ids.length && contexts.every((context, index) => context.id === ids[index]);	383	contexts.length === ids.length && contexts.every((context, index) => context.id === ids[index]);
280		384
281	interface ChatViewProps {	385	type ChatViewProps =
282	threadId: ThreadId;	386	\| {
283	}	387	environmentId: EnvironmentId;
		388	threadId: ThreadId;
		389	routeKind: "server";
		390	draftId?: never;
		391	}
		392	\| {
		393	environmentId: EnvironmentId;
		394	threadId: ThreadId;
		395	routeKind: "draft";
		396	draftId: DraftId;
		397	};
284		398
285	interface TerminalLaunchContext {	399	interface TerminalLaunchContext {
286	threadId: ThreadId;	400	threadId: ThreadId;
@@ -358,6 +472,7 @@ function useLocalDispatchState(input: { · 71 unmodified lines
358	}	472	}
359		473
360	interface PersistentThreadTerminalDrawerProps {	474	interface PersistentThreadTerminalDrawerProps {
		475	threadRef: { environmentId: EnvironmentId; threadId: ThreadId };
361	threadId: ThreadId;	476	threadId: ThreadId;
362	visible: boolean;	477	visible: boolean;
363	launchContext: PersistentTerminalLaunchContext \| null;	478	launchContext: PersistentTerminalLaunchContext \| null;
@@ -369,6 +484,7 @@ interface PersistentThreadTerminalDrawerProps { · 5 unmodified lines
369	}	484	}
370		485
371	function PersistentThreadTerminalDrawer({	486	function PersistentThreadTerminalDrawer({
		487	threadRef,
372	threadId,	488	threadId,
373	visible,	489	visible,
374	launchContext,	490	launchContext,
@@ -378,19 +494,16 @@ function PersistentThreadTerminalDrawer({ · 3 unmodified lines
378	closeShortcutLabel,	494	closeShortcutLabel,
379	onAddTerminalContext,	495	onAddTerminalContext,
380	}: PersistentThreadTerminalDrawerProps) {	496	}: PersistentThreadTerminalDrawerProps) {
381	const serverThread = useStore(useMemo(() => createThreadSelector(threadId), [threadId]));	497	const serverThread = useStore(useMemo(() => createThreadSelectorByRef(threadRef), [threadRef]));
382	const draftThread = useComposerDraftStore(	498	const draftThread = useComposerDraftStore((store) => store.getDraftThreadByRef(threadRef));
383	(store) => store.draftThreadsByThreadId[threadId] ?? null,	499	const projectRef = serverThread
384	);	500	? scopeProjectRef(serverThread.environmentId, serverThread.projectId)
385	const project = useStore((state) =>	501	: draftThread
386	serverThread?.projectId	502	? scopeProjectRef(draftThread.environmentId, draftThread.projectId)
387	? state.projectById[serverThread.projectId]	503	: null;
388	: draftThread?.projectId	504	const project = useStore(useMemo(() => createProjectSelectorByRef(projectRef), [projectRef]));
389	? state.projectById[draftThread.projectId]
390	: undefined,
391	);
392	const terminalState = useTerminalStateStore((state) =>	505	const terminalState = useTerminalStateStore((state) =>
393	selectThreadTerminalState(state.terminalStateByThreadId, threadId),	506	selectThreadTerminalState(state.terminalStateByThreadKey, threadRef),
394	);	507	);
395	const storeSetTerminalHeight = useTerminalStateStore((state) => state.setTerminalHeight);	508	const storeSetTerminalHeight = useTerminalStateStore((state) => state.setTerminalHeight);
396	const storeSplitTerminal = useTerminalStateStore((state) => state.splitTerminal);	509	const storeSplitTerminal = useTerminalStateStore((state) => state.splitTerminal);
@@ -436,32 +549,32 @@ function PersistentThreadTerminalDrawer({ · 39 unmodified lines
436		549
437	const setTerminalHeight = useCallback(	550	const setTerminalHeight = useCallback(
438	(height: number) => {	551	(height: number) => {
439	storeSetTerminalHeight(threadId, height);	552	storeSetTerminalHeight(threadRef, height);
440	},	553	},
441	[storeSetTerminalHeight, threadId],	554	[storeSetTerminalHeight, threadRef],
442	);	555	);
443		556
444	const splitTerminal = useCallback(() => {	557	const splitTerminal = useCallback(() => {
445	storeSplitTerminal(threadId, `terminal-${randomUUID()}`);	558	storeSplitTerminal(threadRef, `terminal-${randomUUID()}`);
446	bumpFocusRequestId();	559	bumpFocusRequestId();
447	}, [bumpFocusRequestId, storeSplitTerminal, threadId]);	560	}, [bumpFocusRequestId, storeSplitTerminal, threadRef]);
448		561
449	const createNewTerminal = useCallback(() => {	562	const createNewTerminal = useCallback(() => {
450	storeNewTerminal(threadId, `terminal-${randomUUID()}`);	563	storeNewTerminal(threadRef, `terminal-${randomUUID()}`);
451	bumpFocusRequestId();	564	bumpFocusRequestId();
452	}, [bumpFocusRequestId, storeNewTerminal, threadId]);	565	}, [bumpFocusRequestId, storeNewTerminal, threadRef]);
453		566
454	const activateTerminal = useCallback(	567	const activateTerminal = useCallback(
455	(terminalId: string) => {	568	(terminalId: string) => {
456	storeSetActiveTerminal(threadId, terminalId);	569	storeSetActiveTerminal(threadRef, terminalId);
457	bumpFocusRequestId();	570	bumpFocusRequestId();
458	},	571	},
459	[bumpFocusRequestId, storeSetActiveTerminal, threadId],	572	[bumpFocusRequestId, storeSetActiveTerminal, threadRef],
460	);	573	);
461		574
462	const closeTerminal = useCallback(	575	const closeTerminal = useCallback(
463	(terminalId: string) => {	576	(terminalId: string) => {
464	const api = readNativeApi();	577	const api = readEnvironmentApi(threadRef.environmentId);
465	if (!api) return;	578	if (!api) return;
466	const isFinalTerminal = terminalState.terminalIds.length <= 1;	579	const isFinalTerminal = terminalState.terminalIds.length <= 1;
467	const fallbackExitWrite = () =>	580	const fallbackExitWrite = () =>
@@ -482,10 +595,10 @@ function PersistentThreadTerminalDrawer({ · 14 unmodified lines
482	void fallbackExitWrite();	595	void fallbackExitWrite();
483	}	596	}
484		597
485	storeCloseTerminal(threadId, terminalId);	598	storeCloseTerminal(threadRef, terminalId);
486	bumpFocusRequestId();	599	bumpFocusRequestId();
487	},	600	},
488	[bumpFocusRequestId, storeCloseTerminal, terminalState.terminalIds.length, threadId],	601	[bumpFocusRequestId, storeCloseTerminal, terminalState.terminalIds.length, threadId, threadRef],
489	);	602	);
490		603
491	const handleAddTerminalContext = useCallback(	604	const handleAddTerminalContext = useCallback(
@@ -505,6 +618,7 @@ function PersistentThreadTerminalDrawer({ · 13 unmodified lines
505	return (	618	return (
506	<div className={visible ? undefined : "hidden"}>	619	<div className={visible ? undefined : "hidden"}>
507	<ThreadTerminalDrawer	620	<ThreadTerminalDrawer
		621	threadRef={threadRef}
508	threadId={threadId}	622	threadId={threadId}
509	cwd={cwd}	623	cwd={cwd}
510	worktreePath={effectiveWorktreePath}	624	worktreePath={effectiveWorktreePath}
@@ -530,12 +644,27 @@ function PersistentThreadTerminalDrawer({ · 19 unmodified lines
530	);	644	);
531	}	645	}
532		646
533	export default function ChatView({ threadId }: ChatViewProps) {	647	export default function ChatView(props: ChatViewProps) {
534	const serverThread = useStore(useMemo(() => createThreadSelector(threadId), [threadId]));	648	const { environmentId, threadId, routeKind } = props;
		649	const draftId = routeKind === "draft" ? props.draftId : null;
		650	const routeThreadRef = useMemo(
		651	() => scopeThreadRef(environmentId, threadId),
		652	[environmentId, threadId],
		653	);
		654	const composerDraftTarget: ScopedThreadRef \| DraftId =
		655	routeKind === "server" ? routeThreadRef : props.draftId;
		656	const serverThread = useStore(
		657	useMemo(
		658	() => createThreadSelectorByRef(routeKind === "server" ? routeThreadRef : null),
		659	[routeKind, routeThreadRef],
		660	),
		661	);
535	const setStoreThreadError = useStore((store) => store.setError);	662	const setStoreThreadError = useStore((store) => store.setError);
536	const markThreadVisited = useUiStateStore((store) => store.markThreadVisited);	663	const markThreadVisited = useUiStateStore((store) => store.markThreadVisited);
537	const activeThreadLastVisitedAt = useUiStateStore(	664	const activeThreadLastVisitedAt = useUiStateStore((store) =>
538	(store) => store.threadLastVisitedAtById[threadId],	665	routeKind === "server"
		666	? store.threadLastVisitedAtById[scopedThreadKey(scopeThreadRef(environmentId, threadId))]
		667	: undefined,
539	);	668	);
540	const settings = useSettings();	669	const settings = useSettings();
541	const setStickyComposerModelSelection = useComposerDraftStore(	670	const setStickyComposerModelSelection = useComposerDraftStore(
@@ -548,7 +677,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 6 unmodified lines
548	select: (params) => parseDiffRouteSearch(params),	677	select: (params) => parseDiffRouteSearch(params),
549	});	678	});
550	const { resolvedTheme } = useTheme();	679	const { resolvedTheme } = useTheme();
551	const composerDraft = useComposerThreadDraft(threadId);	680	const composerDraft = useComposerThreadDraft(composerDraftTarget);
552	const prompt = composerDraft.prompt;	681	const prompt = composerDraft.prompt;
553	const composerImages = composerDraft.images;	682	const composerImages = composerDraft.images;
554	const composerTerminalContexts = composerDraft.terminalContexts;	683	const composerTerminalContexts = composerDraft.terminalContexts;
@@ -591,16 +720,20 @@ export default function ChatView({ threadId }: ChatViewProps) { · 36 unmodified lines
591	);	720	);
592	const clearComposerDraftContent = useComposerDraftStore((store) => store.clearComposerContent);	721	const clearComposerDraftContent = useComposerDraftStore((store) => store.clearComposerContent);
593	const setDraftThreadContext = useComposerDraftStore((store) => store.setDraftThreadContext);	722	const setDraftThreadContext = useComposerDraftStore((store) => store.setDraftThreadContext);
594	const getDraftThreadByProjectId = useComposerDraftStore(	723	const getDraftSessionByLogicalProjectKey = useComposerDraftStore(
595	(store) => store.getDraftThreadByProjectId,	724	(store) => store.getDraftSessionByLogicalProjectKey,
596	);	725	);
597	const getDraftThread = useComposerDraftStore((store) => store.getDraftThread);	726	const getComposerDraft = useComposerDraftStore((store) => store.getComposerDraft);
598	const setProjectDraftThreadId = useComposerDraftStore((store) => store.setProjectDraftThreadId);	727	const getDraftSession = useComposerDraftStore((store) => store.getDraftSession);
599	const clearProjectDraftThreadId = useComposerDraftStore(	728	const setLogicalProjectDraftThreadId = useComposerDraftStore(
600	(store) => store.clearProjectDraftThreadId,	729	(store) => store.setLogicalProjectDraftThreadId,
601	);	730	);
602	const draftThread = useComposerDraftStore(	731	const draftThread = useComposerDraftStore((store) =>
603	(store) => store.draftThreadsByThreadId[threadId] ?? null,	732	routeKind === "server"
		733	? store.getDraftSessionByRef(routeThreadRef)
		734	: draftId
		735	? store.getDraftSession(draftId)
		736	: null,
604	);	737	);
605	const promptRef = useRef(prompt);	738	const promptRef = useRef(prompt);
606	const [showScrollToBottom, setShowScrollToBottom] = useState(false);	739	const [showScrollToBottom, setShowScrollToBottom] = useState(false);
@@ -610,8 +743,8 @@ export default function ChatView({ threadId }: ChatViewProps) { · 3 unmodified lines
610	const optimisticUserMessagesRef = useRef(optimisticUserMessages);	743	const optimisticUserMessagesRef = useRef(optimisticUserMessages);
611	optimisticUserMessagesRef.current = optimisticUserMessages;	744	optimisticUserMessagesRef.current = optimisticUserMessages;
612	const composerTerminalContextsRef = useRef<TerminalContextDraft[]>(composerTerminalContexts);	745	const composerTerminalContextsRef = useRef<TerminalContextDraft[]>(composerTerminalContexts);
613	const [localDraftErrorsByThreadId, setLocalDraftErrorsByThreadId] = useState<	746	const [localDraftErrorsByDraftId, setLocalDraftErrorsByDraftId] = useState<
614	Record<ThreadId, string \| null>	747	Record<string, string \| null>
615	>({});	748	>({});
616	const [isConnecting, _setIsConnecting] = useState(false);	749	const [isConnecting, _setIsConnecting] = useState(false);
617	const [isRevertingCheckpoint, setIsRevertingCheckpoint] = useState(false);	750	const [isRevertingCheckpoint, setIsRevertingCheckpoint] = useState(false);
@@ -689,66 +822,73 @@ export default function ChatView({ threadId }: ChatViewProps) { · 71 unmodified lines
689	setMessagesScrollElement(element);	822	setMessagesScrollElement(element);
690	}, []);	823	}, []);
691		824
692	const terminalStateByThreadId = useTerminalStateStore((state) => state.terminalStateByThreadId);	825	const terminalState = useTerminalStateStore((state) =>
693	const terminalState = useMemo(	826	selectThreadTerminalState(state.terminalStateByThreadKey, routeThreadRef),
694	() => selectThreadTerminalState(terminalStateByThreadId, threadId),
695	[terminalStateByThreadId, threadId],
696	);	827	);
697	const openTerminalThreadIds = useMemo(	828	const openTerminalThreadKeys = useTerminalStateStore(
698	() =>	829	useShallow((state) =>
699	Object.entries(terminalStateByThreadId).flatMap(([nextThreadId, nextTerminalState]) =>	830	Object.entries(state.terminalStateByThreadKey).flatMap(([nextThreadKey, nextTerminalState]) =>
700	nextTerminalState.terminalOpen ? [nextThreadId as ThreadId] : [],	831	nextTerminalState.terminalOpen ? [nextThreadKey] : [],
701	),	832	),
702	[terminalStateByThreadId],	833	),
703	);	834	);
704	const storeSetTerminalOpen = useTerminalStateStore((s) => s.setTerminalOpen);	835	const storeSetTerminalOpen = useTerminalStateStore((s) => s.setTerminalOpen);
705	const storeSplitTerminal = useTerminalStateStore((s) => s.splitTerminal);	836	const storeSplitTerminal = useTerminalStateStore((s) => s.splitTerminal);
706	const storeNewTerminal = useTerminalStateStore((s) => s.newTerminal);	837	const storeNewTerminal = useTerminalStateStore((s) => s.newTerminal);
707	const storeSetActiveTerminal = useTerminalStateStore((s) => s.setActiveTerminal);	838	const storeSetActiveTerminal = useTerminalStateStore((s) => s.setActiveTerminal);
708	const storeCloseTerminal = useTerminalStateStore((s) => s.closeTerminal);	839	const storeCloseTerminal = useTerminalStateStore((s) => s.closeTerminal);
709	const serverThreadIds = useStore((state) => state.threadIds);	840	const serverThreadKeys = useStore(
		841	useShallow((state) =>
		842	selectThreadsAcrossEnvironments(state).map((thread) =>
		843	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
		844	),
		845	),
		846	);
710	const storeServerTerminalLaunchContext = useTerminalStateStore(	847	const storeServerTerminalLaunchContext = useTerminalStateStore(
711	(s) => s.terminalLaunchContextByThreadId[threadId] ?? null,	848	(s) => s.terminalLaunchContextByThreadKey[scopedThreadKey(routeThreadRef)] ?? null,
712	);	849	);
713	const storeClearTerminalLaunchContext = useTerminalStateStore(	850	const storeClearTerminalLaunchContext = useTerminalStateStore(
714	(s) => s.clearTerminalLaunchContext,	851	(s) => s.clearTerminalLaunchContext,
715	);	852	);
716	const draftThreadsByThreadId = useComposerDraftStore((store) => store.draftThreadsByThreadId);	853	const draftThreadsByThreadKey = useComposerDraftStore((store) => store.draftThreadsByThreadKey);
717	const draftThreadIds = useMemo(	854	const draftThreadKeys = useMemo(
718	() => Object.keys(draftThreadsByThreadId) as ThreadId[],	855	() =>
719	[draftThreadsByThreadId],	856	Object.values(draftThreadsByThreadKey).map((draftThread) =>
		857	scopedThreadKey(scopeThreadRef(draftThread.environmentId, draftThread.threadId)),
		858	),
		859	[draftThreadsByThreadKey],
720	);	860	);
721	const [mountedTerminalThreadIds, setMountedTerminalThreadIds] = useState<ThreadId[]>([]);	861	const [mountedTerminalThreadKeys, setMountedTerminalThreadKeys] = useState<string[]>([]);
722		862
723	const setPrompt = useCallback(	863	const setPrompt = useCallback(
724	(nextPrompt: string) => {	864	(nextPrompt: string) => {
725	setComposerDraftPrompt(threadId, nextPrompt);	865	setComposerDraftPrompt(composerDraftTarget, nextPrompt);
726	},	866	},
727	[setComposerDraftPrompt, threadId],	867	[composerDraftTarget, setComposerDraftPrompt],
728	);	868	);
729	const addComposerImage = useCallback(	869	const addComposerImage = useCallback(
730	(image: ComposerImageAttachment) => {	870	(image: ComposerImageAttachment) => {
731	addComposerDraftImage(threadId, image);	871	addComposerDraftImage(composerDraftTarget, image);
732	},	872	},
733	[addComposerDraftImage, threadId],	873	[addComposerDraftImage, composerDraftTarget],
734	);	874	);
735	const addComposerImagesToDraft = useCallback(	875	const addComposerImagesToDraft = useCallback(
736	(images: ComposerImageAttachment[]) => {	876	(images: ComposerImageAttachment[]) => {
737	addComposerDraftImages(threadId, images);	877	addComposerDraftImages(composerDraftTarget, images);
738	},	878	},
739	[addComposerDraftImages, threadId],	879	[addComposerDraftImages, composerDraftTarget],
740	);	880	);
741	const addComposerTerminalContextsToDraft = useCallback(	881	const addComposerTerminalContextsToDraft = useCallback(
742	(contexts: TerminalContextDraft[]) => {	882	(contexts: TerminalContextDraft[]) => {
743	addComposerDraftTerminalContexts(threadId, contexts);	883	addComposerDraftTerminalContexts(composerDraftTarget, contexts);
744	},	884	},
745	[addComposerDraftTerminalContexts, threadId],	885	[addComposerDraftTerminalContexts, composerDraftTarget],
746	);	886	);
747	const removeComposerImageFromDraft = useCallback(	887	const removeComposerImageFromDraft = useCallback(
748	(imageId: string) => {	888	(imageId: string) => {
749	removeComposerDraftImage(threadId, imageId);	889	removeComposerDraftImage(composerDraftTarget, imageId);
750	},	890	},
751	[removeComposerDraftImage, threadId],	891	[composerDraftTarget, removeComposerDraftImage],
752	);	892	);
753	const removeComposerTerminalContextFromDraft = useCallback(	893	const removeComposerTerminalContextFromDraft = useCallback(
754	(contextId: string) => {	894	(contextId: string) => {
@@ -761,7 +901,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 6 unmodified lines
761	const nextPrompt = removeInlineTerminalContextPlaceholder(promptRef.current, contextIndex);	901	const nextPrompt = removeInlineTerminalContextPlaceholder(promptRef.current, contextIndex);
762	promptRef.current = nextPrompt.prompt;	902	promptRef.current = nextPrompt.prompt;
763	setPrompt(nextPrompt.prompt);	903	setPrompt(nextPrompt.prompt);
764	removeComposerDraftTerminalContext(threadId, contextId);	904	removeComposerDraftTerminalContext(composerDraftTarget, contextId);
765	setComposerCursor(nextPrompt.cursor);	905	setComposerCursor(nextPrompt.cursor);
766	setComposerTrigger(	906	setComposerTrigger(
767	detectComposerTrigger(	907	detectComposerTrigger(
@@ -770,13 +910,19 @@ export default function ChatView({ threadId }: ChatViewProps) { · 2 unmodified lines
770	),	910	),
771	);	911	);
772	},	912	},
773	[composerTerminalContexts, removeComposerDraftTerminalContext, setPrompt, threadId],	913	[composerDraftTarget, composerTerminalContexts, removeComposerDraftTerminalContext, setPrompt],
774	);	914	);
775		915
776	const fallbackDraftProject = useStore((state) =>	916	const fallbackDraftProjectRef = draftThread
777	draftThread?.projectId ? state.projectById[draftThread.projectId] : undefined,	917	? scopeProjectRef(draftThread.environmentId, draftThread.projectId)
		918	: null;
		919	const fallbackDraftProject = useStore(
		920	useMemo(() => createProjectSelectorByRef(fallbackDraftProjectRef), [fallbackDraftProjectRef]),
778	);	921	);
779	const localDraftError = serverThread ? null : (localDraftErrorsByThreadId[threadId] ?? null);	922	const localDraftError =
		923	routeKind === "server" && serverThread
		924	? null
		925	: ((draftId ? localDraftErrorsByDraftId[draftId] : null) ?? null);
780	const localDraftThread = useMemo(	926	const localDraftThread = useMemo(
781	() =>	927	() =>
782	draftThread	928	draftThread
@@ -792,20 +938,25 @@ export default function ChatView({ threadId }: ChatViewProps) { · 9 unmodified lines
792	: undefined,	938	: undefined,
793	[draftThread, fallbackDraftProject?.defaultModelSelection, localDraftError, threadId],	939	[draftThread, fallbackDraftProject?.defaultModelSelection, localDraftError, threadId],
794	);	940	);
795	const activeThread = serverThread ?? localDraftThread;	941	const isServerThread = routeKind === "server" && serverThread !== undefined;
		942	const activeThread = isServerThread ? serverThread : localDraftThread;
796	const runtimeMode =	943	const runtimeMode =
797	composerDraft.runtimeMode ?? activeThread?.runtimeMode ?? DEFAULT_RUNTIME_MODE;	944	composerDraft.runtimeMode ?? activeThread?.runtimeMode ?? DEFAULT_RUNTIME_MODE;
798	const interactionMode =	945	const interactionMode =
799	composerDraft.interactionMode ?? activeThread?.interactionMode ?? DEFAULT_INTERACTION_MODE;	946	composerDraft.interactionMode ?? activeThread?.interactionMode ?? DEFAULT_INTERACTION_MODE;
800	const isServerThread = serverThread !== undefined;
801	const isLocalDraftThread = !isServerThread && localDraftThread !== undefined;	947	const isLocalDraftThread = !isServerThread && localDraftThread !== undefined;
802	const canCheckoutPullRequestIntoThread = isLocalDraftThread;	948	const canCheckoutPullRequestIntoThread = isLocalDraftThread;
803	const diffOpen = rawSearch.diff === "1";	949	const diffOpen = rawSearch.diff === "1";
804	const activeThreadId = activeThread?.id ?? null;	950	const activeThreadId = activeThread?.id ?? null;
805	const existingOpenTerminalThreadIds = useMemo(() => {	951	const activeThreadRef = useMemo(
806	const existingThreadIds = new Set<ThreadId>([...serverThreadIds, ...draftThreadIds]);	952	() => (activeThread ? scopeThreadRef(activeThread.environmentId, activeThread.id) : null),
807	return openTerminalThreadIds.filter((nextThreadId) => existingThreadIds.has(nextThreadId));	953	[activeThread],
808	}, [draftThreadIds, openTerminalThreadIds, serverThreadIds]);	954	);
		955	const activeThreadKey = activeThreadRef ? scopedThreadKey(activeThreadRef) : null;
		956	const existingOpenTerminalThreadKeys = useMemo(() => {
		957	const existingThreadKeys = new Set<string>([...serverThreadKeys, ...draftThreadKeys]);
		958	return openTerminalThreadKeys.filter((nextThreadKey) => existingThreadKeys.has(nextThreadKey));
		959	}, [draftThreadKeys, openTerminalThreadKeys, serverThreadKeys]);
809	const activeLatestTurn = activeThread?.latestTurn ?? null;	960	const activeLatestTurn = activeThread?.latestTurn ?? null;
810	const threadPlanCatalog = useThreadPlanCatalog(	961	const threadPlanCatalog = useThreadPlanCatalog(
811	useMemo(() => {	962	useMemo(() => {
@@ -825,12 +976,12 @@ export default function ChatView({ threadId }: ChatViewProps) { · 13 unmodified lines
825	[activeThread?.activities],	976	[activeThread?.activities],
826	);	977	);
827	useEffect(() => {	978	useEffect(() => {
828	setMountedTerminalThreadIds((currentThreadIds) => {	979	setMountedTerminalThreadKeys((currentThreadIds) => {
829	const nextThreadIds = reconcileMountedTerminalThreadIds({	980	const nextThreadIds = reconcileMountedTerminalThreadIds({
830	currentThreadIds,	981	currentThreadIds,
831	openThreadIds: existingOpenTerminalThreadIds,	982	openThreadIds: existingOpenTerminalThreadKeys,
832	activeThreadId,	983	activeThreadId: activeThreadKey,
833	activeThreadTerminalOpen: Boolean(activeThreadId && terminalState.terminalOpen),	984	activeThreadTerminalOpen: Boolean(activeThreadKey && terminalState.terminalOpen),
834	maxHiddenThreadCount: MAX_HIDDEN_MOUNTED_TERMINAL_THREADS,	985	maxHiddenThreadCount: MAX_HIDDEN_MOUNTED_TERMINAL_THREADS,
835	});	986	});
836	return currentThreadIds.length === nextThreadIds.length &&	987	return currentThreadIds.length === nextThreadIds.length &&
@@ -838,10 +989,13 @@ export default function ChatView({ threadId }: ChatViewProps) { · 1 unmodified line
838	? currentThreadIds	989	? currentThreadIds
839	: nextThreadIds;	990	: nextThreadIds;
840	});	991	});
841	}, [activeThreadId, existingOpenTerminalThreadIds, terminalState.terminalOpen]);	992	}, [activeThreadKey, existingOpenTerminalThreadKeys, terminalState.terminalOpen]);
842	const latestTurnSettled = isLatestTurnSettled(activeLatestTurn, activeThread?.session ?? null);	993	const latestTurnSettled = isLatestTurnSettled(activeLatestTurn, activeThread?.session ?? null);
843	const activeProject = useStore((state) =>	994	const activeProjectRef = activeThread
844	activeThread?.projectId ? state.projectById[activeThread.projectId] : undefined,	995	? scopeProjectRef(activeThread.environmentId, activeThread.projectId)
		996	: null;
		997	const activeProject = useStore(
		998	useMemo(() => createProjectSelectorByRef(activeProjectRef), [activeProjectRef]),
845	);	999	);
846		1000
847	const openPullRequestDialog = useCallback(	1001	const openPullRequestDialog = useCallback(
@@ -867,50 +1021,71 @@ export default function ChatView({ threadId }: ChatViewProps) { · 19 unmodified lines
867	if (!activeProject) {	1021	if (!activeProject) {
868	throw new Error("No active project is available for this pull request.");	1022	throw new Error("No active project is available for this pull request.");
869	}	1023	}
870	const storedDraftThread = getDraftThreadByProjectId(activeProject.id);	1024	const activeProjectRef = scopeProjectRef(activeProject.environmentId, activeProject.id);
871	if (storedDraftThread) {	1025	const logicalProjectKey = deriveLogicalProjectKey(activeProject);
872	setDraftThreadContext(storedDraftThread.threadId, input);	1026	const storedDraftSession = getDraftSessionByLogicalProjectKey(logicalProjectKey);
873	setProjectDraftThreadId(activeProject.id, storedDraftThread.threadId, input);	1027	if (storedDraftSession) {
874	if (storedDraftThread.threadId !== threadId) {	1028	setDraftThreadContext(storedDraftSession.draftId, input);
		1029	setLogicalProjectDraftThreadId(
		1030	logicalProjectKey,
		1031	activeProjectRef,
		1032	storedDraftSession.draftId,
		1033	{
		1034	threadId: storedDraftSession.threadId,
		1035	...input,
		1036	},
		1037	);
		1038	if (routeKind !== "draft" \|\| draftId !== storedDraftSession.draftId) {
875	await navigate({	1039	await navigate({
876	to: "/$threadId",	1040	to: "/draft/$draftId",
877	params: { threadId: storedDraftThread.threadId },	1041	params: buildDraftThreadRouteParams(storedDraftSession.draftId),
878	});	1042	});
879	}	1043	}
880	return storedDraftThread.threadId;	1044	return storedDraftSession.threadId;
881	}	1045	}
882		1046
883	const activeDraftThread = getDraftThread(threadId);	1047	const activeDraftSession = routeKind === "draft" && draftId ? getDraftSession(draftId) : null;
884	if (!isServerThread && activeDraftThread?.projectId === activeProject.id) {	1048	if (
885	setDraftThreadContext(threadId, input);	1049	!isServerThread &&
886	setProjectDraftThreadId(activeProject.id, threadId, input);	1050	activeDraftSession?.logicalProjectKey === logicalProjectKey &&
887	return threadId;	1051	draftId
		1052	) {
		1053	setDraftThreadContext(draftId, input);
		1054	setLogicalProjectDraftThreadId(logicalProjectKey, activeProjectRef, draftId, {
		1055	threadId: activeDraftSession.threadId,
		1056	createdAt: activeDraftSession.createdAt,
		1057	runtimeMode: activeDraftSession.runtimeMode,
		1058	interactionMode: activeDraftSession.interactionMode,
		1059	...input,
		1060	});
		1061	return activeDraftSession.threadId;
888	}	1062	}
889		1063
890	clearProjectDraftThreadId(activeProject.id);	1064	const nextDraftId = newDraftId();
891	const nextThreadId = newThreadId();	1065	const nextThreadId = newThreadId();
892	setProjectDraftThreadId(activeProject.id, nextThreadId, {	1066	setLogicalProjectDraftThreadId(logicalProjectKey, activeProjectRef, nextDraftId, {
		1067	threadId: nextThreadId,
893	createdAt: new Date().toISOString(),	1068	createdAt: new Date().toISOString(),
894	runtimeMode: DEFAULT_RUNTIME_MODE,	1069	runtimeMode: DEFAULT_RUNTIME_MODE,
895	interactionMode: DEFAULT_INTERACTION_MODE,	1070	interactionMode: DEFAULT_INTERACTION_MODE,
896	...input,	1071	...input,
897	});	1072	});
898	await navigate({	1073	await navigate({
899	to: "/$threadId",	1074	to: "/draft/$draftId",
900	params: { threadId: nextThreadId },	1075	params: buildDraftThreadRouteParams(nextDraftId),
901	});	1076	});
902	return nextThreadId;	1077	return nextThreadId;
903	},	1078	},
904	[	1079	[
905	activeProject,	1080	activeProject,
906	clearProjectDraftThreadId,	1081	draftId,
907	getDraftThread,	1082	getDraftSession,
908	getDraftThreadByProjectId,	1083	getDraftSessionByLogicalProjectKey,
909	isServerThread,	1084	isServerThread,
910	navigate,	1085	navigate,
		1086	routeKind,
911	setDraftThreadContext,	1087	setDraftThreadContext,
912	setProjectDraftThreadId,	1088	setLogicalProjectDraftThreadId,
913	threadId,
914	],	1089	],
915	);	1090	);
916		1091
@@ -934,12 +1109,13 @@ export default function ChatView({ threadId }: ChatViewProps) { · 17 unmodified lines
934	const lastVisitedAt = activeThreadLastVisitedAt ? Date.parse(activeThreadLastVisitedAt) : NaN;	1109	const lastVisitedAt = activeThreadLastVisitedAt ? Date.parse(activeThreadLastVisitedAt) : NaN;
935	if (!Number.isNaN(lastVisitedAt) && lastVisitedAt >= turnCompletedAt) return;	1110	if (!Number.isNaN(lastVisitedAt) && lastVisitedAt >= turnCompletedAt) return;
936		1111
937	markThreadVisited(serverThread.id);	1112	markThreadVisited(scopedThreadKey(scopeThreadRef(serverThread.environmentId, serverThread.id)));
938	}, [	1113	}, [
939	activeLatestTurn?.completedAt,	1114	activeLatestTurn?.completedAt,
940	activeThreadLastVisitedAt,	1115	activeThreadLastVisitedAt,
941	latestTurnSettled,	1116	latestTurnSettled,
942	markThreadVisited,	1117	markThreadVisited,
		1118	serverThread?.environmentId,
943	serverThread?.id,	1119	serverThread?.id,
944	]);	1120	]);
945		1121
@@ -959,7 +1135,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 13 unmodified lines
959	);	1135	);
960	const selectedProvider: ProviderKind = lockedProvider ?? unlockedSelectedProvider;	1136	const selectedProvider: ProviderKind = lockedProvider ?? unlockedSelectedProvider;
961	const { modelOptions: composerModelOptions, selectedModel } = useEffectiveComposerModelState({	1137	const { modelOptions: composerModelOptions, selectedModel } = useEffectiveComposerModelState({
962	threadId,	1138	threadRef: composerDraftTarget,
963	providers: providerStatuses,	1139	providers: providerStatuses,
964	selectedProvider,	1140	selectedProvider,
965	threadModelSelection: activeThread?.modelSelection,	1141	threadModelSelection: activeThread?.modelSelection,
@@ -1358,7 +1534,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 392 unmodified lines
1358	(debouncerState) => ({ isPending: debouncerState.isPending }),	1534	(debouncerState) => ({ isPending: debouncerState.isPending }),
1359	);	1535	);
1360	const effectivePathQuery = pathTriggerQuery.length > 0 ? debouncedPathQuery : "";	1536	const effectivePathQuery = pathTriggerQuery.length > 0 ? debouncedPathQuery : "";
1361	const gitStatusQuery = useGitStatus(gitCwd);	1537	const gitStatusQuery = useGitStatus({ environmentId, cwd: gitCwd });
1362	const keybindings = useServerKeybindings();	1538	const keybindings = useServerKeybindings();
1363	const availableEditors = useServerAvailableEditors();	1539	const availableEditors = useServerAvailableEditors();
1364	const modelOptionsByProvider = useMemo(	1540	const modelOptionsByProvider = useMemo(
@@ -1394,6 +1570,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 29 unmodified lines
1394	);	1570	);
1395	const workspaceEntriesQuery = useQuery(	1571	const workspaceEntriesQuery = useQuery(
1396	projectSearchEntriesQueryOptions({	1572	projectSearchEntriesQueryOptions({
		1573	environmentId,
1397	cwd: gitCwd,	1574	cwd: gitCwd,
1398	query: effectivePathQuery,	1575	query: effectivePathQuery,
1399	enabled: isPathTrigger,	1576	enabled: isPathTrigger,
@@ -1531,16 +1708,22 @@ export default function ChatView({ threadId }: ChatViewProps) { · 131 unmodified lines
1531	[keybindings, nonTerminalShortcutLabelOptions],	1708	[keybindings, nonTerminalShortcutLabelOptions],
1532	);	1709	);
1533	const onToggleDiff = useCallback(() => {	1710	const onToggleDiff = useCallback(() => {
		1711	if (!isServerThread) {
		1712	return;
		1713	}
1534	void navigate({	1714	void navigate({
1535	to: "/$threadId",	1715	to: "/$environmentId/$threadId",
1536	params: { threadId },	1716	params: {
		1717	environmentId,
		1718	threadId,
		1719	},
1537	replace: true,	1720	replace: true,
1538	search: (previous) => {	1721	search: (previous) => {
1539	const rest = stripDiffSearchParams(previous);	1722	const rest = stripDiffSearchParams(previous);
1540	return diffOpen ? { ...rest, diff: undefined } : { ...rest, diff: "1" };	1723	return diffOpen ? { ...rest, diff: undefined } : { ...rest, diff: "1" };
1541	},	1724	},
1542	});	1725	});
1543	}, [diffOpen, navigate, threadId]);	1726	}, [diffOpen, environmentId, isServerThread, navigate, threadId]);
1544		1727
1545	const envLocked = Boolean(	1728	const envLocked = Boolean(
1546	activeThread &&	1729	activeThread &&
@@ -1561,21 +1744,27 @@ export default function ChatView({ threadId }: ChatViewProps) { · 14 unmodified lines
1561	(targetThreadId: ThreadId \| null, error: string \| null) => {	1744	(targetThreadId: ThreadId \| null, error: string \| null) => {
1562	if (!targetThreadId) return;	1745	if (!targetThreadId) return;
1563	const nextError = sanitizeThreadErrorMessage(error);	1746	const nextError = sanitizeThreadErrorMessage(error);
1564	if (useStore.getState().threadShellById[targetThreadId] !== undefined) {	1747	const isCurrentServerThread = shouldWriteThreadErrorToCurrentServerThread({
		1748	serverThread,
		1749	routeThreadRef,
		1750	targetThreadId,
		1751	});
		1752	if (isCurrentServerThread) {
1565	setStoreThreadError(targetThreadId, nextError);	1753	setStoreThreadError(targetThreadId, nextError);
1566	return;	1754	return;
1567	}	1755	}
1568	setLocalDraftErrorsByThreadId((existing) => {	1756	const localDraftErrorKey = draftId ?? targetThreadId;
1569	if ((existing[targetThreadId] ?? null) === nextError) {	1757	setLocalDraftErrorsByDraftId((existing) => {
		1758	if ((existing[localDraftErrorKey] ?? null) === nextError) {
1570	return existing;	1759	return existing;
1571	}	1760	}
1572	return {	1761	return {
1573	...existing,	1762	...existing,
1574	[targetThreadId]: nextError,	1763	[localDraftErrorKey]: nextError,
1575	};	1764	};
1576	});	1765	});
1577	},	1766	},
1578	[setStoreThreadError],	1767	[draftId, routeThreadRef, serverThread, setStoreThreadError],
1579	);	1768	);
1580		1769
1581	const focusComposer = useCallback(() => {	1770	const focusComposer = useCallback(() => {
@@ -1606,7 +1795,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 24 unmodified lines
1606	insertion.cursor,	1795	insertion.cursor,
1607	);	1796	);
1608	const inserted = insertComposerDraftTerminalContext(	1797	const inserted = insertComposerDraftTerminalContext(
1609	activeThread.id,	1798	scopeThreadRef(activeThread.environmentId, activeThread.id),
1610	insertion.prompt,	1799	insertion.prompt,
1611	{	1800	{
1612	id: randomUUID(),	1801	id: randomUUID(),
@@ -1630,30 +1819,30 @@ export default function ChatView({ threadId }: ChatViewProps) { · 17 unmodified lines
1630	);	1819	);
1631	const setTerminalOpen = useCallback(	1820	const setTerminalOpen = useCallback(
1632	(open: boolean) => {	1821	(open: boolean) => {
1633	if (!activeThreadId) return;	1822	if (!activeThreadRef) return;
1634	storeSetTerminalOpen(activeThreadId, open);	1823	storeSetTerminalOpen(activeThreadRef, open);
1635	},	1824	},
1636	[activeThreadId, storeSetTerminalOpen],	1825	[activeThreadRef, storeSetTerminalOpen],
1637	);	1826	);
1638	const toggleTerminalVisibility = useCallback(() => {	1827	const toggleTerminalVisibility = useCallback(() => {
1639	if (!activeThreadId) return;	1828	if (!activeThreadRef) return;
1640	setTerminalOpen(!terminalState.terminalOpen);	1829	setTerminalOpen(!terminalState.terminalOpen);
1641	}, [activeThreadId, setTerminalOpen, terminalState.terminalOpen]);	1830	}, [activeThreadRef, setTerminalOpen, terminalState.terminalOpen]);
1642	const splitTerminal = useCallback(() => {	1831	const splitTerminal = useCallback(() => {
1643	if (!activeThreadId \|\| hasReachedSplitLimit) return;	1832	if (!activeThreadRef \|\| hasReachedSplitLimit) return;
1644	const terminalId = `terminal-${randomUUID()}`;	1833	const terminalId = `terminal-${randomUUID()}`;
1645	storeSplitTerminal(activeThreadId, terminalId);	1834	storeSplitTerminal(activeThreadRef, terminalId);
1646	setTerminalFocusRequestId((value) => value + 1);	1835	setTerminalFocusRequestId((value) => value + 1);
1647	}, [activeThreadId, hasReachedSplitLimit, storeSplitTerminal]);	1836	}, [activeThreadRef, hasReachedSplitLimit, storeSplitTerminal]);
1648	const createNewTerminal = useCallback(() => {	1837	const createNewTerminal = useCallback(() => {
1649	if (!activeThreadId) return;	1838	if (!activeThreadRef) return;
1650	const terminalId = `terminal-${randomUUID()}`;	1839	const terminalId = `terminal-${randomUUID()}`;
1651	storeNewTerminal(activeThreadId, terminalId);	1840	storeNewTerminal(activeThreadRef, terminalId);
1652	setTerminalFocusRequestId((value) => value + 1);	1841	setTerminalFocusRequestId((value) => value + 1);
1653	}, [activeThreadId, storeNewTerminal]);	1842	}, [activeThreadRef, storeNewTerminal]);
1654	const closeTerminal = useCallback(	1843	const closeTerminal = useCallback(
1655	(terminalId: string) => {	1844	(terminalId: string) => {
1656	const api = readNativeApi();	1845	const api = readEnvironmentApi(environmentId);
1657	if (!activeThreadId \|\| !api) return;	1846	if (!activeThreadId \|\| !api) return;
1658	const isFinalTerminal = terminalState.terminalIds.length <= 1;	1847	const isFinalTerminal = terminalState.terminalIds.length <= 1;
1659	const fallbackExitWrite = () =>	1848	const fallbackExitWrite = () =>
@@ -1676,10 +1865,18 @@ export default function ChatView({ threadId }: ChatViewProps) { · 16 unmodified lines
1676	} else {	1865	} else {
1677	void fallbackExitWrite();	1866	void fallbackExitWrite();
1678	}	1867	}
1679	storeCloseTerminal(activeThreadId, terminalId);	1868	if (activeThreadRef) {
		1869	storeCloseTerminal(activeThreadRef, terminalId);
		1870	}
1680	setTerminalFocusRequestId((value) => value + 1);	1871	setTerminalFocusRequestId((value) => value + 1);
1681	},	1872	},
1682	[activeThreadId, storeCloseTerminal, terminalState.terminalIds.length],	1873	[
		1874	activeThreadId,
		1875	activeThreadRef,
		1876	environmentId,
		1877	storeCloseTerminal,
		1878	terminalState.terminalIds.length,
		1879	],
1683	);	1880	);
1684	const runProjectScript = useCallback(	1881	const runProjectScript = useCallback(
1685	async (	1882	async (
@@ -1692,7 +1889,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 6 unmodified lines
1692	rememberAsLastInvoked?: boolean;	1889	rememberAsLastInvoked?: boolean;
1693	},	1890	},
1694	) => {	1891	) => {
1695	const api = readNativeApi();	1892	const api = readEnvironmentApi(environmentId);
1696	if (!api \|\| !activeThreadId \|\| !activeProject \|\| !activeThread) return;	1893	if (!api \|\| !activeThreadId \|\| !activeProject \|\| !activeThread) return;
1697	if (options?.rememberAsLastInvoked !== false) {	1894	if (options?.rememberAsLastInvoked !== false) {
1698	setLastInvokedScriptByProjectId((current) => {	1895	setLastInvokedScriptByProjectId((current) => {
@@ -1719,10 +1916,13 @@ export default function ChatView({ threadId }: ChatViewProps) { · 20 unmodified lines
1719	worktreePath: targetWorktreePath,	1916	worktreePath: targetWorktreePath,
1720	});	1917	});
1721	setTerminalOpen(true);	1918	setTerminalOpen(true);
		1919	if (!activeThreadRef) {
		1920	return;
		1921	}
1722	if (shouldCreateNewTerminal) {	1922	if (shouldCreateNewTerminal) {
1723	storeNewTerminal(activeThreadId, targetTerminalId);	1923	storeNewTerminal(activeThreadRef, targetTerminalId);
1724	} else {	1924	} else {
1725	storeSetActiveTerminal(activeThreadId, targetTerminalId);	1925	storeSetActiveTerminal(activeThreadRef, targetTerminalId);
1726	}	1926	}
1727	setTerminalFocusRequestId((value) => value + 1);	1927	setTerminalFocusRequestId((value) => value + 1);
1728		1928
@@ -1769,12 +1969,14 @@ export default function ChatView({ threadId }: ChatViewProps) { · 40 unmodified lines
1769	activeProject,	1969	activeProject,
1770	activeThread,	1970	activeThread,
1771	activeThreadId,	1971	activeThreadId,
		1972	activeThreadRef,
1772	gitCwd,	1973	gitCwd,
1773	setTerminalOpen,	1974	setTerminalOpen,
1774	setThreadError,	1975	setThreadError,
1775	storeNewTerminal,	1976	storeNewTerminal,
1776	storeSetActiveTerminal,	1977	storeSetActiveTerminal,
1777	setLastInvokedScriptByProjectId,	1978	setLastInvokedScriptByProjectId,
		1979	environmentId,
1778	terminalState.activeTerminalId,	1980	terminalState.activeTerminalId,
1779	terminalState.runningTerminalIds,	1981	terminalState.runningTerminalIds,
1780	terminalState.terminalIds,	1982	terminalState.terminalIds,
@@ -1790,7 +1992,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 9 unmodified lines
1790	keybinding?: string \| null;	1992	keybinding?: string \| null;
1791	keybindingCommand: KeybindingCommand;	1993	keybindingCommand: KeybindingCommand;
1792	}) => {	1994	}) => {
1793	const api = readNativeApi();	1995	const api = readEnvironmentApi(environmentId);
1794	if (!api) return;	1996	if (!api) return;
1795		1997
1796	await api.orchestration.dispatchCommand({	1998	await api.orchestration.dispatchCommand({
@@ -1806,10 +2008,14 @@ export default function ChatView({ threadId }: ChatViewProps) { · 9 unmodified lines
1806	});	2008	});
1807		2009
1808	if (isElectron && keybindingRule) {	2010	if (isElectron && keybindingRule) {
1809	await api.server.upsertKeybinding(keybindingRule);	2011	const localApi = readLocalApi();
		2012	if (!localApi) {
		2013	throw new Error("Local API unavailable.");
		2014	}
		2015	await localApi.server.upsertKeybinding(keybindingRule);
1810	}	2016	}
1811	},	2017	},
1812	[],	2018	[environmentId],
1813	);	2019	);
1814	const saveProjectScript = useCallback(	2020	const saveProjectScript = useCallback(
1815	async (input: NewProjectScriptInput) => {	2021	async (input: NewProjectScriptInput) => {
@@ -1913,9 +2119,9 @@ export default function ChatView({ threadId }: ChatViewProps) { · 97 unmodified lines
1913	const handleRuntimeModeChange = useCallback(	2119	const handleRuntimeModeChange = useCallback(
1914	(mode: RuntimeMode) => {	2120	(mode: RuntimeMode) => {
1915	if (mode === runtimeMode) return;	2121	if (mode === runtimeMode) return;
1916	setComposerDraftRuntimeMode(threadId, mode);	2122	setComposerDraftRuntimeMode(composerDraftTarget, mode);
1917	if (isLocalDraftThread) {	2123	if (isLocalDraftThread) {
1918	setDraftThreadContext(threadId, { runtimeMode: mode });	2124	setDraftThreadContext(composerDraftTarget, { runtimeMode: mode });
1919	}	2125	}
1920	scheduleComposerFocus();	2126	scheduleComposerFocus();
1921	},	2127	},
@@ -1923,18 +2129,18 @@ export default function ChatView({ threadId }: ChatViewProps) { · 1 unmodified line
1923	isLocalDraftThread,	2129	isLocalDraftThread,
1924	runtimeMode,	2130	runtimeMode,
1925	scheduleComposerFocus,	2131	scheduleComposerFocus,
		2132	composerDraftTarget,
1926	setComposerDraftRuntimeMode,	2133	setComposerDraftRuntimeMode,
1927	setDraftThreadContext,	2134	setDraftThreadContext,
1928	threadId,
1929	],	2135	],
1930	);	2136	);
1931		2137
1932	const handleInteractionModeChange = useCallback(	2138	const handleInteractionModeChange = useCallback(
1933	(mode: ProviderInteractionMode) => {	2139	(mode: ProviderInteractionMode) => {
1934	if (mode === interactionMode) return;	2140	if (mode === interactionMode) return;
1935	setComposerDraftInteractionMode(threadId, mode);	2141	setComposerDraftInteractionMode(composerDraftTarget, mode);
1936	if (isLocalDraftThread) {	2142	if (isLocalDraftThread) {
1937	setDraftThreadContext(threadId, { interactionMode: mode });	2143	setDraftThreadContext(composerDraftTarget, { interactionMode: mode });
1938	}	2144	}
1939	scheduleComposerFocus();	2145	scheduleComposerFocus();
1940	},	2146	},
@@ -1942,9 +2148,9 @@ export default function ChatView({ threadId }: ChatViewProps) { · 1 unmodified line
1942	interactionMode,	2148	interactionMode,
1943	isLocalDraftThread,	2149	isLocalDraftThread,
1944	scheduleComposerFocus,	2150	scheduleComposerFocus,
		2151	composerDraftTarget,
1945	setComposerDraftInteractionMode,	2152	setComposerDraftInteractionMode,
1946	setDraftThreadContext,	2153	setDraftThreadContext,
1947	threadId,
1948	],	2154	],
1949	);	2155	);
1950	const toggleInteractionMode = useCallback(() => {	2156	const toggleInteractionMode = useCallback(() => {
@@ -1980,7 +2186,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 29 unmodified lines
1980	if (!serverThread) {	2186	if (!serverThread) {
1981	return;	2187	return;
1982	}	2188	}
1983	const api = readNativeApi();	2189	const api = readEnvironmentApi(environmentId);
1984	if (!api) {	2190	if (!api) {
1985	return;	2191	return;
1986	}	2192	}
@@ -2020,7 +2226,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 33 unmodified lines
2020	});	2226	});
2021	}	2227	}
2022	},	2228	},
2023	[serverThread],	2229	[environmentId, serverThread],
2024	);	2230	);
2025		2231
2026	// Auto-scroll on new messages	2232	// Auto-scroll on new messages
@@ -2350,17 +2556,17 @@ export default function ChatView({ threadId }: ChatViewProps) { · 323 unmodified lines
2350	dragDepthRef.current = 0;	2556	dragDepthRef.current = 0;
2351	setIsDragOverComposer(false);	2557	setIsDragOverComposer(false);
2352	setExpandedImage(null);	2558	setExpandedImage(null);
2353	}, [resetLocalDispatch, threadId]);	2559	}, [draftId, resetLocalDispatch, threadId]);
2354		2560
2355	useEffect(() => {	2561	useEffect(() => {
2356	let cancelled = false;	2562	let cancelled = false;
2357	void (async () => {	2563	void (async () => {
2358	if (composerImages.length === 0) {	2564	if (composerImages.length === 0) {
2359	clearComposerDraftPersistedAttachments(threadId);	2565	clearComposerDraftPersistedAttachments(composerDraftTarget);
2360	return;	2566	return;
2361	}	2567	}
2362	const getPersistedAttachmentsForThread = () =>	2568	const getPersistedAttachmentsForThread = () =>
2363	useComposerDraftStore.getState().draftsByThreadId[threadId]?.persistedAttachments ?? [];	2569	getComposerDraft(composerDraftTarget)?.persistedAttachments ?? [];
2364	try {	2570	try {
2365	const currentPersistedAttachments = getPersistedAttachmentsForThread();	2571	const currentPersistedAttachments = getPersistedAttachmentsForThread();
2366	const existingPersistedById = new Map(	2572	const existingPersistedById = new Map(
@@ -2391,7 +2597,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 24 unmodified lines
2391	return;	2597	return;
2392	}	2598	}
2393	// Stage attachments in persisted draft state first so persist middleware can write them.	2599	// Stage attachments in persisted draft state first so persist middleware can write them.
2394	syncComposerDraftPersistedAttachments(threadId, serialized);	2600	syncComposerDraftPersistedAttachments(composerDraftTarget, serialized);
2395	} catch {	2601	} catch {
2396	const currentImageIds = new Set(composerImages.map((image) => image.id));	2602	const currentImageIds = new Set(composerImages.map((image) => image.id));
2397	const fallbackPersistedAttachments = getPersistedAttachmentsForThread();	2603	const fallbackPersistedAttachments = getPersistedAttachmentsForThread();
@@ -2405,17 +2611,18 @@ export default function ChatView({ threadId }: ChatViewProps) { · 7 unmodified lines
2405	if (cancelled) {	2611	if (cancelled) {
2406	return;	2612	return;
2407	}	2613	}
2408	syncComposerDraftPersistedAttachments(threadId, fallbackAttachments);	2614	syncComposerDraftPersistedAttachments(composerDraftTarget, fallbackAttachments);
2409	}	2615	}
2410	})();	2616	})();
2411	return () => {	2617	return () => {
2412	cancelled = true;	2618	cancelled = true;
2413	};	2619	};
2414	}, [	2620	}, [
		2621	composerDraftTarget,
2415	clearComposerDraftPersistedAttachments,	2622	clearComposerDraftPersistedAttachments,
2416	composerImages,	2623	composerImages,
		2624	getComposerDraft,
2417	syncComposerDraftPersistedAttachments,	2625	syncComposerDraftPersistedAttachments,
2418	threadId,
2419	]);	2626	]);
2420		2627
2421	const closeExpandedImage = useCallback(() => {	2628	const closeExpandedImage = useCallback(() => {
@@ -2476,7 +2683,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 54 unmodified lines
2476	useEffect(() => {	2683	useEffect(() => {
2477	if (!activeThreadId) {	2684	if (!activeThreadId) {
2478	setTerminalLaunchContext(null);	2685	setTerminalLaunchContext(null);
2479	storeClearTerminalLaunchContext(threadId);	2686	storeClearTerminalLaunchContext(routeThreadRef);
2480	return;	2687	return;
2481	}	2688	}
2482	setTerminalLaunchContext((current) => {	2689	setTerminalLaunchContext((current) => {
@@ -2484,7 +2691,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 1 unmodified line
2484	if (current.threadId === activeThreadId) return current;	2691	if (current.threadId === activeThreadId) return current;
2485	return null;	2692	return null;
2486	});	2693	});
2487	}, [activeThreadId, storeClearTerminalLaunchContext, threadId]);	2694	}, [activeThreadId, routeThreadRef, storeClearTerminalLaunchContext]);
2488		2695
2489	useEffect(() => {	2696	useEffect(() => {
2490	if (!activeThreadId \|\| !activeProjectCwd) {	2697	if (!activeThreadId \|\| !activeProjectCwd) {
@@ -2502,12 +2709,20 @@ export default function ChatView({ threadId }: ChatViewProps) { · 11 unmodified lines
2502	settledCwd === current.cwd &&	2709	settledCwd === current.cwd &&
2503	(activeThreadWorktreePath ?? null) === current.worktreePath	2710	(activeThreadWorktreePath ?? null) === current.worktreePath
2504	) {	2711	) {
2505	storeClearTerminalLaunchContext(activeThreadId);	2712	if (activeThreadRef) {
		2713	storeClearTerminalLaunchContext(activeThreadRef);
		2714	}
2506	return null;	2715	return null;
2507	}	2716	}
2508	return current;	2717	return current;
2509	});	2718	});
2510	}, [activeProjectCwd, activeThreadId, activeThreadWorktreePath, storeClearTerminalLaunchContext]);	2719	}, [
		2720	activeProjectCwd,
		2721	activeThreadId,
		2722	activeThreadRef,
		2723	activeThreadWorktreePath,
		2724	storeClearTerminalLaunchContext,
		2725	]);
2511		2726
2512	useEffect(() => {	2727	useEffect(() => {
2513	if (!activeThreadId \|\| !activeProjectCwd \|\| !storeServerTerminalLaunchContext) {	2728	if (!activeThreadId \|\| !activeProjectCwd \|\| !storeServerTerminalLaunchContext) {
@@ -2521,11 +2736,14 @@ export default function ChatView({ threadId }: ChatViewProps) { · 7 unmodified lines
2521	settledCwd === storeServerTerminalLaunchContext.cwd &&	2736	settledCwd === storeServerTerminalLaunchContext.cwd &&
2522	(activeThreadWorktreePath ?? null) === storeServerTerminalLaunchContext.worktreePath	2737	(activeThreadWorktreePath ?? null) === storeServerTerminalLaunchContext.worktreePath
2523	) {	2738	) {
2524	storeClearTerminalLaunchContext(activeThreadId);	2739	if (activeThreadRef) {
		2740	storeClearTerminalLaunchContext(activeThreadRef);
		2741	}
2525	}	2742	}
2526	}, [	2743	}, [
2527	activeProjectCwd,	2744	activeProjectCwd,
2528	activeThreadId,	2745	activeThreadId,
		2746	activeThreadRef,
2529	activeThreadWorktreePath,	2747	activeThreadWorktreePath,
2530	storeClearTerminalLaunchContext,	2748	storeClearTerminalLaunchContext,
2531	storeServerTerminalLaunchContext,	2749	storeServerTerminalLaunchContext,
@@ -2535,11 +2753,16 @@ export default function ChatView({ threadId }: ChatViewProps) { · 3 unmodified lines
2535	if (terminalState.terminalOpen) {	2753	if (terminalState.terminalOpen) {
2536	return;	2754	return;
2537	}	2755	}
2538	if (activeThreadId) {	2756	if (activeThreadRef) {
2539	storeClearTerminalLaunchContext(activeThreadId);	2757	storeClearTerminalLaunchContext(activeThreadRef);
2540	}	2758	}
2541	setTerminalLaunchContext((current) => (current?.threadId === activeThreadId ? null : current));	2759	setTerminalLaunchContext((current) => (current?.threadId === activeThreadId ? null : current));
2542	}, [activeThreadId, storeClearTerminalLaunchContext, terminalState.terminalOpen]);	2760	}, [
		2761	activeThreadId,
		2762	activeThreadRef,
		2763	storeClearTerminalLaunchContext,
		2764	terminalState.terminalOpen,
		2765	]);
2543		2766
2544	useEffect(() => {	2767	useEffect(() => {
2545	if (phase !== "running") return;	2768	if (phase !== "running") return;
@@ -2552,16 +2775,16 @@ export default function ChatView({ threadId }: ChatViewProps) { · 6 unmodified lines
2552	}, [phase]);	2775	}, [phase]);
2553		2776
2554	useEffect(() => {	2777	useEffect(() => {
2555	if (!activeThreadId) return;	2778	if (!activeThreadKey) return;
2556	const previous = terminalOpenByThreadRef.current[activeThreadId] ?? false;	2779	const previous = terminalOpenByThreadRef.current[activeThreadKey] ?? false;
2557	const current = Boolean(terminalState.terminalOpen);	2780	const current = Boolean(terminalState.terminalOpen);
2558		2781
2559	if (!previous && current) {	2782	if (!previous && current) {
2560	terminalOpenByThreadRef.current[activeThreadId] = current;	2783	terminalOpenByThreadRef.current[activeThreadKey] = current;
2561	setTerminalFocusRequestId((value) => value + 1);	2784	setTerminalFocusRequestId((value) => value + 1);
2562	return;	2785	return;
2563	} else if (previous && !current) {	2786	} else if (previous && !current) {
2564	terminalOpenByThreadRef.current[activeThreadId] = current;	2787	terminalOpenByThreadRef.current[activeThreadKey] = current;
2565	const frame = window.requestAnimationFrame(() => {	2788	const frame = window.requestAnimationFrame(() => {
2566	focusComposer();	2789	focusComposer();
2567	});	2790	});
@@ -2570,8 +2793,8 @@ export default function ChatView({ threadId }: ChatViewProps) { · 2 unmodified lines
2570	};	2793	};
2571	}	2794	}
2572		2795
2573	terminalOpenByThreadRef.current[activeThreadId] = current;	2796	terminalOpenByThreadRef.current[activeThreadKey] = current;
2574	}, [activeThreadId, focusComposer, terminalState.terminalOpen]);	2797	}, [activeThreadKey, focusComposer, terminalState.terminalOpen]);
2575		2798
2576	useEffect(() => {	2799	useEffect(() => {
2577	const handler = (event: globalThis.KeyboardEvent) => {	2800	const handler = (event: globalThis.KeyboardEvent) => {
@@ -2766,14 +2989,15 @@ export default function ChatView({ threadId }: ChatViewProps) { · 188 unmodified lines
2766		2989
2767	const onRevertToTurnCount = useCallback(	2990	const onRevertToTurnCount = useCallback(
2768	async (turnCount: number) => {	2991	async (turnCount: number) => {
2769	const api = readNativeApi();	2992	const api = readEnvironmentApi(environmentId);
2770	if (!api \|\| !activeThread \|\| isRevertingCheckpoint) return;	2993	const localApi = readLocalApi();
		2994	if (!api \|\| !localApi \|\| !activeThread \|\| isRevertingCheckpoint) return;
2771		2995
2772	if (phase === "running" \|\| isSendBusy \|\| isConnecting) {	2996	if (phase === "running" \|\| isSendBusy \|\| isConnecting) {
2773	setThreadError(activeThread.id, "Interrupt the current turn before reverting checkpoints.");	2997	setThreadError(activeThread.id, "Interrupt the current turn before reverting checkpoints.");
2774	return;	2998	return;
2775	}	2999	}
2776	const confirmed = await api.dialogs.confirm(	3000	const confirmed = await localApi.dialogs.confirm(
2777	[	3001	[
2778	`Revert this thread to checkpoint ${turnCount}?`,	3002	`Revert this thread to checkpoint ${turnCount}?`,
2779	"This will discard newer messages and turn diffs in this thread.",	3003	"This will discard newer messages and turn diffs in this thread.",
@@ -2802,12 +3026,20 @@ export default function ChatView({ threadId }: ChatViewProps) { · 22 unmodified lines
2802	}	3026	}
2803	setIsRevertingCheckpoint(false);	3027	setIsRevertingCheckpoint(false);
2804	},	3028	},
2805	[activeThread, isConnecting, isRevertingCheckpoint, isSendBusy, phase, setThreadError],	3029	[
		3030	activeThread,
		3031	environmentId,
		3032	isConnecting,
		3033	isRevertingCheckpoint,
		3034	isSendBusy,
		3035	phase,
		3036	setThreadError,
		3037	],
2806	);	3038	);
2807		3039
2808	const onSend = async (e?: { preventDefault: () => void }) => {	3040	const onSend = async (e?: { preventDefault: () => void }) => {
2809	e?.preventDefault();	3041	e?.preventDefault();
2810	const api = readNativeApi();	3042	const api = readEnvironmentApi(environmentId);
2811	if (!api \|\| !activeThread \|\| isSendBusy \|\| isConnecting \|\| sendInFlightRef.current) return;	3043	if (!api \|\| !activeThread \|\| isSendBusy \|\| isConnecting \|\| sendInFlightRef.current) return;
2812	if (activePendingProgress) {	3044	if (activePendingProgress) {
2813	onAdvanceActivePendingUserInput();	3045	onAdvanceActivePendingUserInput();
@@ -2830,7 +3062,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 16 unmodified lines
2830	planMarkdown: activeProposedPlan.planMarkdown,	3062	planMarkdown: activeProposedPlan.planMarkdown,
2831	});	3063	});
2832	promptRef.current = "";	3064	promptRef.current = "";
2833	clearComposerDraftContent(activeThread.id);	3065	clearComposerDraftContent(scopeThreadRef(activeThread.environmentId, activeThread.id));
2834	setComposerHighlightedItemId(null);	3066	setComposerHighlightedItemId(null);
2835	setComposerCursor(0);	3067	setComposerCursor(0);
2836	setComposerTrigger(null);	3068	setComposerTrigger(null);
@@ -2847,7 +3079,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 10 unmodified lines
2847	if (standaloneSlashCommand) {	3079	if (standaloneSlashCommand) {
2848	handleInteractionModeChange(standaloneSlashCommand);	3080	handleInteractionModeChange(standaloneSlashCommand);
2849	promptRef.current = "";	3081	promptRef.current = "";
2850	clearComposerDraftContent(activeThread.id);	3082	clearComposerDraftContent(scopeThreadRef(activeThread.environmentId, activeThread.id));
2851	setComposerHighlightedItemId(null);	3083	setComposerHighlightedItemId(null);
2852	setComposerCursor(0);	3084	setComposerCursor(0);
2853	setComposerTrigger(null);	3085	setComposerTrigger(null);
@@ -2880,10 +3112,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 26 unmodified lines
2880	const shouldCreateWorktree =	3112	const shouldCreateWorktree =
2881	isFirstMessage && envMode === "worktree" && !activeThread.worktreePath;	3113	isFirstMessage && envMode === "worktree" && !activeThread.worktreePath;
2882	if (shouldCreateWorktree && !activeThread.branch) {	3114	if (shouldCreateWorktree && !activeThread.branch) {
2883	setStoreThreadError(	3115	setThreadError(threadIdForSend, "Select a base branch before sending in New worktree mode.");
2884	threadIdForSend,
2885	"Select a base branch before sending in New worktree mode.",
2886	);
2887	return;	3116	return;
2888	}	3117	}
2889		3118
@@ -2950,7 +3179,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 60 unmodified lines
2950	});	3179	});
2951	}	3180	}
2952	promptRef.current = "";	3181	promptRef.current = "";
2953	clearComposerDraftContent(threadIdForSend);	3182	clearComposerDraftContent(scopeThreadRef(activeThread.environmentId, threadIdForSend));
2954	setComposerHighlightedItemId(null);	3183	setComposerHighlightedItemId(null);
2955	setComposerCursor(0);	3184	setComposerCursor(0);
2956	setComposerTrigger(null);	3185	setComposerTrigger(null);
@@ -3087,7 +3316,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 130 unmodified lines
3087	};	3316	};
3088		3317
3089	const onInterrupt = async () => {	3318	const onInterrupt = async () => {
3090	const api = readNativeApi();	3319	const api = readEnvironmentApi(environmentId);
3091	if (!api \|\| !activeThread) return;	3320	if (!api \|\| !activeThread) return;
3092	await api.orchestration.dispatchCommand({	3321	await api.orchestration.dispatchCommand({
3093	type: "thread.turn.interrupt",	3322	type: "thread.turn.interrupt",
@@ -3099,7 +3328,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 5 unmodified lines
3099		3328
3100	const onRespondToApproval = useCallback(	3329	const onRespondToApproval = useCallback(
3101	async (requestId: ApprovalRequestId, decision: ProviderApprovalDecision) => {	3330	async (requestId: ApprovalRequestId, decision: ProviderApprovalDecision) => {
3102	const api = readNativeApi();	3331	const api = readEnvironmentApi(environmentId);
3103	if (!api \|\| !activeThreadId) return;	3332	if (!api \|\| !activeThreadId) return;
3104		3333
3105	setRespondingRequestIds((existing) =>	3334	setRespondingRequestIds((existing) =>
@@ -3122,12 +3351,12 @@ export default function ChatView({ threadId }: ChatViewProps) { · 16 unmodified lines
3122	});	3351	});
3123	setRespondingRequestIds((existing) => existing.filter((id) => id !== requestId));	3352	setRespondingRequestIds((existing) => existing.filter((id) => id !== requestId));
3124	},	3353	},
3125	[activeThreadId, setThreadError],	3354	[activeThreadId, environmentId, setThreadError],
3126	);	3355	);
3127		3356
3128	const onRespondToUserInput = useCallback(	3357	const onRespondToUserInput = useCallback(
3129	async (requestId: ApprovalRequestId, answers: Record<string, unknown>) => {	3358	async (requestId: ApprovalRequestId, answers: Record<string, unknown>) => {
3130	const api = readNativeApi();	3359	const api = readEnvironmentApi(environmentId);
3131	if (!api \|\| !activeThreadId) return;	3360	if (!api \|\| !activeThreadId) return;
3132		3361
3133	setRespondingUserInputRequestIds((existing) =>	3362	setRespondingUserInputRequestIds((existing) =>
@@ -3150,7 +3379,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 16 unmodified lines
3150	});	3379	});
3151	setRespondingUserInputRequestIds((existing) => existing.filter((id) => id !== requestId));	3380	setRespondingUserInputRequestIds((existing) => existing.filter((id) => id !== requestId));
3152	},	3381	},
3153	[activeThreadId, setThreadError],	3382	[activeThreadId, environmentId, setThreadError],
3154	);	3383	);
3155		3384
3156	const setActivePendingUserInputQuestionIndex = useCallback(	3385	const setActivePendingUserInputQuestionIndex = useCallback(
@@ -3166,31 +3395,38 @@ export default function ChatView({ threadId }: ChatViewProps) { · 9 unmodified lines
3166	[activePendingUserInput],	3395	[activePendingUserInput],
3167	);	3396	);
3168		3397
3169	const onToggleActivePendingUserInputOption = useCallback(	3398	const onSelectActivePendingUserInputOption = useCallback(
3170	(questionId: string, optionLabel: string) => {	3399	(questionId: string, optionLabel: string) => {
3171	if (!activePendingUserInput) {	3400	if (!activePendingUserInput) {
3172	return;	3401	return;
3173	}	3402	}
3174	const question = activePendingUserInput.questions.find((entry) => entry.id === questionId);	3403	setPendingUserInputAnswersByRequestId((existing) => {
3175	if (!question) {	3404	const question =
3176	return;	3405	(activePendingProgress?.activeQuestion?.id === questionId
3177	}	3406	? activePendingProgress.activeQuestion
3178	setPendingUserInputAnswersByRequestId((existing) => ({	3407	: undefined) ??
3179	...existing,	3408	activePendingUserInput.questions.find((entry) => entry.id === questionId);
3180	[activePendingUserInput.requestId]: {	3409	if (!question) {
3181	...existing[activePendingUserInput.requestId],	3410	return existing;
3182	[questionId]: togglePendingUserInputOptionSelection(	3411	}
3183	question,	3412
3184	existing[activePendingUserInput.requestId]?.[questionId],	3413	return {
3185	optionLabel,	3414	...existing,
3186	),	3415	[activePendingUserInput.requestId]: {
3187	},	3416	...existing[activePendingUserInput.requestId],
3188	}));	3417	[questionId]: togglePendingUserInputOptionSelection(
		3418	question,
		3419	existing[activePendingUserInput.requestId]?.[questionId],
		3420	optionLabel,
		3421	),
		3422	},
		3423	};
		3424	});
3189	promptRef.current = "";	3425	promptRef.current = "";
3190	setComposerCursor(0);	3426	setComposerCursor(0);
3191	setComposerTrigger(null);	3427	setComposerTrigger(null);
3192	},	3428	},
3193	[activePendingUserInput],	3429	[activePendingProgress?.activeQuestion, activePendingUserInput],
3194	);	3430	);
3195		3431
3196	const onChangeActivePendingUserInputCustomAnswer = useCallback(	3432	const onChangeActivePendingUserInputCustomAnswer = useCallback(
@@ -3257,7 +3493,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 60 unmodified lines
3257	text: string;	3493	text: string;
3258	interactionMode: "default" \| "plan";	3494	interactionMode: "default" \| "plan";
3259	}) => {	3495	}) => {
3260	const api = readNativeApi();	3496	const api = readEnvironmentApi(environmentId);
3261	if (	3497	if (
3262	!api \|\|	3498	!api \|\|
3263	!activeThread \|\|	3499	!activeThread \|\|
@@ -3312,7 +3548,10 @@ export default function ChatView({ threadId }: ChatViewProps) { · 48 unmodified lines
3312		3548
3313	// Keep the mode toggle and plan-follow-up banner in sync immediately	3549	// Keep the mode toggle and plan-follow-up banner in sync immediately
3314	// while the same-thread implementation turn is starting.	3550	// while the same-thread implementation turn is starting.
3315	setComposerDraftInteractionMode(threadIdForSend, nextInteractionMode);	3551	setComposerDraftInteractionMode(
		3552	scopeThreadRef(activeThread.environmentId, threadIdForSend),
		3553	nextInteractionMode,
		3554	);
3316		3555
3317	await api.orchestration.dispatchCommand({	3556	await api.orchestration.dispatchCommand({
3318	type: "thread.turn.start",	3557	type: "thread.turn.start",
@@ -3376,11 +3615,12 @@ export default function ChatView({ threadId }: ChatViewProps) { · 57 unmodified lines
3376	setComposerDraftInteractionMode,	3615	setComposerDraftInteractionMode,
3377	setThreadError,	3616	setThreadError,
3378	selectedModel,	3617	selectedModel,
		3618	environmentId,
3379	],	3619	],
3380	);	3620	);
3381		3621
3382	const onImplementPlanInNewThread = useCallback(async () => {	3622	const onImplementPlanInNewThread = useCallback(async () => {
3383	const api = readNativeApi();	3623	const api = readEnvironmentApi(environmentId);
3384	if (	3624	if (
3385	!api \|\|	3625	!api \|\|
3386	!activeThread \|\|	3626	!activeThread \|\|
@@ -3452,17 +3692,20 @@ export default function ChatView({ threadId }: ChatViewProps) { · 65 unmodified lines
3452	});	3692	});
3453	})	3693	})
3454	.then(() => {	3694	.then(() => {
3455	return waitForStartedServerThread(nextThreadId);	3695	return waitForStartedServerThread(scopeThreadRef(activeThread.environmentId, nextThreadId));
3456	})	3696	})
3457	.then(() => {	3697	.then(() => {
3458	// Signal that the plan sidebar should open on the new thread.	3698	// Signal that the plan sidebar should open on the new thread.
3459	planSidebarOpenOnNextThreadRef.current = true;	3699	planSidebarOpenOnNextThreadRef.current = true;
3460	return navigate({	3700	return navigate({
3461	to: "/$threadId",	3701	to: "/$environmentId/$threadId",
3462	params: { threadId: nextThreadId },	3702	params: {
		3703	environmentId: activeThread.environmentId,
		3704	threadId: nextThreadId,
		3705	},
3463	});	3706	});
3464	})	3707	})
3465	.catch(async (err) => {	3708	.catch(async (err: unknown) => {
3466	await api.orchestration	3709	await api.orchestration
3467	.dispatchCommand({	3710	.dispatchCommand({
3468	type: "thread.delete",	3711	type: "thread.delete",
@@ -3494,6 +3737,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 25 unmodified lines
3494	selectedProvider,	3737	selectedProvider,
3495	selectedProviderModels,	3738	selectedProviderModels,
3496	selectedModel,	3739	selectedModel,
		3740	environmentId,
3497	]);	3741	]);
3498		3742
3499	const onProviderModelSelect = useCallback(	3743	const onProviderModelSelect = useCallback(
@@ -3514,7 +3758,10 @@ export default function ChatView({ threadId }: ChatViewProps) { · 14 unmodified lines
3514	provider: resolvedProvider,	3758	provider: resolvedProvider,
3515	model: resolvedModel,	3759	model: resolvedModel,
3516	};	3760	};
3517	setComposerDraftModelSelection(activeThread.id, nextModelSelection);	3761	setComposerDraftModelSelection(
		3762	scopeThreadRef(activeThread.environmentId, activeThread.id),
		3763	nextModelSelection,
		3764	);
3518	setStickyComposerModelSelection(nextModelSelection);	3765	setStickyComposerModelSelection(nextModelSelection);
3519	scheduleComposerFocus();	3766	scheduleComposerFocus();
3520	},	3767	},
@@ -3546,7 +3793,8 @@ export default function ChatView({ threadId }: ChatViewProps) { · 25 unmodified lines
3546	);	3793	);
3547	const providerTraitsMenuContent = renderProviderTraitsMenuContent({	3794	const providerTraitsMenuContent = renderProviderTraitsMenuContent({
3548	provider: selectedProvider,	3795	provider: selectedProvider,
3549	threadId,	3796	...(routeKind === "server" ? { threadRef: routeThreadRef } : {}),
		3797	...(routeKind === "draft" && draftId ? { draftId } : {}),
3550	model: selectedModel,	3798	model: selectedModel,
3551	models: selectedProviderModels,	3799	models: selectedProviderModels,
3552	modelOptions: composerModelOptions?.[selectedProvider],	3800	modelOptions: composerModelOptions?.[selectedProvider],
@@ -3555,7 +3803,8 @@ export default function ChatView({ threadId }: ChatViewProps) { · 2 unmodified lines
3555	});	3803	});
3556	const providerTraitsPicker = renderProviderTraitsPicker({	3804	const providerTraitsPicker = renderProviderTraitsPicker({
3557	provider: selectedProvider,	3805	provider: selectedProvider,
3558	threadId,	3806	...(routeKind === "server" ? { threadRef: routeThreadRef } : {}),
		3807	...(routeKind === "draft" && draftId ? { draftId } : {}),
3559	model: selectedModel,	3808	model: selectedModel,
3560	models: selectedProviderModels,	3809	models: selectedProviderModels,
3561	modelOptions: composerModelOptions?.[selectedProvider],	3810	modelOptions: composerModelOptions?.[selectedProvider],
@@ -3565,11 +3814,11 @@ export default function ChatView({ threadId }: ChatViewProps) { · 3 unmodified lines
3565	const onEnvModeChange = useCallback(	3814	const onEnvModeChange = useCallback(
3566	(mode: DraftThreadEnvMode) => {	3815	(mode: DraftThreadEnvMode) => {
3567	if (isLocalDraftThread) {	3816	if (isLocalDraftThread) {
3568	setDraftThreadContext(threadId, { envMode: mode });	3817	setDraftThreadContext(composerDraftTarget, { envMode: mode });
3569	}	3818	}
3570	scheduleComposerFocus();	3819	scheduleComposerFocus();
3571	},	3820	},
3572	[isLocalDraftThread, scheduleComposerFocus, setDraftThreadContext, threadId],	3821	[composerDraftTarget, isLocalDraftThread, scheduleComposerFocus, setDraftThreadContext],
3573	);	3822	);
3574		3823
3575	const applyPromptReplacement = useCallback(	3824	const applyPromptReplacement = useCallback(
@@ -3766,7 +4015,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 190 unmodified lines
3766	setPrompt(nextPrompt);	4015	setPrompt(nextPrompt);
3767	if (!terminalContextIdListsEqual(composerTerminalContexts, terminalContextIds)) {	4016	if (!terminalContextIdListsEqual(composerTerminalContexts, terminalContextIds)) {
3768	setComposerDraftTerminalContexts(	4017	setComposerDraftTerminalContexts(
3769	threadId,	4018	composerDraftTarget,
3770	syncTerminalContextsByIds(composerTerminalContexts, terminalContextIds),	4019	syncTerminalContextsByIds(composerTerminalContexts, terminalContextIds),
3771	);	4020	);
3772	}	4021	}
@@ -3781,8 +4030,8 @@ export default function ChatView({ threadId }: ChatViewProps) { · 8 unmodified lines
3781	composerTerminalContexts,	4030	composerTerminalContexts,
3782	onChangeActivePendingUserInputCustomAnswer,	4031	onChangeActivePendingUserInputCustomAnswer,
3783	setPrompt,	4032	setPrompt,
		4033	composerDraftTarget,
3784	setComposerDraftTerminalContexts,	4034	setComposerDraftTerminalContexts,
3785	threadId,
3786	],	4035	],
3787	);	4036	);
3788		4037
@@ -3835,9 +4084,15 @@ export default function ChatView({ threadId }: ChatViewProps) { · 46 unmodified lines
3835	const expandedImageItem = expandedImage ? expandedImage.images[expandedImage.index] : null;	4084	const expandedImageItem = expandedImage ? expandedImage.images[expandedImage.index] : null;
3836	const onOpenTurnDiff = useCallback(	4085	const onOpenTurnDiff = useCallback(
3837	(turnId: TurnId, filePath?: string) => {	4086	(turnId: TurnId, filePath?: string) => {
		4087	if (!isServerThread) {
		4088	return;
		4089	}
3838	void navigate({	4090	void navigate({
3839	to: "/$threadId",	4091	to: "/$environmentId/$threadId",
3840	params: { threadId },	4092	params: {
		4093	environmentId,
		4094	threadId,
		4095	},
3841	search: (previous) => {	4096	search: (previous) => {
3842	const rest = stripDiffSearchParams(previous);	4097	const rest = stripDiffSearchParams(previous);
3843	return filePath	4098	return filePath
@@ -3846,7 +4101,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 2 unmodified lines
3846	},	4101	},
3847	});	4102	});
3848	},	4103	},
3849	[navigate, threadId],	4104	[environmentId, isServerThread, navigate, threadId],
3850	);	4105	);
3851	const onRevertUserMessage = (messageId: MessageId) => {	4106	const onRevertUserMessage = (messageId: MessageId) => {
3852	const targetTurnCount = revertTurnCountByUserMessageId.get(messageId);	4107	const targetTurnCount = revertTurnCountByUserMessageId.get(messageId);
@@ -3892,6 +4147,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 39 unmodified lines
3892	)}	4147	)}
3893	>	4148	>
3894	<ChatHeader	4149	<ChatHeader
		4150	activeThreadEnvironmentId={activeThread.environmentId}
3895	activeThreadId={activeThread.id}	4151	activeThreadId={activeThread.id}
3896	activeThreadTitle={activeThread.title}	4152	activeThreadTitle={activeThread.title}
3897	activeProjectName={activeProject?.name}	4153	activeProjectName={activeProject?.name}
@@ -3959,6 +4215,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 61 unmodified lines
3959	completionSummary={completionSummary}	4215	completionSummary={completionSummary}
3960	turnDiffSummaryByAssistantMessageId={turnDiffSummaryByAssistantMessageId}	4216	turnDiffSummaryByAssistantMessageId={turnDiffSummaryByAssistantMessageId}
3961	nowIso={nowIso}	4217	nowIso={nowIso}
		4218	activeThreadEnvironmentId={activeThread.environmentId}
3962	expandedWorkGroups={expandedWorkGroups}	4219	expandedWorkGroups={expandedWorkGroups}
3963	onToggleWorkGroup={onToggleWorkGroup}	4220	onToggleWorkGroup={onToggleWorkGroup}
3964	onOpenTurnDiff={onOpenTurnDiff}	4221	onOpenTurnDiff={onOpenTurnDiff}
@@ -4027,7 +4284,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 62 unmodified lines
4027	respondingRequestIds={respondingRequestIds}	4284	respondingRequestIds={respondingRequestIds}
4028	answers={activePendingDraftAnswers}	4285	answers={activePendingDraftAnswers}
4029	questionIndex={activePendingQuestionIndex}	4286	questionIndex={activePendingQuestionIndex}
4030	onToggleOption={onToggleActivePendingUserInputOption}	4287	onToggleOption={onSelectActivePendingUserInputOption}
4031	onAdvance={onAdvanceActivePendingUserInput}	4288	onAdvance={onAdvanceActivePendingUserInput}
4032	/>	4289	/>
4033	</div>	4290	</div>
@@ -4370,7 +4627,9 @@ export default function ChatView({ threadId }: ChatViewProps) { · 336 unmodified lines
4370		4627
4371	{isGitRepo && (	4628	{isGitRepo && (
4372	<BranchToolbar	4629	<BranchToolbar
		4630	environmentId={activeThread.environmentId}
4373	threadId={activeThread.id}	4631	threadId={activeThread.id}
		4632	{...(routeKind === "draft" && draftId ? { draftId } : {})}
4374	onEnvModeChange={onEnvModeChange}	4633	onEnvModeChange={onEnvModeChange}
4375	envLocked={envLocked}	4634	envLocked={envLocked}
4376	onComposerFocusRequest={scheduleComposerFocus}	4635	onComposerFocusRequest={scheduleComposerFocus}
@@ -4383,6 +4642,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 6 unmodified lines
4383	<PullRequestThreadDialog	4642	<PullRequestThreadDialog
4384	key={pullRequestDialogState.key}	4643	key={pullRequestDialogState.key}
4385	open	4644	open
		4645	environmentId={activeThread.environmentId}
4386	threadId={activeThread.id}	4646	threadId={activeThread.id}
4387	cwd={activeProject?.cwd ?? null}	4647	cwd={activeProject?.cwd ?? null}
4388	initialReference={pullRequestDialogState.initialReference}	4648	initialReference={pullRequestDialogState.initialReference}
@@ -4402,6 +4662,7 @@ export default function ChatView({ threadId }: ChatViewProps) { · 13 unmodified lines
4402	<PlanSidebar	4662	<PlanSidebar
4403	activePlan={activePlan}	4663	activePlan={activePlan}
4404	activeProposedPlan={sidebarProposedPlan}	4664	activeProposedPlan={sidebarProposedPlan}
		4665	environmentId={environmentId}
4405	markdownCwd={gitCwd ?? undefined}	4666	markdownCwd={gitCwd ?? undefined}
4406	workspaceRoot={activeWorkspaceRoot}	4667	workspaceRoot={activeWorkspaceRoot}
4407	timestampFormat={timestampFormat}	4668	timestampFormat={timestampFormat}
@@ -4418,21 +4679,28 @@ export default function ChatView({ threadId }: ChatViewProps) { · 10 unmodified lines
4418	</div>	4679	</div>
4419	{/* end horizontal flex container */}	4680	{/* end horizontal flex container */}
4420		4681
4421	{mountedTerminalThreadIds.map((mountedThreadId) => (	4682	{mountedTerminalThreadKeys.flatMap((mountedThreadKey) => {
4422	<PersistentThreadTerminalDrawer	4683	const mountedThreadRef = parseScopedThreadKey(mountedThreadKey);
4423	key={mountedThreadId}	4684	if (!mountedThreadRef) {
4424	threadId={mountedThreadId}	4685	return [];
4425	visible={mountedThreadId === activeThreadId && terminalState.terminalOpen}	4686	}
4426	launchContext={	4687	return [
4427	mountedThreadId === activeThreadId ? (activeTerminalLaunchContext ?? null) : null	4688	<PersistentThreadTerminalDrawer
4428	}	4689	key={mountedThreadKey}
4429	focusRequestId={mountedThreadId === activeThreadId ? terminalFocusRequestId : 0}	4690	threadRef={mountedThreadRef}
4430	splitShortcutLabel={splitTerminalShortcutLabel ?? undefined}	4691	threadId={mountedThreadRef.threadId}
4431	newShortcutLabel={newTerminalShortcutLabel ?? undefined}	4692	visible={mountedThreadKey === activeThreadKey && terminalState.terminalOpen}
4432	closeShortcutLabel={closeTerminalShortcutLabel ?? undefined}	4693	launchContext={
4433	onAddTerminalContext={addTerminalContextToDraft}	4694	mountedThreadKey === activeThreadKey ? (activeTerminalLaunchContext ?? null) : null
4434	/>	4695	}
4435	))}	4696	focusRequestId={mountedThreadKey === activeThreadKey ? terminalFocusRequestId : 0}
		4697	splitShortcutLabel={splitTerminalShortcutLabel ?? undefined}
		4698	newShortcutLabel={newTerminalShortcutLabel ?? undefined}
		4699	closeShortcutLabel={closeTerminalShortcutLabel ?? undefined}
		4700	onAddTerminalContext={addTerminalContextToDraft}
		4701	/>,
		4702	];
		4703	})}
4436		4704
4437	{expandedImage && expandedImageItem && (	4705	{expandedImage && expandedImageItem && (
4438	<div	4706	<div

apps/web/src/components/DiffPanel.tsx+26−15

 import { FileDiff, type FileDiffMetadata, Virtualizer } from "@pierre/diffs/react";
 import { useQuery } from "@tanstack/react-query";
 import { useNavigate, useParams, useSearch } from "@tanstack/react-router";
-import { ThreadId, type TurnId } from "@t3tools/contracts";
+import { scopeThreadRef } from "@t3tools/client-runtime";
+import type { TurnId } from "@t3tools/contracts";
 import {
   ChevronLeftIcon,
   ChevronRightIcon,
 import { useGitStatus } from "~/lib/gitStatusState";
 import { checkpointDiffQueryOptions } from "~/lib/providerReactQuery";
 import { cn } from "~/lib/utils";
-import { readNativeApi } from "../nativeApi";
+import { readLocalApi } from "../localApi";
 import { resolvePathLinkTarget } from "../terminal-links";
 import { parseDiffRouteSearch, stripDiffSearchParams } from "../diffRouteSearch";
 import { useTheme } from "../hooks/useTheme";
 import { buildPatchCacheKey } from "../lib/diffRendering";
 import { resolveDiffThemeName } from "../lib/diffRendering";
 import { useTurnDiffSummaries } from "../hooks/useTurnDiffSummaries";
-import { useStore } from "../store";
+import { selectProjectByRef, useStore } from "../store";
-import { createThreadSelector } from "../storeSelectors";
+import { createThreadSelectorByRef } from "../storeSelectors";
+import { buildThreadRouteParams, resolveThreadRouteRef } from "../threadRoutes";
 import { useSettings } from "../hooks/useSettings";
 import { formatShortTimestamp } from "../timestampFormat";
 import { DiffPanelLoadingState, DiffPanelShell, type DiffPanelMode } from "./DiffPanelShell";
   const previousDiffOpenRef = useRef(false);
   const [canScrollTurnStripLeft, setCanScrollTurnStripLeft] = useState(false);
   const [canScrollTurnStripRight, setCanScrollTurnStripRight] = useState(false);
-  const routeThreadId = useParams({
+  const routeThreadRef = useParams({
     strict: false,
-    select: (params) => (params.threadId ? ThreadId.makeUnsafe(params.threadId) : null),
+    select: (params) => resolveThreadRouteRef(params),
   });
   const diffSearch = useSearch({ strict: false, select: (search) => parseDiffRouteSearch(search) });
   const diffOpen = diffSearch.diff === "1";
-  const activeThreadId = routeThreadId;
+  const activeThreadId = routeThreadRef?.threadId ?? null;
   const activeThread = useStore(
-    useMemo(() => createThreadSelector(activeThreadId), [activeThreadId]),
+    useMemo(() => createThreadSelectorByRef(routeThreadRef), [routeThreadRef]),
   );
   const activeProjectId = activeThread?.projectId ?? null;
   const activeProject = useStore((store) =>
-    activeProjectId ? store.projectById[activeProjectId] : undefined,
+    activeThread && activeProjectId
+      ? selectProjectByRef(store, {
+          environmentId: activeThread.environmentId,
+          projectId: activeProjectId,
+        })
+      : undefined,
   );
   const activeCwd = activeThread?.worktreePath ?? activeProject?.cwd;
-  const gitStatusQuery = useGitStatus(activeCwd ?? null);
+  const gitStatusQuery = useGitStatus({
+    environmentId: activeThread?.environmentId ?? null,
+    cwd: activeCwd ?? null,
+  });
   const isGitRepo = gitStatusQuery.data?.isRepo ?? true;
   const { turnDiffSummaries, inferredCheckpointTurnCountByTurnId } =
     useTurnDiffSummaries(activeThread);
   }, [orderedTurnDiffSummaries, selectedTurn]);
   const activeCheckpointDiffQuery = useQuery(
     checkpointDiffQueryOptions({
+      environmentId: activeThread?.environmentId ?? null,
       threadId: activeThreadId,
       fromTurnCount: activeCheckpointRange?.fromTurnCount ?? null,
       toTurnCount: activeCheckpointRange?.toTurnCount ?? null,
   const openDiffFileInEditor = useCallback(
     (filePath: string) => {
-      const api = readNativeApi();
+      const api = readLocalApi();
       if (!api) return;
       const targetPath = activeCwd ? resolvePathLinkTarget(filePath, activeCwd) : filePath;
       void openInPreferredEditor(api, targetPath).catch((error) => {
   const selectTurn = (turnId: TurnId) => {
     if (!activeThread) return;
     void navigate({
-      to: "/$threadId",
+      to: "/$environmentId/$threadId",
-      params: { threadId: activeThread.id },
+      params: buildThreadRouteParams(scopeThreadRef(activeThread.environmentId, activeThread.id)),
       search: (previous) => {
         const rest = stripDiffSearchParams(previous);
         return { ...rest, diff: "1", diffTurnId: turnId };
   const selectWholeConversation = () => {
     if (!activeThread) return;
     void navigate({
-      to: "/$threadId",
+      to: "/$environmentId/$threadId",
-      params: { threadId: activeThread.id },
+      params: buildThreadRouteParams(scopeThreadRef(activeThread.environmentId, activeThread.id)),
       search: (previous) => {
         const rest = stripDiffSearchParams(previous);
         return { ...rest, diff: "1" };

apps/web/src/components/GitActionsControl.browser.tsx+73−47

+import { scopeThreadRef } from "@t3tools/client-runtime";
 import { ThreadId } from "@t3tools/contracts";
 import { useState } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 const THREAD_A = ThreadId.makeUnsafe("thread-a");
 const THREAD_B = ThreadId.makeUnsafe("thread-b");
+const ENVIRONMENT_ID = "environment-local" as never;
 const GIT_CWD = "/repo/project";
 const BRANCH_NAME = "feature/toast-scope";
+function createDeferredPromise<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((nextResolve, nextReject) => {
+    resolve = nextResolve;
+    reject = nextReject;
+  });
+  return { promise, resolve, reject };
+}
 const {
+  activeRunStackedActionDeferredRef,
   invalidateGitQueriesSpy,
   refreshGitStatusSpy,
   runStackedActionMutateAsyncSpy,
   toastPromiseSpy,
   toastUpdateSpy,
 } = vi.hoisted(() => ({
+  activeRunStackedActionDeferredRef: { current: createDeferredPromise<never>() },
   invalidateGitQueriesSpy: vi.fn(() => Promise.resolve()),
   refreshGitStatusSpy: vi.fn(() => Promise.resolve(null)),
-  runStackedActionMutateAsyncSpy: vi.fn(() => new Promise<never>(() => undefined)),
+  runStackedActionMutateAsyncSpy: vi.fn(() => activeRunStackedActionDeferredRef.current.promise),
   setThreadBranchSpy: vi.fn(),
   toastAddSpy: vi.fn(() => "toast-1"),
   toastCloseSpy: vi.fn(),
   toastUpdateSpy: vi.fn(),
 }));
-vi.mock("@tanstack/react-query", async () => {
+vi.mock("@tanstack/react-query", () => {
-  const actual =
-    await vi.importActual<typeof import("@tanstack/react-query")>("@tanstack/react-query");
   return {
-    ...actual,
     useIsMutating: vi.fn(() => 0),
     useMutation: vi.fn((options: { __kind?: string }) => {
       if (options.__kind === "run-stacked-action") {
         isPending: false,
       };
     }),
-    useQuery: vi.fn((options: { queryKey?: string[] }) => {
+    useQuery: vi.fn(() => ({ data: null, error: null })),
-      if (options.queryKey?.[0] === "git-branches") {
-        return {
-          data: {
-            isRepo: true,
-            hasOriginRemote: true,
-            branches: [
-              {
-                name: BRANCH_NAME,
-                current: true,
-                isDefault: false,
-                worktreePath: null,
-              },
-            ],
-          },
-          error: null,
-        };
-      }
-      return { data: null, error: null };
-    }),
     useQueryClient: vi.fn(() => ({})),
   };
 });
   })),
 }));
-vi.mock("~/lib/utils", async () => {
+vi.mock("~/localApi", () => ({
-  const actual = await vi.importActual<typeof import("~/lib/utils")>("~/lib/utils");
+  readLocalApi: vi.fn(() => null),
-  return {
-    ...actual,
-    newCommandId: vi.fn(() => "command-1"),
-    randomUUID: vi.fn(() => "action-1"),
-  };
-});
-vi.mock("~/nativeApi", () => ({
-  readNativeApi: vi.fn(() => null),
 }));
 vi.mock("~/store", () => ({
+  selectEnvironmentState: (
+    state: { environmentStateById: Record<string, unknown> },
+    environmentId: string | null,
+  ) => {
+    if (!environmentId) {
+      throw new Error("Missing environment id");
+    }
+    const environmentState = state.environmentStateById[environmentId];
+    if (!environmentState) {
+      throw new Error(`Unknown environment: ${environmentId}`);
+    }
+    return environmentState;
+  },
   useStore: (selector: (state: unknown) => unknown) =>
     selector({
       setThreadBranch: setThreadBranchSpy,
-      threadShellById: {
+      environmentStateById: {
-        [THREAD_A]: { id: THREAD_A, branch: BRANCH_NAME, worktreePath: null },
+        [ENVIRONMENT_ID]: {
-        [THREAD_B]: { id: THREAD_B, branch: BRANCH_NAME, worktreePath: null },
+          threadShellById: {
+            [THREAD_A]: { id: THREAD_A, branch: BRANCH_NAME, worktreePath: null },
+            [THREAD_B]: { id: THREAD_B, branch: BRANCH_NAME, worktreePath: null },
+          },
+          threadSessionById: {},
+          threadTurnStateById: {},
+          messageIdsByThreadId: {},
+          messageByThreadId: {},
+          activityIdsByThreadId: {},
+          activityByThreadId: {},
+          proposedPlanIdsByThreadId: {},
+          proposedPlanByThreadId: {},
+          turnDiffIdsByThreadId: {},
+          turnDiffSummaryByThreadId: {},
+        },
       },
     }),
 }));
       <button type="button" onClick={() => setActiveThreadId(THREAD_B)}>
         Switch thread
       </button>
-      <GitActionsControl gitCwd={GIT_CWD} activeThreadId={activeThreadId} />
+      <GitActionsControl
+        gitCwd={GIT_CWD}
+        activeThreadRef={scopeThreadRef(ENVIRONMENT_ID, activeThreadId)}
+      />
     </>
   );
 }
   afterEach(() => {
     vi.useRealTimers();
     vi.clearAllMocks();
+    activeRunStackedActionDeferredRef.current = createDeferredPromise<never>();
     document.body.innerHTML = "";
   });
         }),
       );
     } finally {
+      activeRunStackedActionDeferredRef.current.reject(new Error("test cleanup"));
+      await Promise.resolve();
+      vi.useRealTimers();
       await screen.unmount();
       host.remove();
     }
     const host = document.createElement("div");
     document.body.append(host);
-    const screen = await render(<GitActionsControl gitCwd={GIT_CWD} activeThreadId={THREAD_A} />, {
+    const screen = await render(
-      container: host,
+      <GitActionsControl
-    });
+        gitCwd={GIT_CWD}
+        activeThreadRef={scopeThreadRef(ENVIRONMENT_ID, THREAD_A)}
+      />,
+      {
+        container: host,
+      },
+    );
     try {
       window.dispatchEvent(new Event("focus"));
       await vi.advanceTimersByTimeAsync(1);
       expect(refreshGitStatusSpy).toHaveBeenCalledTimes(1);
-      expect(refreshGitStatusSpy).toHaveBeenCalledWith(GIT_CWD);
+      expect(refreshGitStatusSpy).toHaveBeenCalledWith({
+        environmentId: ENVIRONMENT_ID,
+        cwd: GIT_CWD,
+      });
     } finally {
       if (originalVisibilityState) {
         Object.defineProperty(document, "visibilityState", originalVisibilityState);
       }
+      vi.useRealTimers();
       await screen.unmount();
       host.remove();
     }

apps/web/src/components/GitActionsControl.tsx+42−20

+import { type ScopedThreadRef } from "@t3tools/contracts";
 import type {
   GitActionProgressEvent,
   GitRunStackedActionResult,
   GitStackedAction,
   GitStatusResult,
-  ThreadId,
 } from "@t3tools/contracts";
 import { useIsMutating, useMutation, useQueryClient } from "@tanstack/react-query";
 import { useCallback, useEffect, useEffectEvent, useMemo, useRef, useState } from "react";
 import { refreshGitStatus, useGitStatus } from "~/lib/gitStatusState";
 import { newCommandId, randomUUID } from "~/lib/utils";
 import { resolvePathLinkTarget } from "~/terminal-links";
-import { readNativeApi } from "~/nativeApi";
+import { readEnvironmentApi } from "~/environmentApi";
+import { readLocalApi } from "~/localApi";
 import { useStore } from "~/store";
+import { createThreadSelectorByRef } from "~/storeSelectors";
 interface GitActionsControlProps {
   gitCwd: string | null;
-  activeThreadId: ThreadId | null;
+  activeThreadRef: ScopedThreadRef | null;
 }
 interface PendingDefaultBranchAction {
   return <InfoIcon className={iconClassName} />;
 }
-export default function GitActionsControl({ gitCwd, activeThreadId }: GitActionsControlProps) {
+export default function GitActionsControl({ gitCwd, activeThreadRef }: GitActionsControlProps) {
+  const activeThreadId = activeThreadRef?.threadId ?? null;
+  const activeEnvironmentId = activeThreadRef?.environmentId ?? null;
   const threadToastData = useMemo(
     () => (activeThreadId ? { threadId: activeThreadId } : undefined),
     [activeThreadId],
   );
-  const activeServerThread = useStore((store) =>
+  const activeServerThreadSelector = useMemo(
-    activeThreadId ? store.threadShellById[activeThreadId] : undefined,
+    () => createThreadSelectorByRef(activeThreadRef),
+    [activeThreadRef],
   );
+  const activeServerThread = useStore(activeServerThreadSelector);
   const setThreadBranch = useStore((store) => store.setThreadBranch);
   const queryClient = useQueryClient();
   const [isCommitDialogOpen, setIsCommitDialogOpen] = useState(false);
       }
       const worktreePath = activeServerThread.worktreePath;
-      const api = readNativeApi();
+      const api = activeEnvironmentId ? readEnvironmentApi(activeEnvironmentId) : undefined;
       if (api) {
         void api.orchestration
           .dispatchCommand({
       setThreadBranch(activeThreadId, branch, worktreePath);
     },
-    [activeServerThread, activeThreadId, setThreadBranch],
+    [activeEnvironmentId, activeServerThread, activeThreadId, setThreadBranch],
   );
   const syncThreadBranchAfterGitAction = useCallback(
     [persistThreadBranchSync],
   );
-  const { data: gitStatus = null, error: gitStatusError } = useGitStatus(gitCwd);
+  const { data: gitStatus = null, error: gitStatusError } = useGitStatus({
+    environmentId: activeEnvironmentId,
+    cwd: gitCwd,
+  });
   // Default to true while loading so we don't flash init controls.
   const isRepo = gitStatus?.isRepo ?? true;
   const hasOriginRemote = gitStatus?.hasOriginRemote ?? false;
   const allSelected = excludedFiles.size === 0;
   const noneSelected = selectedFiles.length === 0;
-  const initMutation = useMutation(gitInitMutationOptions({ cwd: gitCwd, queryClient }));
+  const initMutation = useMutation(
+    gitInitMutationOptions({ environmentId: activeEnvironmentId, cwd: gitCwd, queryClient }),
+  );
   const runImmediateGitActionMutation = useMutation(
     gitRunStackedActionMutationOptions({
+      environmentId: activeEnvironmentId,
       cwd: gitCwd,
       queryClient,
     }),
   );
-  const pullMutation = useMutation(gitPullMutationOptions({ cwd: gitCwd, queryClient }));
+  const pullMutation = useMutation(
+    gitPullMutationOptions({ environmentId: activeEnvironmentId, cwd: gitCwd, queryClient }),
+  );
   const isRunStackedActionRunning =
-    useIsMutating({ mutationKey: gitMutationKeys.runStackedAction(gitCwd) }) > 0;
+    useIsMutating({
-  const isPullRunning = useIsMutating({ mutationKey: gitMutationKeys.pull(gitCwd) }) > 0;
+      mutationKey: gitMutationKeys.runStackedAction(activeEnvironmentId, gitCwd),
+    }) > 0;
+  const isPullRunning =
+    useIsMutating({ mutationKey: gitMutationKeys.pull(activeEnvironmentId, gitCwd) }) > 0;
   const isGitActionRunning = isRunStackedActionRunning || isPullRunning;
   useEffect(() => {
       }
       refreshTimeout = window.setTimeout(() => {
         refreshTimeout = null;
-        void refreshGitStatus(gitCwd).catch(() => undefined);
+        void refreshGitStatus({ environmentId: activeEnvironmentId, cwd: gitCwd }).catch(
+          () => undefined,
+        );
       }, GIT_STATUS_WINDOW_REFRESH_DEBOUNCE_MS);
     };
     const handleVisibilityChange = () => {
       window.removeEventListener("focus", scheduleRefreshCurrentGitStatus);
       document.removeEventListener("visibilitychange", handleVisibilityChange);
     };
-  }, [gitCwd]);
+  }, [activeEnvironmentId, gitCwd]);
   const openExistingPr = useCallback(async () => {
-    const api = readNativeApi();
+    const api = readLocalApi();
     if (!api) {
       toastManager.add({
         type: "error",
       });
       return;
     }
-    void api.shell.openExternal(prUrl).catch((err) => {
+    void api.shell.openExternal(prUrl).catch((err: unknown) => {
       toastManager.add({
         type: "error",
         title: "Unable to open PR link",
           toastActionProps = {
             children: toastCta.label,
             onClick: () => {
-              const api = readNativeApi();
+              const api = readLocalApi();
               if (!api) return;
               closeResultToast();
               void api.shell.openExternal(toastCta.url);
   const openChangedFileInEditor = useCallback(
     (filePath: string) => {
-      const api = readNativeApi();
+      const api = readLocalApi();
       if (!api || !gitCwd) {
         toastManager.add({
           type: "error",
           <Menu
             onOpenChange={(open) => {
               if (open) {
-                void refreshGitStatus(gitCwd).catch(() => undefined);
+                void refreshGitStatus({
+                  environmentId: activeEnvironmentId,
+                  cwd: gitCwd,
+                }).catch(() => undefined);
               }
             }}
           >

apps/web/src/components/KeybindingsToast.browser.tsx+26−23

 import {
   DEFAULT_SERVER_SETTINGS,
+  EnvironmentId,
   ORCHESTRATION_WS_METHODS,
   type MessageId,
   type OrchestrationReadModel,
 import { render } from "vitest-browser-react";
 import { useComposerDraftStore } from "../composerDraftStore";
-import { __resetNativeApiForTests } from "../nativeApi";
+import { __resetLocalApiForTests } from "../localApi";
 import { AppAtomRegistryProvider } from "../rpc/atomRegistry";
 import { getServerConfig } from "../rpc/serverState";
 import { getRouter } from "../router";
 const THREAD_ID = "thread-kb-toast-test" as ThreadId;
 const PROJECT_ID = "project-1" as ProjectId;
+const LOCAL_ENVIRONMENT_ID = EnvironmentId.makeUnsafe("environment-local");
 const NOW_ISO = "2026-03-04T12:00:00.000Z";
 interface TestFixture {
 function createBaseServerConfig(): ServerConfig {
   return {
+    environment: {
+      environmentId: LOCAL_ENVIRONMENT_ID,
+      label: "Local environment",
+      platform: { os: "darwin" as const, arch: "arm64" as const },
+      serverVersion: "0.0.0-test",
+      capabilities: { repositoryIdentity: true },
+    },
     cwd: "/repo/project",
     keybindingsConfigPath: "/repo/project/.t3code-keybindings.json",
     keybindings: [],
     snapshot: createMinimalSnapshot(),
     serverConfig: createBaseServerConfig(),
     welcome: {
+      environment: {
+        environmentId: LOCAL_ENVIRONMENT_ID,
+        label: "Local environment",
+        platform: { os: "darwin" as const, arch: "arm64" as const },
+        serverVersion: "0.0.0-test",
+        capabilities: { repositoryIdentity: true },
+      },
       cwd: "/repo/project",
       projectName: "Project",
       bootstrapProjectId: PROJECT_ID,
   host.style.overflow = "hidden";
   document.body.append(host);
-  const router = getRouter(createMemoryHistory({ initialEntries: [`/${THREAD_ID}`] }));
+  const router = getRouter(
+    createMemoryHistory({ initialEntries: [`/${LOCAL_ENVIRONMENT_ID}/${THREAD_ID}`] }),
+  );
   const screen = await render(
     <AppAtomRegistryProvider>
         return [];
       },
     });
-    await __resetNativeApiForTests();
+    await __resetLocalApiForTests();
     localStorage.clear();
     document.body.innerHTML = "";
     useComposerDraftStore.setState({
-      draftsByThreadId: {},
+      draftsByThreadKey: {},
-      draftThreadsByThreadId: {},
+      draftThreadsByThreadKey: {},
-      projectDraftThreadIdByProjectId: {},
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
     });
     useStore.setState({
-      projectIds: [],
+      activeEnvironmentId: null,
-      projectById: {},
+      environmentStateById: {},
-      threadIds: [],
-      threadIdsByProjectId: {},
-      threadShellById: {},
-      threadSessionById: {},
-      threadTurnStateById: {},
-      messageIdsByThreadId: {},
-      messageByThreadId: {},
-      activityIdsByThreadId: {},
-      activityByThreadId: {},
-      proposedPlanIdsByThreadId: {},
-      proposedPlanByThreadId: {},
-      turnDiffIdsByThreadId: {},
-      turnDiffSummaryByThreadId: {},
-      sidebarThreadSummaryById: {},
-      bootstrapComplete: false,
     });
   });

apps/web/src/components/PlanSidebar.tsx+6−3

 import { memo, useState, useCallback } from "react";
+import type { EnvironmentId } from "@t3tools/contracts";
 import { type TimestampFormat } from "@t3tools/contracts/settings";
 import { Badge } from "./ui/badge";
 import { Button } from "./ui/button";
   stripDisplayedPlanMarkdown,
 } from "../proposedPlan";
 import { Menu, MenuItem, MenuPopup, MenuTrigger } from "./ui/menu";
-import { readNativeApi } from "~/nativeApi";
+import { readEnvironmentApi } from "~/environmentApi";
 import { toastManager } from "./ui/toast";
 import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";
 interface PlanSidebarProps {
   activePlan: ActivePlanState | null;
   activeProposedPlan: LatestProposedPlanState | null;
+  environmentId: EnvironmentId;
   markdownCwd: string | undefined;
   workspaceRoot: string | undefined;
   timestampFormat: TimestampFormat;
 const PlanSidebar = memo(function PlanSidebar({
   activePlan,
   activeProposedPlan,
+  environmentId,
   markdownCwd,
   workspaceRoot,
   timestampFormat,
   }, [planMarkdown]);
   const handleSaveToWorkspace = useCallback(() => {
-    const api = readNativeApi();
+    const api = readEnvironmentApi(environmentId);
     if (!api || !workspaceRoot || !planMarkdown) return;
     const filename = buildProposedPlanMarkdownFilename(planMarkdown);
     setIsSavingToWorkspace(true);
         () => setIsSavingToWorkspace(false),
         () => setIsSavingToWorkspace(false),
       );
-  }, [planMarkdown, workspaceRoot]);
+  }, [environmentId, planMarkdown, workspaceRoot]);
   return (
     <div className="flex h-full w-[340px] shrink-0 flex-col border-l border-border/70 bg-card/50">

apps/web/src/components/PullRequestThreadDialog.tsx+7−3

-import type { GitResolvePullRequestResult, ThreadId } from "@t3tools/contracts";
+import type { EnvironmentId, GitResolvePullRequestResult, ThreadId } from "@t3tools/contracts";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useDebouncedValue } from "@tanstack/react-pacer";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 interface PullRequestThreadDialogProps {
   open: boolean;
+  environmentId: EnvironmentId;
   threadId: ThreadId;
   cwd: string | null;
   initialReference: string | null;
 export function PullRequestThreadDialog({
   open,
+  environmentId,
   threadId,
   cwd,
   initialReference,
   const parsedDebouncedReference = parsePullRequestReference(debouncedReference);
   const resolvePullRequestQuery = useQuery(
     gitResolvePullRequestQueryOptions({
+      environmentId,
       cwd,
       reference: open ? parsedDebouncedReference : null,
     }),
     const cached = queryClient.getQueryData<GitResolvePullRequestResult>([
       "git",
       "pull-request",
+      environmentId,
       cwd,
       parsedReference,
     ]);
     return cached?.pullRequest ?? null;
-  }, [cwd, parsedReference, queryClient]);
+  }, [cwd, environmentId, parsedReference, queryClient]);
   const preparePullRequestThreadMutation = useMutation(
-    gitPreparePullRequestThreadMutationOptions({ cwd, queryClient }),
+    gitPreparePullRequestThreadMutationOptions({ environmentId, cwd, queryClient }),
   );
   const liveResolvedPullRequest =

apps/web/src/components/Sidebar.logic.test.ts+5−1

   sortThreadsForSidebar,
   THREAD_JUMP_HINT_SHOW_DELAY_MS,
 } from "./Sidebar.logic";
-import { OrchestrationLatestTurn, ProjectId, ThreadId } from "@t3tools/contracts";
+import { EnvironmentId, OrchestrationLatestTurn, ProjectId, ThreadId } from "@t3tools/contracts";
 import {
   DEFAULT_INTERACTION_MODE,
   DEFAULT_RUNTIME_MODE,
   type Thread,
 } from "../types";
+const localEnvironmentId = EnvironmentId.makeUnsafe("environment-local");
 function makeLatestTurn(overrides?: {
   completedAt?: string | null;
   startedAt?: string | null;
   const { defaultModelSelection, ...rest } = overrides;
   return {
     id: ProjectId.makeUnsafe("project-1"),
+    environmentId: localEnvironmentId,
     name: "Project",
     cwd: "/tmp/project",
     defaultModelSelection: {
 function makeThread(overrides: Partial<Thread> = {}): Thread {
   return {
     id: ThreadId.makeUnsafe("thread-1"),
+    environmentId: localEnvironmentId,
     codexThreadId: null,
     projectId: ProjectId.makeUnsafe("project-1"),
     title: "Thread",

apps/web/src/components/Sidebar.tsx+2083−1402

@@ -12,20 +12,7 @@ import { · 11 unmodified lines
12	} from "lucide-react";	12	} from "lucide-react";
13	import { ProjectFavicon } from "./ProjectFavicon";	13	import { ProjectFavicon } from "./ProjectFavicon";
14	import { autoAnimate } from "@formkit/auto-animate";	14	import { autoAnimate } from "@formkit/auto-animate";
15	import {	15	import React, { useCallback, useEffect, memo, useMemo, useRef, useState } from "react";
16	useCallback,
17	useEffect,
18	useMemo,
19	useRef,
20	useState,
21	type Dispatch,
22	type KeyboardEvent,
23	type MouseEvent,
24	type MutableRefObject,
25	type PointerEvent,
26	type ReactNode,
27	type SetStateAction,
28	} from "react";
29	import { useShallow } from "zustand/react/shallow";	16	import { useShallow } from "zustand/react/shallow";
30	import {	17	import {
31	DndContext,	18	DndContext,
@@ -45,11 +32,20 @@ import { CSS } from "@dnd-kit/utilities"; · 13 unmodified lines
45	import {	32	import {
46	DEFAULT_MODEL_BY_PROVIDER,	33	DEFAULT_MODEL_BY_PROVIDER,
47	type DesktopUpdateState,	34	type DesktopUpdateState,
		35	type EnvironmentId,
48	ProjectId,	36	ProjectId,
		37	type ScopedThreadRef,
		38	type ThreadEnvMode,
49	ThreadId,	39	ThreadId,
50	type GitStatusResult,	40	type GitStatusResult,
51	} from "@t3tools/contracts";	41	} from "@t3tools/contracts";
52	import { Link, useLocation, useNavigate, useParams } from "@tanstack/react-router";	42	import {
		43	scopedProjectKey,
		44	scopedThreadKey,
		45	scopeProjectRef,
		46	scopeThreadRef,
		47	} from "@t3tools/client-runtime";
		48	import { Link, useLocation, useNavigate, useParams, useRouter } from "@tanstack/react-router";
53	import {	49	import {
54	type SidebarProjectSortOrder,	50	type SidebarProjectSortOrder,
55	type SidebarThreadSortOrder,	51	type SidebarThreadSortOrder,
@@ -58,7 +54,13 @@ import { isElectron } from "../env"; · 2 unmodified lines
58	import { APP_STAGE_LABEL, APP_VERSION } from "../branding";	54	import { APP_STAGE_LABEL, APP_VERSION } from "../branding";
59	import { isTerminalFocused } from "../lib/terminalFocus";	55	import { isTerminalFocused } from "../lib/terminalFocus";
60	import { isLinuxPlatform, isMacPlatform, newCommandId, newProjectId } from "../lib/utils";	56	import { isLinuxPlatform, isMacPlatform, newCommandId, newProjectId } from "../lib/utils";
61	import { useStore } from "../store";	57	import {
		58	selectProjectsAcrossEnvironments,
		59	selectSidebarThreadsForProjectRef,
		60	selectSidebarThreadsAcrossEnvironments,
		61	selectThreadByRef,
		62	useStore,
		63	} from "../store";
62	import { selectThreadTerminalState, useTerminalStateStore } from "../terminalStateStore";	64	import { selectThreadTerminalState, useTerminalStateStore } from "../terminalStateStore";
63	import { useUiStateStore } from "../uiStateStore";	65	import { useUiStateStore } from "../uiStateStore";
64	import {	66	import {
@@ -70,11 +72,16 @@ import { · 5 unmodified lines
70	threadTraversalDirectionFromCommand,	72	threadTraversalDirectionFromCommand,
71	} from "../keybindings";	73	} from "../keybindings";
72	import { useGitStatus } from "../lib/gitStatusState";	74	import { useGitStatus } from "../lib/gitStatusState";
73	import { readNativeApi } from "../nativeApi";	75	import { readLocalApi } from "../localApi";
74	import { useComposerDraftStore } from "../composerDraftStore";	76	import { useComposerDraftStore } from "../composerDraftStore";
75	import { useHandleNewThread } from "../hooks/useHandleNewThread";	77	import { useHandleNewThread } from "../hooks/useHandleNewThread";
76		78
77	import { useThreadActions } from "../hooks/useThreadActions";	79	import { useThreadActions } from "../hooks/useThreadActions";
		80	import {
		81	buildThreadRouteParams,
		82	resolveThreadRouteRef,
		83	resolveThreadRouteTarget,
		84	} from "../threadRoutes";
78	import { toastManager } from "./ui/toast";	85	import { toastManager } from "./ui/toast";
79	import { formatRelativeTimeLabel } from "../timestampFormat";	86	import { formatRelativeTimeLabel } from "../timestampFormat";
80	import { SettingsSidebarNav } from "./settings/SettingsSidebarNav";	87	import { SettingsSidebarNav } from "./settings/SettingsSidebarNav";
@@ -109,8 +116,6 @@ import { · 28 unmodified lines
109	import { useThreadSelectionStore } from "../threadSelectionStore";	116	import { useThreadSelectionStore } from "../threadSelectionStore";
110	import { isNonEmpty as isNonEmptyString } from "effect/String";	117	import { isNonEmpty as isNonEmptyString } from "effect/String";
111	import {	118	import {
112	getVisibleSidebarThreadIds,
113	getVisibleThreadsForProject,
114	resolveAdjacentThreadId,	119	resolveAdjacentThreadId,
115	isContextMenuPointerDown,	120	isContextMenuPointerDown,
116	resolveProjectStatusIndicator,	121	resolveProjectStatusIndicator,
@@ -123,12 +128,14 @@ import { · 6 unmodified lines
123	sortProjectsForSidebar,	128	sortProjectsForSidebar,
124	sortThreadsForSidebar,	129	sortThreadsForSidebar,
125	useThreadJumpHintVisibility,	130	useThreadJumpHintVisibility,
		131	ThreadStatusPill,
126	} from "./Sidebar.logic";	132	} from "./Sidebar.logic";
127	import { SidebarUpdatePill } from "./sidebar/SidebarUpdatePill";	133	import { SidebarUpdatePill } from "./sidebar/SidebarUpdatePill";
128	import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";	134	import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";
		135	import { readEnvironmentApi } from "../environmentApi";
129	import { useSettings, useUpdateSettings } from "~/hooks/useSettings";	136	import { useSettings, useUpdateSettings } from "~/hooks/useSettings";
130	import { useServerKeybindings } from "../rpc/serverState";	137	import { useServerKeybindings } from "../rpc/serverState";
131	import type { Project } from "../types";	138	import type { Project, SidebarThreadSummary } from "../types";
132	const THREAD_PREVIEW_LIMIT = 6;	139	const THREAD_PREVIEW_LIMIT = 6;
133	const SIDEBAR_SORT_LABELS: Record<SidebarProjectSortOrder, string> = {	140	const SIDEBAR_SORT_LABELS: Record<SidebarProjectSortOrder, string> = {
134	updated_at: "Last user message",	141	updated_at: "Last user message",
@@ -143,9 +150,58 @@ const SIDEBAR_LIST_ANIMATION_OPTIONS = { · 8 unmodified lines
143	duration: 180,	150	duration: 180,
144	easing: "ease-out",	151	easing: "ease-out",
145	} as const;	152	} as const;
		153	const EMPTY_THREAD_JUMP_LABELS = new Map<string, string>();
		154
		155	function threadJumpLabelMapsEqual(
		156	left: ReadonlyMap<string, string>,
		157	right: ReadonlyMap<string, string>,
		158	): boolean {
		159	if (left === right) {
		160	return true;
		161	}
		162	if (left.size !== right.size) {
		163	return false;
		164	}
		165	for (const [key, value] of left) {
		166	if (right.get(key) !== value) {
		167	return false;
		168	}
		169	}
		170	return true;
		171	}
		172
		173	function buildThreadJumpLabelMap(input: {
		174	keybindings: ReturnType<typeof useServerKeybindings>;
		175	platform: string;
		176	terminalOpen: boolean;
		177	threadJumpCommandByKey: ReadonlyMap<
		178	string,
		179	NonNullable<ReturnType<typeof threadJumpCommandForIndex>>
		180	>;
		181	}): ReadonlyMap<string, string> {
		182	if (input.threadJumpCommandByKey.size === 0) {
		183	return EMPTY_THREAD_JUMP_LABELS;
		184	}
		185
		186	const shortcutLabelOptions = {
		187	platform: input.platform,
		188	context: {
		189	terminalFocus: false,
		190	terminalOpen: input.terminalOpen,
		191	},
		192	} as const;
		193	const mapping = new Map<string, string>();
		194	for (const [threadKey, command] of input.threadJumpCommandByKey) {
		195	const label = shortcutLabelForCommand(input.keybindings, command, shortcutLabelOptions);
		196	if (label) {
		197	mapping.set(threadKey, label);
		198	}
		199	}
		200	return mapping.size > 0 ? mapping : EMPTY_THREAD_JUMP_LABELS;
		201	}
146		202
147	type SidebarProjectSnapshot = Project & {	203	type SidebarProjectSnapshot = Project & {
148	expanded: boolean;	204	projectKey: string;
149	};	205	};
150	interface TerminalStatusIndicator {	206	interface TerminalStatusIndicator {
151	label: "Terminal process running";	207	label: "Terminal process running";
@@ -166,7 +222,7 @@ function ThreadStatusLabel({ · 14 unmodified lines
166	status,	222	status,
167	compact = false,	223	compact = false,
168	}: {	224	}: {
169	status: NonNullable<ReturnType<typeof resolveThreadStatusPill>>;	225	status: ThreadStatusPill;
170	compact?: boolean;	226	compact?: boolean;
171	}) {	227	}) {
172	if (compact) {	228	if (compact) {
@@ -255,57 +311,81 @@ function resolveThreadPr( · 82 unmodified lines
255	}	311	}
256		312
257	interface SidebarThreadRowProps {	313	interface SidebarThreadRowProps {
258	threadId: ThreadId;	314	thread: SidebarThreadSummary;
259	projectCwd: string \| null;	315	projectCwd: string \| null;
260	orderedProjectThreadIds: readonly ThreadId[];	316	orderedProjectThreadKeys: readonly string[];
261	routeThreadId: ThreadId \| null;	317	isActive: boolean;
262	selectedThreadIds: ReadonlySet<ThreadId>;
263	showThreadJumpHints: boolean;
264	jumpLabel: string \| null;	318	jumpLabel: string \| null;
265	appSettingsConfirmThreadArchive: boolean;	319	appSettingsConfirmThreadArchive: boolean;
266	renamingThreadId: ThreadId \| null;	320	renamingThreadKey: string \| null;
267	renamingTitle: string;	321	renamingTitle: string;
268	setRenamingTitle: (title: string) => void;	322	setRenamingTitle: (title: string) => void;
269	onRenamingInputMount: (element: HTMLInputElement \| null) => void;	323	renamingInputRef: React.RefObject<HTMLInputElement \| null>;
270	hasRenameCommitted: () => boolean;	324	renamingCommittedRef: React.RefObject<boolean>;
271	markRenameCommitted: () => void;	325	confirmingArchiveThreadKey: string \| null;
272	confirmingArchiveThreadId: ThreadId \| null;	326	setConfirmingArchiveThreadKey: React.Dispatch<React.SetStateAction<string \| null>>;
273	setConfirmingArchiveThreadId: Dispatch<SetStateAction<ThreadId \| null>>;	327	confirmArchiveButtonRefs: React.RefObject<Map<string, HTMLButtonElement>>;
274	confirmArchiveButtonRefs: MutableRefObject<Map<ThreadId, HTMLButtonElement>>;
275	handleThreadClick: (	328	handleThreadClick: (
276	event: MouseEvent,	329	event: React.MouseEvent,
277	threadId: ThreadId,	330	threadRef: ScopedThreadRef,
278	orderedProjectThreadIds: readonly ThreadId[],	331	orderedProjectThreadKeys: readonly string[],
279	) => void;	332	) => void;
280	navigateToThread: (threadId: ThreadId) => void;	333	navigateToThread: (threadRef: ScopedThreadRef) => void;
281	handleMultiSelectContextMenu: (position: { x: number; y: number }) => Promise<void>;	334	handleMultiSelectContextMenu: (position: { x: number; y: number }) => Promise<void>;
282	handleThreadContextMenu: (	335	handleThreadContextMenu: (
283	threadId: ThreadId,	336	threadRef: ScopedThreadRef,
284	position: { x: number; y: number },	337	position: { x: number; y: number },
285	) => Promise<void>;	338	) => Promise<void>;
286	clearSelection: () => void;	339	clearSelection: () => void;
287	commitRename: (threadId: ThreadId, newTitle: string, originalTitle: string) => Promise<void>;	340	commitRename: (
		341	threadRef: ScopedThreadRef,
		342	newTitle: string,
		343	originalTitle: string,
		344	) => Promise<void>;
288	cancelRename: () => void;	345	cancelRename: () => void;
289	attemptArchiveThread: (threadId: ThreadId) => Promise<void>;	346	attemptArchiveThread: (threadRef: ScopedThreadRef) => Promise<void>;
290	openPrLink: (event: MouseEvent<HTMLElement>, prUrl: string) => void;	347	openPrLink: (event: React.MouseEvent<HTMLElement>, prUrl: string) => void;
291	}	348	}
292		349
293	function SidebarThreadRow(props: SidebarThreadRowProps) {	350	const SidebarThreadRow = memo(function SidebarThreadRow(props: SidebarThreadRowProps) {
294	const thread = useStore((state) => state.sidebarThreadSummaryById[props.threadId]);	351	const {
295	const lastVisitedAt = useUiStateStore((state) => state.threadLastVisitedAtById[props.threadId]);	352	orderedProjectThreadKeys,
		353	isActive,
		354	jumpLabel,
		355	appSettingsConfirmThreadArchive,
		356	renamingThreadKey,
		357	renamingTitle,
		358	setRenamingTitle,
		359	renamingInputRef,
		360	renamingCommittedRef,
		361	confirmingArchiveThreadKey,
		362	setConfirmingArchiveThreadKey,
		363	confirmArchiveButtonRefs,
		364	handleThreadClick,
		365	navigateToThread,
		366	handleMultiSelectContextMenu,
		367	handleThreadContextMenu,
		368	clearSelection,
		369	commitRename,
		370	cancelRename,
		371	attemptArchiveThread,
		372	openPrLink,
		373	thread,
		374	} = props;
		375	const threadRef = scopeThreadRef(thread.environmentId, thread.id);
		376	const threadKey = scopedThreadKey(threadRef);
		377	const lastVisitedAt = useUiStateStore((state) => state.threadLastVisitedAtById[threadKey]);
		378	const isSelected = useThreadSelectionStore((state) => state.selectedThreadKeys.has(threadKey));
		379	const hasSelection = useThreadSelectionStore((state) => state.selectedThreadKeys.size > 0);
296	const runningTerminalIds = useTerminalStateStore(	380	const runningTerminalIds = useTerminalStateStore(
297	(state) =>	381	(state) =>
298	selectThreadTerminalState(state.terminalStateByThreadId, props.threadId).runningTerminalIds,	382	selectThreadTerminalState(state.terminalStateByThreadKey, threadRef).runningTerminalIds,
299	);	383	);
300	const gitCwd = thread?.worktreePath ?? props.projectCwd;	384	const gitCwd = thread.worktreePath ?? props.projectCwd;
301	const gitStatus = useGitStatus(thread?.branch != null ? gitCwd : null);	385	const gitStatus = useGitStatus({
302		386	environmentId: thread.environmentId,
303	if (!thread) {	387	cwd: thread.branch != null ? gitCwd : null,
304	return null;	388	});
305	}
306
307	const isActive = props.routeThreadId === thread.id;
308	const isSelected = props.selectedThreadIds.has(thread.id);
309	const isHighlighted = isActive \|\| isSelected;	389	const isHighlighted = isActive \|\| isSelected;
310	const isThreadRunning =	390	const isThreadRunning =
311	thread.session?.status === "running" && thread.session.activeTurnId != null;	391	thread.session?.status === "running" && thread.session.activeTurnId != null;
@@ -318,32 +398,173 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 6 unmodified lines
318	const pr = resolveThreadPr(thread.branch, gitStatus.data);	398	const pr = resolveThreadPr(thread.branch, gitStatus.data);
319	const prStatus = prStatusIndicator(pr);	399	const prStatus = prStatusIndicator(pr);
320	const terminalStatus = terminalStatusFromRunningIds(runningTerminalIds);	400	const terminalStatus = terminalStatusFromRunningIds(runningTerminalIds);
321	const isConfirmingArchive = props.confirmingArchiveThreadId === thread.id && !isThreadRunning;	401	const isConfirmingArchive = confirmingArchiveThreadKey === threadKey && !isThreadRunning;
322	const threadMetaClassName = isConfirmingArchive	402	const threadMetaClassName = isConfirmingArchive
323	? "pointer-events-none opacity-0"	403	? "pointer-events-none opacity-0"
324	: !isThreadRunning	404	: !isThreadRunning
325	? "pointer-events-none transition-opacity duration-150 group-hover/menu-sub-item:opacity-0 group-focus-within/menu-sub-item:opacity-0"	405	? "pointer-events-none transition-opacity duration-150 group-hover/menu-sub-item:opacity-0 group-focus-within/menu-sub-item:opacity-0"
326	: "pointer-events-none";	406	: "pointer-events-none";
		407	const clearConfirmingArchive = useCallback(() => {
		408	setConfirmingArchiveThreadKey((current) => (current === threadKey ? null : current));
		409	}, [setConfirmingArchiveThreadKey, threadKey]);
		410	const handleMouseLeave = useCallback(() => {
		411	clearConfirmingArchive();
		412	}, [clearConfirmingArchive]);
		413	const handleBlurCapture = useCallback(
		414	(event: React.FocusEvent<HTMLLIElement>) => {
		415	const currentTarget = event.currentTarget;
		416	requestAnimationFrame(() => {
		417	if (currentTarget.contains(document.activeElement)) {
		418	return;
		419	}
		420	clearConfirmingArchive();
		421	});
		422	},
		423	[clearConfirmingArchive],
		424	);
		425	const handleRowClick = useCallback(
		426	(event: React.MouseEvent) => {
		427	handleThreadClick(event, threadRef, orderedProjectThreadKeys);
		428	},
		429	[handleThreadClick, orderedProjectThreadKeys, threadRef],
		430	);
		431	const handleRowKeyDown = useCallback(
		432	(event: React.KeyboardEvent) => {
		433	if (event.key !== "Enter" && event.key !== " ") return;
		434	event.preventDefault();
		435	navigateToThread(threadRef);
		436	},
		437	[navigateToThread, threadRef],
		438	);
		439	const handleRowContextMenu = useCallback(
		440	(event: React.MouseEvent) => {
		441	event.preventDefault();
		442	if (hasSelection && isSelected) {
		443	void handleMultiSelectContextMenu({
		444	x: event.clientX,
		445	y: event.clientY,
		446	});
		447	return;
		448	}
		449
		450	if (hasSelection) {
		451	clearSelection();
		452	}
		453	void handleThreadContextMenu(threadRef, {
		454	x: event.clientX,
		455	y: event.clientY,
		456	});
		457	},
		458	[
		459	clearSelection,
		460	handleMultiSelectContextMenu,
		461	handleThreadContextMenu,
		462	hasSelection,
		463	isSelected,
		464	threadRef,
		465	],
		466	);
		467	const handlePrClick = useCallback(
		468	(event: React.MouseEvent<HTMLButtonElement>) => {
		469	if (!prStatus) return;
		470	openPrLink(event, prStatus.url);
		471	},
		472	[openPrLink, prStatus],
		473	);
		474	const handleRenameInputRef = useCallback(
		475	(element: HTMLInputElement \| null) => {
		476	if (element && renamingInputRef.current !== element) {
		477	renamingInputRef.current = element;
		478	element.focus();
		479	element.select();
		480	}
		481	},
		482	[renamingInputRef],
		483	);
		484	const handleRenameInputChange = useCallback(
		485	(event: React.ChangeEvent<HTMLInputElement>) => {
		486	setRenamingTitle(event.target.value);
		487	},
		488	[setRenamingTitle],
		489	);
		490	const handleRenameInputKeyDown = useCallback(
		491	(event: React.KeyboardEvent<HTMLInputElement>) => {
		492	event.stopPropagation();
		493	if (event.key === "Enter") {
		494	event.preventDefault();
		495	renamingCommittedRef.current = true;
		496	void commitRename(threadRef, renamingTitle, thread.title);
		497	} else if (event.key === "Escape") {
		498	event.preventDefault();
		499	renamingCommittedRef.current = true;
		500	cancelRename();
		501	}
		502	},
		503	[cancelRename, commitRename, renamingCommittedRef, renamingTitle, thread.title, threadRef],
		504	);
		505	const handleRenameInputBlur = useCallback(() => {
		506	if (!renamingCommittedRef.current) {
		507	void commitRename(threadRef, renamingTitle, thread.title);
		508	}
		509	}, [commitRename, renamingCommittedRef, renamingTitle, thread.title, threadRef]);
		510	const handleRenameInputClick = useCallback((event: React.MouseEvent<HTMLInputElement>) => {
		511	event.stopPropagation();
		512	}, []);
		513	const handleConfirmArchiveRef = useCallback(
		514	(element: HTMLButtonElement \| null) => {
		515	if (element) {
		516	confirmArchiveButtonRefs.current.set(threadKey, element);
		517	} else {
		518	confirmArchiveButtonRefs.current.delete(threadKey);
		519	}
		520	},
		521	[confirmArchiveButtonRefs, threadKey],
		522	);
		523	const stopPropagationOnPointerDown = useCallback(
		524	(event: React.PointerEvent<HTMLButtonElement>) => {
		525	event.stopPropagation();
		526	},
		527	[],
		528	);
		529	const handleConfirmArchiveClick = useCallback(
		530	(event: React.MouseEvent<HTMLButtonElement>) => {
		531	event.preventDefault();
		532	event.stopPropagation();
		533	clearConfirmingArchive();
		534	void attemptArchiveThread(threadRef);
		535	},
		536	[attemptArchiveThread, clearConfirmingArchive, threadRef],
		537	);
		538	const handleStartArchiveConfirmation = useCallback(
		539	(event: React.MouseEvent<HTMLButtonElement>) => {
		540	event.preventDefault();
		541	event.stopPropagation();
		542	setConfirmingArchiveThreadKey(threadKey);
		543	requestAnimationFrame(() => {
		544	confirmArchiveButtonRefs.current.get(threadKey)?.focus();
		545	});
		546	},
		547	[confirmArchiveButtonRefs, setConfirmingArchiveThreadKey, threadKey],
		548	);
		549	const handleArchiveImmediateClick = useCallback(
		550	(event: React.MouseEvent<HTMLButtonElement>) => {
		551	event.preventDefault();
		552	event.stopPropagation();
		553	void attemptArchiveThread(threadRef);
		554	},
		555	[attemptArchiveThread, threadRef],
		556	);
		557	const rowButtonRender = useMemo(() => <div role="button" tabIndex={0} />, []);
327		558
328	return (	559	return (
329	<SidebarMenuSubItem	560	<SidebarMenuSubItem
330	className="w-full"	561	className="w-full"
331	data-thread-item	562	data-thread-item
332	onMouseLeave={() => {	563	onMouseLeave={handleMouseLeave}
333	props.setConfirmingArchiveThreadId((current) => (current === thread.id ? null : current));	564	onBlurCapture={handleBlurCapture}
334	}}
335	onBlurCapture={(event) => {
336	const currentTarget = event.currentTarget;
337	requestAnimationFrame(() => {
338	if (currentTarget.contains(document.activeElement)) {
339	return;
340	}
341	props.setConfirmingArchiveThreadId((current) => (current === thread.id ? null : current));
342	});
343	}}
344	>	565	>
345	<SidebarMenuSubButton	566	<SidebarMenuSubButton
346	render={<div role="button" tabIndex={0} />}	567	render={rowButtonRender}
347	size="sm"	568	size="sm"
348	isActive={isActive}	569	isActive={isActive}
349	data-testid={`thread-row-${thread.id}`}	570	data-testid={`thread-row-${thread.id}`}
@@ -351,31 +572,9 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 1 unmodified line
351	isActive,	572	isActive,
352	isSelected,	573	isSelected,
353	})} relative isolate`}	574	})} relative isolate`}
354	onClick={(event) => {	575	onClick={handleRowClick}
355	props.handleThreadClick(event, thread.id, props.orderedProjectThreadIds);	576	onKeyDown={handleRowKeyDown}
356	}}	577	onContextMenu={handleRowContextMenu}
357	onKeyDown={(event) => {
358	if (event.key !== "Enter" && event.key !== " ") return;
359	event.preventDefault();
360	props.navigateToThread(thread.id);
361	}}
362	onContextMenu={(event) => {
363	event.preventDefault();
364	if (props.selectedThreadIds.size > 0 && props.selectedThreadIds.has(thread.id)) {
365	void props.handleMultiSelectContextMenu({
366	x: event.clientX,
367	y: event.clientY,
368	});
369	} else {
370	if (props.selectedThreadIds.size > 0) {
371	props.clearSelection();
372	}
373	void props.handleThreadContextMenu(thread.id, {
374	x: event.clientX,
375	y: event.clientY,
376	});
377	}
378	}}
379	>	578	>
380	<div className="flex min-w-0 flex-1 items-center gap-1.5 text-left">	579	<div className="flex min-w-0 flex-1 items-center gap-1.5 text-left">
381	{prStatus && (	580	{prStatus && (
@@ -386,9 +585,7 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 4 unmodified lines
386	type="button"	585	type="button"
387	aria-label={prStatus.tooltip}	586	aria-label={prStatus.tooltip}
388	className={`inline-flex items-center justify-center ${prStatus.colorClass} cursor-pointer rounded-sm outline-hidden focus-visible:ring-1 focus-visible:ring-ring`}	587	className={`inline-flex items-center justify-center ${prStatus.colorClass} cursor-pointer rounded-sm outline-hidden focus-visible:ring-1 focus-visible:ring-ring`}
389	onClick={(event) => {	588	onClick={handlePrClick}
390	props.openPrLink(event, prStatus.url);
391	}}
392	>	589	>
393	<GitPullRequestIcon className="size-3" />	590	<GitPullRequestIcon className="size-3" />
394	</button>	591	</button>
@@ -398,30 +595,15 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 3 unmodified lines
398	</Tooltip>	595	</Tooltip>
399	)}	596	)}
400	{threadStatus && <ThreadStatusLabel status={threadStatus} />}	597	{threadStatus && <ThreadStatusLabel status={threadStatus} />}
401	{props.renamingThreadId === thread.id ? (	598	{renamingThreadKey === threadKey ? (
402	<input	599	<input
403	ref={props.onRenamingInputMount}	600	ref={handleRenameInputRef}
404	className="min-w-0 flex-1 truncate text-xs bg-transparent outline-none border border-ring rounded px-0.5"	601	className="min-w-0 flex-1 truncate text-xs bg-transparent outline-none border border-ring rounded px-0.5"
405	value={props.renamingTitle}	602	value={renamingTitle}
406	onChange={(event) => props.setRenamingTitle(event.target.value)}	603	onChange={handleRenameInputChange}
407	onKeyDown={(event) => {	604	onKeyDown={handleRenameInputKeyDown}
408	event.stopPropagation();	605	onBlur={handleRenameInputBlur}
409	if (event.key === "Enter") {	606	onClick={handleRenameInputClick}
410	event.preventDefault();
411	props.markRenameCommitted();
412	void props.commitRename(thread.id, props.renamingTitle, thread.title);
413	} else if (event.key === "Escape") {
414	event.preventDefault();
415	props.markRenameCommitted();
416	props.cancelRename();
417	}
418	}}
419	onBlur={() => {
420	if (!props.hasRenameCommitted()) {
421	void props.commitRename(thread.id, props.renamingTitle, thread.title);
422	}
423	}}
424	onClick={(event) => event.stopPropagation()}
425	/>	607	/>
426	) : (	608	) : (
427	<span className="min-w-0 flex-1 truncate text-xs">{thread.title}</span>	609	<span className="min-w-0 flex-1 truncate text-xs">{thread.title}</span>
@@ -441,34 +623,19 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 13 unmodified lines
441	<div className="flex min-w-12 justify-end">	623	<div className="flex min-w-12 justify-end">
442	{isConfirmingArchive ? (	624	{isConfirmingArchive ? (
443	<button	625	<button
444	ref={(element) => {	626	ref={handleConfirmArchiveRef}
445	if (element) {
446	props.confirmArchiveButtonRefs.current.set(thread.id, element);
447	} else {
448	props.confirmArchiveButtonRefs.current.delete(thread.id);
449	}
450	}}
451	type="button"	627	type="button"
452	data-thread-selection-safe	628	data-thread-selection-safe
453	data-testid={`thread-archive-confirm-${thread.id}`}	629	data-testid={`thread-archive-confirm-${thread.id}`}
454	aria-label={`Confirm archive ${thread.title}`}	630	aria-label={`Confirm archive ${thread.title}`}
455	className="absolute top-1/2 right-1 inline-flex h-5 -translate-y-1/2 cursor-pointer items-center rounded-full bg-destructive/12 px-2 text-[10px] font-medium text-destructive transition-colors hover:bg-destructive/18 focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-destructive/40"	631	className="absolute top-1/2 right-1 inline-flex h-5 -translate-y-1/2 cursor-pointer items-center rounded-full bg-destructive/12 px-2 text-[10px] font-medium text-destructive transition-colors hover:bg-destructive/18 focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-destructive/40"
456	onPointerDown={(event) => {	632	onPointerDown={stopPropagationOnPointerDown}
457	event.stopPropagation();	633	onClick={handleConfirmArchiveClick}
458	}}
459	onClick={(event) => {
460	event.preventDefault();
461	event.stopPropagation();
462	props.setConfirmingArchiveThreadId((current) =>
463	current === thread.id ? null : current,
464	);
465	void props.attemptArchiveThread(thread.id);
466	}}
467	>	634	>
468	Confirm	635	Confirm
469	</button>	636	</button>
470	) : !isThreadRunning ? (	637	) : !isThreadRunning ? (
471	props.appSettingsConfirmThreadArchive ? (	638	appSettingsConfirmThreadArchive ? (
472	<div className="pointer-events-none absolute top-1/2 right-1 -translate-y-1/2 opacity-0 transition-opacity duration-150 group-hover/menu-sub-item:pointer-events-auto group-hover/menu-sub-item:opacity-100 group-focus-within/menu-sub-item:pointer-events-auto group-focus-within/menu-sub-item:opacity-100">	639	<div className="pointer-events-none absolute top-1/2 right-1 -translate-y-1/2 opacity-0 transition-opacity duration-150 group-hover/menu-sub-item:pointer-events-auto group-hover/menu-sub-item:opacity-100 group-focus-within/menu-sub-item:pointer-events-auto group-focus-within/menu-sub-item:opacity-100">
473	<button	640	<button
474	type="button"	641	type="button"
@@ -476,17 +643,8 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 1 unmodified line
476	data-testid={`thread-archive-${thread.id}`}	643	data-testid={`thread-archive-${thread.id}`}
477	aria-label={`Archive ${thread.title}`}	644	aria-label={`Archive ${thread.title}`}
478	className="inline-flex size-5 cursor-pointer items-center justify-center text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-ring"	645	className="inline-flex size-5 cursor-pointer items-center justify-center text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-ring"
479	onPointerDown={(event) => {	646	onPointerDown={stopPropagationOnPointerDown}
480	event.stopPropagation();	647	onClick={handleStartArchiveConfirmation}
481	}}
482	onClick={(event) => {
483	event.preventDefault();
484	event.stopPropagation();
485	props.setConfirmingArchiveThreadId(thread.id);
486	requestAnimationFrame(() => {
487	props.confirmArchiveButtonRefs.current.get(thread.id)?.focus();
488	});
489	}}
490	>	648	>
491	<ArchiveIcon className="size-3.5" />	649	<ArchiveIcon className="size-3.5" />
492	</button>	650	</button>
@@ -502,14 +660,8 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 9 unmodified lines
502	data-testid={`thread-archive-${thread.id}`}	660	data-testid={`thread-archive-${thread.id}`}
503	aria-label={`Archive ${thread.title}`}	661	aria-label={`Archive ${thread.title}`}
504	className="inline-flex size-5 cursor-pointer items-center justify-center text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-ring"	662	className="inline-flex size-5 cursor-pointer items-center justify-center text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-ring"
505	onPointerDown={(event) => {	663	onPointerDown={stopPropagationOnPointerDown}
506	event.stopPropagation();	664	onClick={handleArchiveImmediateClick}
507	}}
508	onClick={(event) => {
509	event.preventDefault();
510	event.stopPropagation();
511	void props.attemptArchiveThread(thread.id);
512	}}
513	>	665	>
514	<ArchiveIcon className="size-3.5" />	666	<ArchiveIcon className="size-3.5" />
515	</button>	667	</button>
@@ -521,12 +673,12 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 5 unmodified lines
521	)	673	)
522	) : null}	674	) : null}
523	<span className={threadMetaClassName}>	675	<span className={threadMetaClassName}>
524	{props.showThreadJumpHints && props.jumpLabel ? (	676	{jumpLabel ? (
525	<span	677	<span
526	className="inline-flex h-5 items-center rounded-full border border-border/80 bg-background/90 px-1.5 font-mono text-[10px] font-medium tracking-tight text-foreground shadow-sm"	678	className="inline-flex h-5 items-center rounded-full border border-border/80 bg-background/90 px-1.5 font-mono text-[10px] font-medium tracking-tight text-foreground shadow-sm"
527	title={props.jumpLabel}	679	title={jumpLabel}
528	>	680	>
529	{props.jumpLabel}	681	{jumpLabel}
530	</span>	682	</span>
531	) : (	683	) : (
532	<span	684	<span
@@ -545,248 +697,288 @@ function SidebarThreadRow(props: SidebarThreadRowProps) { · 12 unmodified lines
545	</SidebarMenuSubButton>	697	</SidebarMenuSubButton>
546	</SidebarMenuSubItem>	698	</SidebarMenuSubItem>
547	);	699	);
		700	});
		701
		702	interface SidebarProjectThreadListProps {
		703	projectKey: string;
		704	projectExpanded: boolean;
		705	hasOverflowingThreads: boolean;
		706	hiddenThreadStatus: ThreadStatusPill \| null;
		707	orderedProjectThreadKeys: readonly string[];
		708	renderedThreads: readonly SidebarThreadSummary[];
		709	showEmptyThreadState: boolean;
		710	shouldShowThreadPanel: boolean;
		711	isThreadListExpanded: boolean;
		712	projectCwd: string;
		713	activeRouteThreadKey: string \| null;
		714	threadJumpLabelByKey: ReadonlyMap<string, string>;
		715	appSettingsConfirmThreadArchive: boolean;
		716	renamingThreadKey: string \| null;
		717	renamingTitle: string;
		718	setRenamingTitle: (title: string) => void;
		719	renamingInputRef: React.RefObject<HTMLInputElement \| null>;
		720	renamingCommittedRef: React.RefObject<boolean>;
		721	confirmingArchiveThreadKey: string \| null;
		722	setConfirmingArchiveThreadKey: React.Dispatch<React.SetStateAction<string \| null>>;
		723	confirmArchiveButtonRefs: React.RefObject<Map<string, HTMLButtonElement>>;
		724	attachThreadListAutoAnimateRef: (node: HTMLElement \| null) => void;
		725	handleThreadClick: (
		726	event: React.MouseEvent,
		727	threadRef: ScopedThreadRef,
		728	orderedProjectThreadKeys: readonly string[],
		729	) => void;
		730	navigateToThread: (threadRef: ScopedThreadRef) => void;
		731	handleMultiSelectContextMenu: (position: { x: number; y: number }) => Promise<void>;
		732	handleThreadContextMenu: (
		733	threadRef: ScopedThreadRef,
		734	position: { x: number; y: number },
		735	) => Promise<void>;
		736	clearSelection: () => void;
		737	commitRename: (
		738	threadRef: ScopedThreadRef,
		739	newTitle: string,
		740	originalTitle: string,
		741	) => Promise<void>;
		742	cancelRename: () => void;
		743	attemptArchiveThread: (threadRef: ScopedThreadRef) => Promise<void>;
		744	openPrLink: (event: React.MouseEvent<HTMLElement>, prUrl: string) => void;
		745	expandThreadListForProject: (projectKey: string) => void;
		746	collapseThreadListForProject: (projectKey: string) => void;
548	}	747	}
549		748
550	function T3Wordmark() {	749	const SidebarProjectThreadList = memo(function SidebarProjectThreadList(
551	return (	750	props: SidebarProjectThreadListProps,
552	<svg	751	) {
553	aria-label="T3"	752	const {
554	className="h-2.5 w-auto shrink-0 text-foreground"	753	projectKey,
555	viewBox="15.5309 37 94.3941 56.96"	754	projectExpanded,
556	xmlns="http://www.w3.org/2000/svg"	755	hasOverflowingThreads,
557	>	756	hiddenThreadStatus,
558	<path	757	orderedProjectThreadKeys,
559	d="M33.4509 93V47.56H15.5309V37H64.3309V47.56H46.4109V93H33.4509ZM86.7253 93.96C82.832 93.96 78.9653 93.4533 75.1253 92.44C71.2853 91.3733 68.032 89.88 65.3653 87.96L70.4053 78.04C72.5386 79.5867 75.0186 80.8133 77.8453 81.72C80.672 82.6267 83.5253 83.08 86.4053 83.08C89.6586 83.08 92.2186 82.44 94.0853 81.16C95.952 79.88 96.8853 78.12 96.8853 75.88C96.8853 73.7467 96.0586 72.0667 94.4053 70.84C92.752 69.6133 90.0853 69 86.4053 69H80.4853V60.44L96.0853 42.76L97.5253 47.4H68.1653V37H107.365V45.4L91.8453 63.08L85.2853 59.32H89.0453C95.9253 59.32 101.125 60.8667 104.645 63.96C108.165 67.0533 109.925 71.0267 109.925 75.88C109.925 79.0267 109.099 81.9867 107.445 84.76C105.792 87.48 103.259 89.6933 99.8453 91.4C96.432 93.1067 92.0586 93.96 86.7253 93.96Z"	758	renderedThreads,
560	fill="currentColor"	759	showEmptyThreadState,
561	/>	760	shouldShowThreadPanel,
562	</svg>	761	isThreadListExpanded,
563	);	762	projectCwd,
564	}	763	activeRouteThreadKey,
565		764	threadJumpLabelByKey,
566	type SortableProjectHandleProps = Pick<	765	appSettingsConfirmThreadArchive,
567	ReturnType<typeof useSortable>,	766	renamingThreadKey,
568	"attributes" \| "listeners" \| "setActivatorNodeRef"	767	renamingTitle,
569	>;	768	setRenamingTitle,
		769	renamingInputRef,
		770	renamingCommittedRef,
		771	confirmingArchiveThreadKey,
		772	setConfirmingArchiveThreadKey,
		773	confirmArchiveButtonRefs,
		774	attachThreadListAutoAnimateRef,
		775	handleThreadClick,
		776	navigateToThread,
		777	handleMultiSelectContextMenu,
		778	handleThreadContextMenu,
		779	clearSelection,
		780	commitRename,
		781	cancelRename,
		782	attemptArchiveThread,
		783	openPrLink,
		784	expandThreadListForProject,
		785	collapseThreadListForProject,
		786	} = props;
		787	const showMoreButtonRender = useMemo(() => <button type="button" />, []);
		788	const showLessButtonRender = useMemo(() => <button type="button" />, []);
570		789
571	function ProjectSortMenu({
572	projectSortOrder,
573	threadSortOrder,
574	onProjectSortOrderChange,
575	onThreadSortOrderChange,
576	}: {
577	projectSortOrder: SidebarProjectSortOrder;
578	threadSortOrder: SidebarThreadSortOrder;
579	onProjectSortOrderChange: (sortOrder: SidebarProjectSortOrder) => void;
580	onThreadSortOrderChange: (sortOrder: SidebarThreadSortOrder) => void;
581	}) {
582	return (	790	return (
583	<Menu>	791	<SidebarMenuSub
584	<Tooltip>	792	ref={attachThreadListAutoAnimateRef}
585	<TooltipTrigger	793	className="mx-1 my-0 w-full translate-x-0 gap-0.5 overflow-hidden px-1.5 py-0"
586	render={	794	>
587	<MenuTrigger className="inline-flex size-5 cursor-pointer items-center justify-center rounded-md text-muted-foreground/60 transition-colors hover:bg-accent hover:text-foreground" />	795	{shouldShowThreadPanel && showEmptyThreadState ? (
588	}	796	<SidebarMenuSubItem className="w-full" data-thread-selection-safe>
589	>	797	<div
590	<ArrowUpDownIcon className="size-3.5" />	798	data-thread-selection-safe
591	</TooltipTrigger>	799	className="flex h-6 w-full translate-x-0 items-center px-2 text-left text-[10px] text-muted-foreground/60"
592	<TooltipPopup side="right">Sort projects</TooltipPopup>	800	>
593	</Tooltip>	801	<span>No threads yet</span>
594	<MenuPopup align="end" side="bottom" className="min-w-44">
595	<MenuGroup>
596	<div className="px-2 py-1 sm:text-xs font-medium text-muted-foreground">
597	Sort projects
598	</div>	802	</div>
599	<MenuRadioGroup	803	</SidebarMenuSubItem>
600	value={projectSortOrder}	804	) : null}
601	onValueChange={(value) => {	805	{shouldShowThreadPanel &&
602	onProjectSortOrderChange(value as SidebarProjectSortOrder);	806	renderedThreads.map((thread) => {
		807	const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id));
		808	return (
		809	<SidebarThreadRow
		810	key={threadKey}
		811	thread={thread}
		812	projectCwd={projectCwd}
		813	orderedProjectThreadKeys={orderedProjectThreadKeys}
		814	isActive={activeRouteThreadKey === threadKey}
		815	jumpLabel={threadJumpLabelByKey.get(threadKey) ?? null}
		816	appSettingsConfirmThreadArchive={appSettingsConfirmThreadArchive}
		817	renamingThreadKey={renamingThreadKey}
		818	renamingTitle={renamingTitle}
		819	setRenamingTitle={setRenamingTitle}
		820	renamingInputRef={renamingInputRef}
		821	renamingCommittedRef={renamingCommittedRef}
		822	confirmingArchiveThreadKey={confirmingArchiveThreadKey}
		823	setConfirmingArchiveThreadKey={setConfirmingArchiveThreadKey}
		824	confirmArchiveButtonRefs={confirmArchiveButtonRefs}
		825	handleThreadClick={handleThreadClick}
		826	navigateToThread={navigateToThread}
		827	handleMultiSelectContextMenu={handleMultiSelectContextMenu}
		828	handleThreadContextMenu={handleThreadContextMenu}
		829	clearSelection={clearSelection}
		830	commitRename={commitRename}
		831	cancelRename={cancelRename}
		832	attemptArchiveThread={attemptArchiveThread}
		833	openPrLink={openPrLink}
		834	/>
		835	);
		836	})}
		837
		838	{projectExpanded && hasOverflowingThreads && !isThreadListExpanded && (
		839	<SidebarMenuSubItem className="w-full">
		840	<SidebarMenuSubButton
		841	render={showMoreButtonRender}
		842	data-thread-selection-safe
		843	size="sm"
		844	className="h-6 w-full translate-x-0 justify-start px-2 text-left text-[10px] text-muted-foreground/60 hover:bg-accent hover:text-muted-foreground/80"
		845	onClick={() => {
		846	expandThreadListForProject(projectKey);
603	}}	847	}}
604	>	848	>
605	{(Object.entries(SIDEBAR_SORT_LABELS) as Array<[SidebarProjectSortOrder, string]>).map(	849	<span className="flex min-w-0 flex-1 items-center gap-2">
606	([value, label]) => (	850	{hiddenThreadStatus && <ThreadStatusLabel status={hiddenThreadStatus} compact />}
607	<MenuRadioItem key={value} value={value} className="min-h-7 py-1 sm:text-xs">	851	<span>Show more</span>
608	{label}	852	</span>
609	</MenuRadioItem>	853	</SidebarMenuSubButton>
610	),	854	</SidebarMenuSubItem>
611	)}	855	)}
612	</MenuRadioGroup>	856	{projectExpanded && hasOverflowingThreads && isThreadListExpanded && (
613	</MenuGroup>	857	<SidebarMenuSubItem className="w-full">
614	<MenuGroup>	858	<SidebarMenuSubButton
615	<div className="px-2 pt-2 pb-1 sm:text-xs font-medium text-muted-foreground">	859	render={showLessButtonRender}
616	Sort threads	860	data-thread-selection-safe
617	</div>	861	size="sm"
618	<MenuRadioGroup	862	className="h-6 w-full translate-x-0 justify-start px-2 text-left text-[10px] text-muted-foreground/60 hover:bg-accent hover:text-muted-foreground/80"
619	value={threadSortOrder}	863	onClick={() => {
620	onValueChange={(value) => {	864	collapseThreadListForProject(projectKey);
621	onThreadSortOrderChange(value as SidebarThreadSortOrder);
622	}}	865	}}
623	>	866	>
624	{(	867	<span>Show less</span>
625	Object.entries(SIDEBAR_THREAD_SORT_LABELS) as Array<[SidebarThreadSortOrder, string]>	868	</SidebarMenuSubButton>
626	).map(([value, label]) => (	869	</SidebarMenuSubItem>
627	<MenuRadioItem key={value} value={value} className="min-h-7 py-1 sm:text-xs">	870	)}
628	{label}	871	</SidebarMenuSub>
629	</MenuRadioItem>
630	))}
631	</MenuRadioGroup>
632	</MenuGroup>
633	</MenuPopup>
634	</Menu>
635	);	872	);
		873	});
		874
		875	interface SidebarProjectItemProps {
		876	project: SidebarProjectSnapshot;
		877	isThreadListExpanded: boolean;
		878	activeRouteThreadKey: string \| null;
		879	newThreadShortcutLabel: string \| null;
		880	handleNewThread: ReturnType<typeof useHandleNewThread>["handleNewThread"];
		881	archiveThread: ReturnType<typeof useThreadActions>["archiveThread"];
		882	deleteThread: ReturnType<typeof useThreadActions>["deleteThread"];
		883	threadJumpLabelByKey: ReadonlyMap<string, string>;
		884	attachThreadListAutoAnimateRef: (node: HTMLElement \| null) => void;
		885	expandThreadListForProject: (projectKey: string) => void;
		886	collapseThreadListForProject: (projectKey: string) => void;
		887	dragInProgressRef: React.RefObject<boolean>;
		888	suppressProjectClickAfterDragRef: React.RefObject<boolean>;
		889	suppressProjectClickForContextMenuRef: React.RefObject<boolean>;
		890	isManualProjectSorting: boolean;
		891	dragHandleProps: SortableProjectHandleProps \| null;
636	}	892	}
637		893
638	function SortableProjectItem({	894	const SidebarProjectItem = memo(function SidebarProjectItem(props: SidebarProjectItemProps) {
639	projectId,
640	disabled = false,
641	children,
642	}: {
643	projectId: ProjectId;
644	disabled?: boolean;
645	children: (handleProps: SortableProjectHandleProps) => ReactNode;
646	}) {
647	const {	895	const {
648	attributes,	896	project,
649	listeners,	897	isThreadListExpanded,
650	setActivatorNodeRef,	898	activeRouteThreadKey,
651	setNodeRef,	899	newThreadShortcutLabel,
652	transform,	900	handleNewThread,
653	transition,	901	archiveThread,
654	isDragging,	902	deleteThread,
655	isOver,	903	threadJumpLabelByKey,
656	} = useSortable({ id: projectId, disabled });	904	attachThreadListAutoAnimateRef,
657	return (	905	expandThreadListForProject,
658	<li	906	collapseThreadListForProject,
659	ref={setNodeRef}	907	dragInProgressRef,
660	style={{	908	suppressProjectClickAfterDragRef,
661	transform: CSS.Translate.toString(transform),	909	suppressProjectClickForContextMenuRef,
662	transition,	910	isManualProjectSorting,
663	}}	911	dragHandleProps,
664	className={`group/menu-item relative rounded-md ${	912	} = props;
665	isDragging ? "z-20 opacity-80" : ""	913	const threadSortOrder = useSettings<SidebarThreadSortOrder>(
666	} ${isOver && !isDragging ? "ring-1 ring-primary/40" : ""}`}	914	(settings) => settings.sidebarThreadSortOrder,
667	data-sidebar="menu-item"
668	data-slot="sidebar-menu-item"
669	>
670	{children({ attributes, listeners, setActivatorNodeRef })}
671	</li>
672	);	915	);
673	}	916	const appSettingsConfirmThreadDelete = useSettings<boolean>(
674		917	(settings) => settings.confirmThreadDelete,
675	export default function Sidebar() {	918	);
676	const projectIds = useStore((store) => store.projectIds);	919	const appSettingsConfirmThreadArchive = useSettings<boolean>(
677	const projectById = useStore((store) => store.projectById);	920	(settings) => settings.confirmThreadArchive,
678	const sidebarThreadsById = useStore((store) => store.sidebarThreadSummaryById);	921	);
679	const threadIdsByProjectId = useStore((store) => store.threadIdsByProjectId);	922	const defaultThreadEnvMode = useSettings<ThreadEnvMode>(
680	const { projectExpandedById, projectOrder, threadLastVisitedAtById } = useUiStateStore(	923	(settings) => settings.defaultThreadEnvMode,
681	useShallow((store) => ({	924	);
682	projectExpandedById: store.projectExpandedById,	925	const router = useRouter();
683	projectOrder: store.projectOrder,	926	const markThreadUnread = useUiStateStore((state) => state.markThreadUnread);
684	threadLastVisitedAtById: store.threadLastVisitedAtById,	927	const toggleProject = useUiStateStore((state) => state.toggleProject);
685	})),	928	const toggleThreadSelection = useThreadSelectionStore((state) => state.toggleThread);
686	);	929	const rangeSelectTo = useThreadSelectionStore((state) => state.rangeSelectTo);
687	const markThreadUnread = useUiStateStore((store) => store.markThreadUnread);	930	const clearSelection = useThreadSelectionStore((state) => state.clearSelection);
688	const toggleProject = useUiStateStore((store) => store.toggleProject);	931	const removeFromSelection = useThreadSelectionStore((state) => state.removeFromSelection);
689	const reorderProjects = useUiStateStore((store) => store.reorderProjects);	932	const setSelectionAnchor = useThreadSelectionStore((state) => state.setAnchor);
690	const clearComposerDraftForThread = useComposerDraftStore((store) => store.clearDraftThread);	933	const selectedThreadCount = useThreadSelectionStore((state) => state.selectedThreadKeys.size);
691	const getDraftThreadByProjectId = useComposerDraftStore(	934	const clearComposerDraftForThread = useComposerDraftStore((state) => state.clearDraftThread);
692	(store) => store.getDraftThreadByProjectId,	935	const getDraftThreadByProjectRef = useComposerDraftStore(
		936	(state) => state.getDraftThreadByProjectRef,
693	);	937	);
694	const terminalStateByThreadId = useTerminalStateStore((state) => state.terminalStateByThreadId);
695	const clearProjectDraftThreadId = useComposerDraftStore(	938	const clearProjectDraftThreadId = useComposerDraftStore(
696	(store) => store.clearProjectDraftThreadId,	939	(state) => state.clearProjectDraftThreadId,
697	);	940	);
698	const navigate = useNavigate();	941	const { copyToClipboard: copyThreadIdToClipboard } = useCopyToClipboard<{
699	const pathname = useLocation({ select: (loc) => loc.pathname });	942	threadId: ThreadId;
700	const isOnSettings = pathname.startsWith("/settings");	943	}>({
701	const appSettings = useSettings();	944	onCopy: (ctx) => {
702	const { updateSettings } = useUpdateSettings();	945	toastManager.add({
703	const { activeDraftThread, activeThread, handleNewThread } = useHandleNewThread();	946	type: "success",
704	const { archiveThread, deleteThread } = useThreadActions();	947	title: "Thread ID copied",
705	const routeThreadId = useParams({	948	description: ctx.threadId,
706	strict: false,	949	});
707	select: (params) => (params.threadId ? ThreadId.makeUnsafe(params.threadId) : null),	950	},
		951	onError: (error) => {
		952	toastManager.add({
		953	type: "error",
		954	title: "Failed to copy thread ID",
		955	description: error instanceof Error ? error.message : "An error occurred.",
		956	});
		957	},
708	});	958	});
709	const keybindings = useServerKeybindings();	959	const { copyToClipboard: copyPathToClipboard } = useCopyToClipboard<{
710	const [addingProject, setAddingProject] = useState(false);	960	path: string;
711	const [newCwd, setNewCwd] = useState("");	961	}>({
712	const [isPickingFolder, setIsPickingFolder] = useState(false);	962	onCopy: (ctx) => {
713	const [isAddingProject, setIsAddingProject] = useState(false);	963	toastManager.add({
714	const [addProjectError, setAddProjectError] = useState<string \| null>(null);	964	type: "success",
715	const addProjectInputRef = useRef<HTMLInputElement \| null>(null);	965	title: "Path copied",
716	const [renamingProjectId, setRenamingProjectId] = useState<ProjectId \| null>(null);	966	description: ctx.path,
717	const [renamingProjectTitle, setRenamingProjectTitle] = useState("");	967	});
718	const [renamingThreadId, setRenamingThreadId] = useState<ThreadId \| null>(null);	968	},
719	const [renamingTitle, setRenamingTitle] = useState("");	969	onError: (error) => {
720	const [confirmingArchiveThreadId, setConfirmingArchiveThreadId] = useState<ThreadId \| null>(null);	970	toastManager.add({
721	const [expandedThreadListsByProject, setExpandedThreadListsByProject] = useState<	971	type: "error",
722	ReadonlySet<ProjectId>	972	title: "Failed to copy path",
723	>(() => new Set());	973	description: error instanceof Error ? error.message : "An error occurred.",
724	const { showThreadJumpHints, updateThreadJumpHintsVisibility } = useThreadJumpHintVisibility();	974	});
725	const projectRenamingCommittedRef = useRef(false);	975	},
726	const projectRenamingInputRef = useRef<HTMLInputElement \| null>(null);	976	});
727	const renamingCommittedRef = useRef(false);	977	const openPrLink = useCallback((event: React.MouseEvent<HTMLElement>, prUrl: string) => {
728	const renamingInputRef = useRef<HTMLInputElement \| null>(null);
729	const confirmArchiveButtonRefs = useRef(new Map<ThreadId, HTMLButtonElement>());
730	const dragInProgressRef = useRef(false);
731	const suppressProjectClickAfterDragRef = useRef(false);
732	const suppressProjectClickForContextMenuRef = useRef(false);
733	const [desktopUpdateState, setDesktopUpdateState] = useState<DesktopUpdateState \| null>(null);
734	const selectedThreadIds = useThreadSelectionStore((s) => s.selectedThreadIds);
735	const toggleThreadSelection = useThreadSelectionStore((s) => s.toggleThread);
736	const rangeSelectTo = useThreadSelectionStore((s) => s.rangeSelectTo);
737	const clearSelection = useThreadSelectionStore((s) => s.clearSelection);
738	const removeFromSelection = useThreadSelectionStore((s) => s.removeFromSelection);
739	const setSelectionAnchor = useThreadSelectionStore((s) => s.setAnchor);
740	const isLinuxDesktop = isElectron && isLinuxPlatform(navigator.platform);
741	const platform = navigator.platform;
742	const shouldBrowseForProjectImmediately = isElectron && !isLinuxDesktop;
743	const shouldShowProjectPathEntry = addingProject && !shouldBrowseForProjectImmediately;
744	const projects = useMemo(
745	() =>
746	projectIds.flatMap((projectId) => {
747	const project = projectById[projectId];
748	return project ? [project] : [];
749	}),
750	[projectById, projectIds],
751	);
752	const orderedProjects = useMemo(() => {
753	return orderItemsByPreferredIds({
754	items: projects,
755	preferredIds: projectOrder,
756	getId: (project) => project.id,
757	});
758	}, [projectOrder, projects]);
759	const sidebarProjects = useMemo<SidebarProjectSnapshot[]>(
760	() =>
761	orderedProjects.map((project) => ({
762	...project,
763	expanded: projectExpandedById[project.id] ?? true,
764	})),
765	[orderedProjects, projectExpandedById],
766	);
767	const sidebarThreads = useMemo(() => Object.values(sidebarThreadsById), [sidebarThreadsById]);
768	const projectCwdById = useMemo(
769	() => new Map(projects.map((project) => [project.id, project.cwd] as const)),
770	[projects],
771	);
772	const routeTerminalOpen = routeThreadId
773	? selectThreadTerminalState(terminalStateByThreadId, routeThreadId).terminalOpen
774	: false;
775	const sidebarShortcutLabelOptions = useMemo(
776	() => ({
777	platform,
778	context: {
779	terminalFocus: false,
780	terminalOpen: routeTerminalOpen,
781	},
782	}),
783	[platform, routeTerminalOpen],
784	);
785	const openPrLink = useCallback((event: MouseEvent<HTMLElement>, prUrl: string) => {
786	event.preventDefault();	978	event.preventDefault();
787	event.stopPropagation();	979	event.stopPropagation();
788		980
789	const api = readNativeApi();	981	const api = readLocalApi();
790	if (!api) {	982	if (!api) {
791	toastManager.add({	983	toastManager.add({
792	type: "error",	984	type: "error",
@@ -803,222 +995,495 @@ export default function Sidebar() { · 10 unmodified lines
803	});	995	});
804	});	996	});
805	}, []);	997	}, []);
		998	const sidebarThreads = useStore(
		999	useShallow(
		1000	useMemo(
		1001	() => (state) =>
		1002	selectSidebarThreadsForProjectRef(
		1003	state,
		1004	scopeProjectRef(project.environmentId, project.id),
		1005	),
		1006	[project.environmentId, project.id],
		1007	),
		1008	),
		1009	);
		1010	const sidebarThreadByKey = useMemo(
		1011	() =>
		1012	new Map(
		1013	sidebarThreads.map(
		1014	(thread) =>
		1015	[scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)), thread] as const,
		1016	),
		1017	),
		1018	[sidebarThreads],
		1019	);
		1020	const projectThreads = useMemo(
		1021	() =>
		1022	sidebarThreads.filter(
		1023	(thread) =>
		1024	scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId)) ===
		1025	project.projectKey,
		1026	),
		1027	[project.projectKey, sidebarThreads],
		1028	);
		1029	const projectExpanded = useUiStateStore(
		1030	(state) => state.projectExpandedById[project.projectKey] ?? true,
		1031	);
		1032	const threadLastVisitedAts = useUiStateStore(
		1033	useShallow((state) =>
		1034	projectThreads.map(
		1035	(thread) =>
		1036	state.threadLastVisitedAtById[
		1037	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id))
		1038	] ?? null,
		1039	),
		1040	),
		1041	);
		1042	const [renamingThreadKey, setRenamingThreadKey] = useState<string \| null>(null);
		1043	const [renamingTitle, setRenamingTitle] = useState("");
		1044	const [confirmingArchiveThreadKey, setConfirmingArchiveThreadKey] = useState<string \| null>(null);
		1045	const renamingCommittedRef = useRef(false);
		1046	const renamingInputRef = useRef<HTMLInputElement \| null>(null);
		1047	const confirmArchiveButtonRefs = useRef(new Map<string, HTMLButtonElement>());
		1048
		1049	const { projectStatus, visibleProjectThreads, orderedProjectThreadKeys } = useMemo(() => {
		1050	const lastVisitedAtByThreadKey = new Map(
		1051	projectThreads.map((thread, index) => [
		1052	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
		1053	threadLastVisitedAts[index] ?? null,
		1054	]),
		1055	);
		1056	const resolveProjectThreadStatus = (thread: SidebarThreadSummary) => {
		1057	const lastVisitedAt = lastVisitedAtByThreadKey.get(
		1058	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
		1059	);
		1060	return resolveThreadStatusPill({
		1061	thread: {
		1062	...thread,
		1063	...(lastVisitedAt !== null && lastVisitedAt !== undefined ? { lastVisitedAt } : {}),
		1064	},
		1065	});
		1066	};
		1067	const visibleProjectThreads = sortThreadsForSidebar(
		1068	projectThreads.filter((thread) => thread.archivedAt === null),
		1069	threadSortOrder,
		1070	);
		1071	const projectStatus = resolveProjectStatusIndicator(
		1072	visibleProjectThreads.map((thread) => resolveProjectThreadStatus(thread)),
		1073	);
		1074	return {
		1075	orderedProjectThreadKeys: visibleProjectThreads.map((thread) =>
		1076	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
		1077	),
		1078	projectStatus,
		1079	visibleProjectThreads,
		1080	};
		1081	}, [projectThreads, threadLastVisitedAts, threadSortOrder]);
806		1082
807	const attemptArchiveThread = useCallback(	1083	const pinnedCollapsedThread = useMemo(() => {
808	async (threadId: ThreadId) => {	1084	const activeThreadKey = activeRouteThreadKey ?? undefined;
809	try {	1085	if (!activeThreadKey \|\| projectExpanded) {
810	await archiveThread(threadId);	1086	return null;
811	} catch (error) {	1087	}
812	toastManager.add({	1088	return (
813	type: "error",	1089	visibleProjectThreads.find(
814	title: "Failed to archive thread",	1090	(thread) =>
815	description: error instanceof Error ? error.message : "An error occurred.",	1091	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)) === activeThreadKey,
816	});	1092	) ?? null
		1093	);
		1094	}, [activeRouteThreadKey, projectExpanded, visibleProjectThreads]);
		1095
		1096	const {
		1097	hasOverflowingThreads,
		1098	hiddenThreadStatus,
		1099	renderedThreads,
		1100	showEmptyThreadState,
		1101	shouldShowThreadPanel,
		1102	} = useMemo(() => {
		1103	const lastVisitedAtByThreadKey = new Map(
		1104	projectThreads.map((thread, index) => [
		1105	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
		1106	threadLastVisitedAts[index] ?? null,
		1107	]),
		1108	);
		1109	const resolveProjectThreadStatus = (thread: SidebarThreadSummary) => {
		1110	const lastVisitedAt = lastVisitedAtByThreadKey.get(
		1111	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
		1112	);
		1113	return resolveThreadStatusPill({
		1114	thread: {
		1115	...thread,
		1116	...(lastVisitedAt !== null && lastVisitedAt !== undefined ? { lastVisitedAt } : {}),
		1117	},
		1118	});
		1119	};
		1120	const hasOverflowingThreads = visibleProjectThreads.length > THREAD_PREVIEW_LIMIT;
		1121	const previewThreads =
		1122	isThreadListExpanded \|\| !hasOverflowingThreads
		1123	? visibleProjectThreads
		1124	: visibleProjectThreads.slice(0, THREAD_PREVIEW_LIMIT);
		1125	const visibleThreadKeys = new Set(
		1126	[...previewThreads, ...(pinnedCollapsedThread ? [pinnedCollapsedThread] : [])].map((thread) =>
		1127	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
		1128	),
		1129	);
		1130	const renderedThreads = pinnedCollapsedThread
		1131	? [pinnedCollapsedThread]
		1132	: visibleProjectThreads.filter((thread) =>
		1133	visibleThreadKeys.has(scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id))),
		1134	);
		1135	const hiddenThreads = visibleProjectThreads.filter(
		1136	(thread) =>
		1137	!visibleThreadKeys.has(scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id))),
		1138	);
		1139	return {
		1140	hasOverflowingThreads,
		1141	hiddenThreadStatus: resolveProjectStatusIndicator(
		1142	hiddenThreads.map((thread) => resolveProjectThreadStatus(thread)),
		1143	),
		1144	renderedThreads,
		1145	showEmptyThreadState: projectExpanded && visibleProjectThreads.length === 0,
		1146	shouldShowThreadPanel: projectExpanded \|\| pinnedCollapsedThread !== null,
		1147	};
		1148	}, [
		1149	isThreadListExpanded,
		1150	pinnedCollapsedThread,
		1151	projectExpanded,
		1152	projectThreads,
		1153	threadLastVisitedAts,
		1154	visibleProjectThreads,
		1155	]);
		1156
		1157	const handleProjectButtonClick = useCallback(
		1158	(event: React.MouseEvent<HTMLButtonElement>) => {
		1159	if (suppressProjectClickForContextMenuRef.current) {
		1160	suppressProjectClickForContextMenuRef.current = false;
		1161	event.preventDefault();
		1162	event.stopPropagation();
		1163	return;
		1164	}
		1165	if (dragInProgressRef.current) {
		1166	event.preventDefault();
		1167	event.stopPropagation();
		1168	return;
		1169	}
		1170	if (suppressProjectClickAfterDragRef.current) {
		1171	suppressProjectClickAfterDragRef.current = false;
		1172	event.preventDefault();
		1173	event.stopPropagation();
		1174	return;
		1175	}
		1176	if (selectedThreadCount > 0) {
		1177	clearSelection();
817	}	1178	}
		1179	toggleProject(project.projectKey);
818	},	1180	},
819	[archiveThread],	1181	[
		1182	clearSelection,
		1183	dragInProgressRef,
		1184	project.projectKey,
		1185	selectedThreadCount,
		1186	suppressProjectClickAfterDragRef,
		1187	suppressProjectClickForContextMenuRef,
		1188	toggleProject,
		1189	],
820	);	1190	);
821		1191
822	const focusMostRecentThreadForProject = useCallback(	1192	const handleProjectButtonKeyDown = useCallback(
823	(projectId: ProjectId) => {	1193	(event: React.KeyboardEvent<HTMLButtonElement>) => {
824	const latestThread = sortThreadsForSidebar(	1194	if (event.key !== "Enter" && event.key !== " ") return;
825	(threadIdsByProjectId[projectId] ?? [])	1195	event.preventDefault();
826	.map((threadId) => sidebarThreadsById[threadId])	1196	if (dragInProgressRef.current) {
827	.filter((thread): thread is NonNullable<typeof thread> => thread !== undefined)	1197	return;
828	.filter((thread) => thread.archivedAt === null),	1198	}
829	appSettings.sidebarThreadSortOrder,	1199	toggleProject(project.projectKey);
830	)[0];
831	if (!latestThread) return;
832
833	void navigate({
834	to: "/$threadId",
835	params: { threadId: latestThread.id },
836	});
837	},	1200	},
838	[appSettings.sidebarThreadSortOrder, navigate, sidebarThreadsById, threadIdsByProjectId],	1201	[dragInProgressRef, project.projectKey, toggleProject],
839	);	1202	);
840		1203
841	const addProjectFromPath = useCallback(	1204	const handleProjectButtonPointerDownCapture = useCallback(
842	async (rawCwd: string) => {	1205	(event: React.PointerEvent<HTMLButtonElement>) => {
843	const cwd = rawCwd.trim();	1206	suppressProjectClickForContextMenuRef.current = false;
844	if (!cwd \|\| isAddingProject) return;	1207	if (
845	const api = readNativeApi();	1208	isContextMenuPointerDown({
846	if (!api) return;	1209	button: event.button,
		1210	ctrlKey: event.ctrlKey,
		1211	isMac: isMacPlatform(navigator.platform),
		1212	})
		1213	) {
		1214	event.stopPropagation();
		1215	}
847		1216
848	setIsAddingProject(true);	1217	suppressProjectClickAfterDragRef.current = false;
849	const finishAddingProject = () => {	1218	},
850	setIsAddingProject(false);	1219	[suppressProjectClickAfterDragRef, suppressProjectClickForContextMenuRef],
851	setNewCwd("");	1220	);
852	setAddProjectError(null);
853	setAddingProject(false);
854	};
855		1221
856	const existing = projects.find((project) => project.cwd === cwd);	1222	const handleProjectButtonContextMenu = useCallback(
857	if (existing) {	1223	(event: React.MouseEvent<HTMLButtonElement>) => {
858	focusMostRecentThreadForProject(existing.id);	1224	event.preventDefault();
859	finishAddingProject();	1225	suppressProjectClickForContextMenuRef.current = true;
860	return;	1226	void (async () => {
861	}	1227	const api = readLocalApi();
		1228	if (!api) return;
862		1229
863	const projectId = newProjectId();	1230	const clicked = await api.contextMenu.show(
864	const createdAt = new Date().toISOString();	1231	[
865	const title = cwd.split(/[/\\]/).findLast(isNonEmptyString) ?? cwd;	1232	{ id: "copy-path", label: "Copy Project Path" },
866	try {	1233	{ id: "delete", label: "Remove project", destructive: true },
867	await api.orchestration.dispatchCommand({	1234	],
868	type: "project.create",	1235	{
869	commandId: newCommandId(),	1236	x: event.clientX,
870	projectId,	1237	y: event.clientY,
871	title,
872	workspaceRoot: cwd,
873	defaultModelSelection: {
874	provider: "codex",
875	model: DEFAULT_MODEL_BY_PROVIDER.codex,
876	},	1238	},
877	createdAt,	1239	);
878	});	1240	if (clicked === "copy-path") {
879	await handleNewThread(projectId, {	1241	copyPathToClipboard(project.cwd, { path: project.cwd });
880	envMode: appSettings.defaultThreadEnvMode,	1242	return;
881	}).catch(() => undefined);	1243	}
882	} catch (error) {	1244	if (clicked !== "delete") return;
883	const description =	1245
884	error instanceof Error ? error.message : "An error occurred while adding the project.";	1246	if (projectThreads.length > 0) {
885	setIsAddingProject(false);	1247	toastManager.add({
886	if (shouldBrowseForProjectImmediately) {	1248	type: "warning",
		1249	title: "Project is not empty",
		1250	description: "Delete all threads in this project before removing it.",
		1251	});
		1252	return;
		1253	}
		1254
		1255	const confirmed = await api.dialogs.confirm(`Remove project "${project.name}"?`);
		1256	if (!confirmed) return;
		1257
		1258	try {
		1259	const projectDraftThread = getDraftThreadByProjectRef(
		1260	scopeProjectRef(project.environmentId, project.id),
		1261	);
		1262	if (projectDraftThread) {
		1263	clearComposerDraftForThread(projectDraftThread.draftId);
		1264	}
		1265	clearProjectDraftThreadId(scopeProjectRef(project.environmentId, project.id));
		1266	const projectApi = readEnvironmentApi(project.environmentId);
		1267	if (!projectApi) {
		1268	throw new Error("Project API unavailable.");
		1269	}
		1270	await projectApi.orchestration.dispatchCommand({
		1271	type: "project.delete",
		1272	commandId: newCommandId(),
		1273	projectId: project.id,
		1274	});
		1275	} catch (error) {
		1276	const message =
		1277	error instanceof Error ? error.message : "Unknown error removing project.";
		1278	console.error("Failed to remove project", { projectId: project.id, error });
887	toastManager.add({	1279	toastManager.add({
888	type: "error",	1280	type: "error",
889	title: "Failed to add project",	1281	title: `Failed to remove "${project.name}"`,
890	description,	1282	description: message,
891	});	1283	});
892	} else {
893	setAddProjectError(description);
894	}	1284	}
895	return;	1285	})();
896	}
897	finishAddingProject();
898	},	1286	},
899	[	1287	[
900	focusMostRecentThreadForProject,	1288	clearComposerDraftForThread,
901	handleNewThread,	1289	clearProjectDraftThreadId,
902	isAddingProject,	1290	copyPathToClipboard,
903	projects,	1291	getDraftThreadByProjectRef,
904	shouldBrowseForProjectImmediately,	1292	project.cwd,
905	appSettings.defaultThreadEnvMode,	1293	project.environmentId,
		1294	project.id,
		1295	project.name,
		1296	projectThreads.length,
		1297	suppressProjectClickForContextMenuRef,
906	],	1298	],
907	);	1299	);
908		1300
909	const handleAddProject = () => {	1301	const navigateToThread = useCallback(
910	void addProjectFromPath(newCwd);	1302	(threadRef: ScopedThreadRef) => {
911	};	1303	if (useThreadSelectionStore.getState().selectedThreadKeys.size > 0) {
		1304	clearSelection();
		1305	}
		1306	setSelectionAnchor(scopedThreadKey(threadRef));
		1307	void router.navigate({
		1308	to: "/$environmentId/$threadId",
		1309	params: buildThreadRouteParams(threadRef),
		1310	});
		1311	},
		1312	[clearSelection, router, setSelectionAnchor],
		1313	);
912		1314
913	const canAddProject = newCwd.trim().length > 0 && !isAddingProject;	1315	const handleThreadClick = useCallback(
		1316	(
		1317	event: React.MouseEvent,
		1318	threadRef: ScopedThreadRef,
		1319	orderedProjectThreadKeys: readonly string[],
		1320	) => {
		1321	const isMac = isMacPlatform(navigator.platform);
		1322	const isModClick = isMac ? event.metaKey : event.ctrlKey;
		1323	const isShiftClick = event.shiftKey;
		1324	const threadKey = scopedThreadKey(threadRef);
		1325	const currentSelectionCount = useThreadSelectionStore.getState().selectedThreadKeys.size;
914		1326
915	const handlePickFolder = async () => {	1327	if (isModClick) {
916	const api = readNativeApi();	1328	event.preventDefault();
917	if (!api \|\| isPickingFolder) return;	1329	toggleThreadSelection(threadKey);
918	setIsPickingFolder(true);	1330	return;
919	let pickedPath: string \| null = null;	1331	}
920	try {
921	pickedPath = await api.dialogs.pickFolder();
922	} catch {
923	// Ignore picker failures and leave the current thread selection unchanged.
924	}
925	if (pickedPath) {
926	await addProjectFromPath(pickedPath);
927	} else if (!shouldBrowseForProjectImmediately) {
928	addProjectInputRef.current?.focus();
929	}
930	setIsPickingFolder(false);
931	};
932
933	const handleStartAddProject = () => {
934	setAddProjectError(null);
935	if (shouldBrowseForProjectImmediately) {
936	void handlePickFolder();
937	return;
938	}
939	setAddingProject((prev) => !prev);
940	};
941
942	const cancelRename = useCallback(() => {
943	setRenamingThreadId(null);
944	renamingInputRef.current = null;
945	}, []);
946		1332
947	const handleRenamingInputMount = useCallback((element: HTMLInputElement \| null) => {	1333	if (isShiftClick) {
948	if (element && renamingInputRef.current !== element) {	1334	event.preventDefault();
949	renamingInputRef.current = element;	1335	rangeSelectTo(threadKey, orderedProjectThreadKeys);
950	element.focus();	1336	return;
951	element.select();	1337	}
952	return;
953	}
954	if (element === null && renamingInputRef.current !== null) {
955	renamingInputRef.current = null;
956	}
957	}, []);
958		1338
959	const hasRenameCommitted = useCallback(() => renamingCommittedRef.current, []);	1339	if (currentSelectionCount > 0) {
960	const markRenameCommitted = useCallback(() => {	1340	clearSelection();
961	renamingCommittedRef.current = true;	1341	}
962	}, []);	1342	setSelectionAnchor(threadKey);
		1343	void router.navigate({
		1344	to: "/$environmentId/$threadId",
		1345	params: buildThreadRouteParams(threadRef),
		1346	});
		1347	},
		1348	[clearSelection, rangeSelectTo, router, setSelectionAnchor, toggleThreadSelection],
		1349	);
963		1350
964	const cancelProjectRename = useCallback(() => {	1351	const handleMultiSelectContextMenu = useCallback(
965	setRenamingProjectId(null);	1352	async (position: { x: number; y: number }) => {
966	projectRenamingInputRef.current = null;	1353	const api = readLocalApi();
967	}, []);	1354	if (!api) return;
		1355	const threadKeys = [...useThreadSelectionStore.getState().selectedThreadKeys];
		1356	if (threadKeys.length === 0) return;
		1357	const count = threadKeys.length;
968		1358
969	const commitRename = useCallback(	1359	const clicked = await api.contextMenu.show(
970	async (threadId: ThreadId, newTitle: string, originalTitle: string) => {	1360	[
971	const finishRename = () => {	1361	{ id: "mark-unread", label: `Mark unread (${count})` },
972	setRenamingThreadId((current) => {	1362	{ id: "delete", label: `Delete (${count})`, destructive: true },
973	if (current !== threadId) return current;	1363	],
974	renamingInputRef.current = null;	1364	position,
975	return null;	1365	);
976	});
977	};
978		1366
979	const trimmed = newTitle.trim();	1367	if (clicked === "mark-unread") {
980	if (trimmed.length === 0) {	1368	for (const threadKey of threadKeys) {
981	toastManager.add({	1369	const thread = sidebarThreadByKey.get(threadKey);
982	type: "warning",	1370	markThreadUnread(threadKey, thread?.latestTurn?.completedAt);
983	title: "Thread title cannot be empty",	1371	}
984	});	1372	clearSelection();
985	finishRename();
986	return;	1373	return;
987	}	1374	}
988	if (trimmed === originalTitle) {	1375
989	finishRename();	1376	if (clicked !== "delete") return;
990	return;	1377
		1378	if (appSettingsConfirmThreadDelete) {
		1379	const confirmed = await api.dialogs.confirm(
		1380	[
		1381	`Delete ${count} thread${count === 1 ? "" : "s"}?`,
		1382	"This permanently clears conversation history for these threads.",
		1383	].join("\n"),
		1384	);
		1385	if (!confirmed) return;
991	}	1386	}
992	const api = readNativeApi();	1387
993	if (!api) {	1388	const deletedThreadKeys = new Set(threadKeys);
994	finishRename();	1389	for (const threadKey of threadKeys) {
995	return;	1390	const thread = sidebarThreadByKey.get(threadKey);
		1391	if (!thread) continue;
		1392	await deleteThread(scopeThreadRef(thread.environmentId, thread.id), {
		1393	deletedThreadKeys,
		1394	});
996	}	1395	}
		1396	removeFromSelection(threadKeys);
		1397	},
		1398	[
		1399	appSettingsConfirmThreadDelete,
		1400	clearSelection,
		1401	deleteThread,
		1402	markThreadUnread,
		1403	removeFromSelection,
		1404	sidebarThreadByKey,
		1405	],
		1406	);
		1407
		1408	const handleCreateThreadClick = useCallback(
		1409	(event: React.MouseEvent<HTMLButtonElement>) => {
		1410	event.preventDefault();
		1411	event.stopPropagation();
		1412	const currentRouteParams =
		1413	router.state.matches[router.state.matches.length - 1]?.params ?? {};
		1414	const currentRouteTarget = resolveThreadRouteTarget(currentRouteParams);
		1415	const currentActiveThread =
		1416	currentRouteTarget?.kind === "server"
		1417	? (selectThreadByRef(useStore.getState(), currentRouteTarget.threadRef) ?? null)
		1418	: null;
		1419	const draftStore = useComposerDraftStore.getState();
		1420	const currentActiveDraftThread =
		1421	currentRouteTarget?.kind === "server"
		1422	? (draftStore.getDraftThread(currentRouteTarget.threadRef) ?? null)
		1423	: currentRouteTarget?.kind === "draft"
		1424	? (draftStore.getDraftSession(currentRouteTarget.draftId) ?? null)
		1425	: null;
		1426	const seedContext = resolveSidebarNewThreadSeedContext({
		1427	projectId: project.id,
		1428	defaultEnvMode: resolveSidebarNewThreadEnvMode({
		1429	defaultEnvMode: defaultThreadEnvMode,
		1430	}),
		1431	activeThread:
		1432	currentActiveThread && currentActiveThread.projectId === project.id
		1433	? {
		1434	projectId: currentActiveThread.projectId,
		1435	branch: currentActiveThread.branch,
		1436	worktreePath: currentActiveThread.worktreePath,
		1437	}
		1438	: null,
		1439	activeDraftThread:
		1440	currentActiveDraftThread && currentActiveDraftThread.projectId === project.id
		1441	? {
		1442	projectId: currentActiveDraftThread.projectId,
		1443	branch: currentActiveDraftThread.branch,
		1444	worktreePath: currentActiveDraftThread.worktreePath,
		1445	envMode: currentActiveDraftThread.envMode,
		1446	}
		1447	: null,
		1448	});
		1449	void handleNewThread(scopeProjectRef(project.environmentId, project.id), {
		1450	...(seedContext.branch !== undefined ? { branch: seedContext.branch } : {}),
		1451	...(seedContext.worktreePath !== undefined
		1452	? { worktreePath: seedContext.worktreePath }
		1453	: {}),
		1454	envMode: seedContext.envMode,
		1455	});
		1456	},
		1457	[defaultThreadEnvMode, handleNewThread, project.environmentId, project.id, router],
		1458	);
		1459
		1460	const attemptArchiveThread = useCallback(
		1461	async (threadRef: ScopedThreadRef) => {
997	try {	1462	try {
998	await api.orchestration.dispatchCommand({	1463	await archiveThread(threadRef);
999	type: "thread.meta.update",
1000	commandId: newCommandId(),
1001	threadId,
1002	title: trimmed,
1003	});
1004	} catch (error) {	1464	} catch (error) {
1005	toastManager.add({	1465	toastManager.add({
1006	type: "error",	1466	type: "error",
1007	title: "Failed to rename thread",	1467	title: "Failed to archive thread",
1008	description: error instanceof Error ? error.message : "An error occurred.",	1468	description: error instanceof Error ? error.message : "An error occurred.",
1009	});	1469	});
1010	}	1470	}
1011	finishRename();
1012	},	1471	},
1013	[],	1472	[archiveThread],
1014	);	1473	);
1015		1474
1016	const commitProjectRename = useCallback(	1475	const cancelRename = useCallback(() => {
1017	async (projectId: ProjectId, newTitle: string, originalTitle: string) => {	1476	setRenamingThreadKey(null);
		1477	renamingInputRef.current = null;
		1478	}, []);
		1479
		1480	const commitRename = useCallback(
		1481	async (threadRef: ScopedThreadRef, newTitle: string, originalTitle: string) => {
		1482	const threadKey = scopedThreadKey(threadRef);
1018	const finishRename = () => {	1483	const finishRename = () => {
1019	setRenamingProjectId((current) => {	1484	setRenamingThreadKey((current) => {
1020	if (current !== projectId) return current;	1485	if (current !== threadKey) return current;
1021	projectRenamingInputRef.current = null;	1486	renamingInputRef.current = null;
1022	return null;	1487	return null;
1023	});	1488	});
1024	};	1489	};
@@ -1027,7 +1492,7 @@ export default function Sidebar() { · 2 unmodified lines
1027	if (trimmed.length === 0) {	1492	if (trimmed.length === 0) {
1028	toastManager.add({	1493	toastManager.add({
1029	type: "warning",	1494	type: "warning",
1030	title: "Project title cannot be empty",	1495	title: "Thread title cannot be empty",
1031	});	1496	});
1032	finishRename();	1497	finishRename();
1033	return;	1498	return;
@@ -1036,22 +1501,22 @@ export default function Sidebar() { · 2 unmodified lines
1036	finishRename();	1501	finishRename();
1037	return;	1502	return;
1038	}	1503	}
1039	const api = readNativeApi();	1504	const api = readEnvironmentApi(threadRef.environmentId);
1040	if (!api) {	1505	if (!api) {
1041	finishRename();	1506	finishRename();
1042	return;	1507	return;
1043	}	1508	}
1044	try {	1509	try {
1045	await api.orchestration.dispatchCommand({	1510	await api.orchestration.dispatchCommand({
1046	type: "project.meta.update",	1511	type: "thread.meta.update",
1047	commandId: newCommandId(),	1512	commandId: newCommandId(),
1048	projectId,	1513	threadId: threadRef.threadId,
1049	title: trimmed,	1514	title: trimmed,
1050	});	1515	});
1051	} catch (error) {	1516	} catch (error) {
1052	toastManager.add({	1517	toastManager.add({
1053	type: "error",	1518	type: "error",
1054	title: "Failed to rename project",	1519	title: "Failed to rename thread",
1055	description: error instanceof Error ? error.message : "An error occurred.",	1520	description: error instanceof Error ? error.message : "An error occurred.",
1056	});	1521	});
1057	}	1522	}
@@ -1060,50 +1525,19 @@ export default function Sidebar() { · 2 unmodified lines
1060	[],	1525	[],
1061	);	1526	);
1062		1527
1063	const { copyToClipboard: copyThreadIdToClipboard } = useCopyToClipboard<{
1064	threadId: ThreadId;
1065	}>({
1066	onCopy: (ctx) => {
1067	toastManager.add({
1068	type: "success",
1069	title: "Thread ID copied",
1070	description: ctx.threadId,
1071	});
1072	},
1073	onError: (error) => {
1074	toastManager.add({
1075	type: "error",
1076	title: "Failed to copy thread ID",
1077	description: error instanceof Error ? error.message : "An error occurred.",
1078	});
1079	},
1080	});
1081	const { copyToClipboard: copyPathToClipboard } = useCopyToClipboard<{
1082	path: string;
1083	}>({
1084	onCopy: (ctx) => {
1085	toastManager.add({
1086	type: "success",
1087	title: "Path copied",
1088	description: ctx.path,
1089	});
1090	},
1091	onError: (error) => {
1092	toastManager.add({
1093	type: "error",
1094	title: "Failed to copy path",
1095	description: error instanceof Error ? error.message : "An error occurred.",
1096	});
1097	},
1098	});
1099	const handleThreadContextMenu = useCallback(	1528	const handleThreadContextMenu = useCallback(
1100	async (threadId: ThreadId, position: { x: number; y: number }) => {	1529	async (threadRef: ScopedThreadRef, position: { x: number; y: number }) => {
1101	const api = readNativeApi();	1530	const api = readLocalApi();
1102	if (!api) return;	1531	if (!api) return;
1103	const thread = sidebarThreadsById[threadId];	1532	const threadKey = scopedThreadKey(threadRef);
		1533	const thread =
		1534	projectThreads.find(
		1535	(projectThread) =>
		1536	projectThread.environmentId === threadRef.environmentId &&
		1537	projectThread.id === threadRef.threadId,
		1538	) ?? null;
1104	if (!thread) return;	1539	if (!thread) return;
1105	const threadWorkspacePath =	1540	const threadWorkspacePath = thread.worktreePath ?? project.cwd ?? null;
1106	thread.worktreePath ?? projectCwdById.get(thread.projectId) ?? null;
1107	const clicked = await api.contextMenu.show(	1541	const clicked = await api.contextMenu.show(
1108	[	1542	[
1109	{ id: "rename", label: "Rename thread" },	1543	{ id: "rename", label: "Rename thread" },
@@ -1116,16 +1550,14 @@ export default function Sidebar() { · 6 unmodified lines
1116	);	1550	);
1117		1551
1118	if (clicked === "rename") {	1552	if (clicked === "rename") {
1119	setRenamingProjectId(null);	1553	setRenamingThreadKey(threadKey);
1120	projectRenamingInputRef.current = null;
1121	setRenamingThreadId(threadId);
1122	setRenamingTitle(thread.title);	1554	setRenamingTitle(thread.title);
1123	renamingCommittedRef.current = false;	1555	renamingCommittedRef.current = false;
1124	return;	1556	return;
1125	}	1557	}
1126		1558
1127	if (clicked === "mark-unread") {	1559	if (clicked === "mark-unread") {
1128	markThreadUnread(threadId, thread.latestTurn?.completedAt);	1560	markThreadUnread(threadKey, thread.latestTurn?.completedAt);
1129	return;	1561	return;
1130	}	1562	}
1131	if (clicked === "copy-path") {	1563	if (clicked === "copy-path") {
@@ -1141,11 +1573,11 @@ export default function Sidebar() { · 9 unmodified lines
1141	return;	1573	return;
1142	}	1574	}
1143	if (clicked === "copy-thread-id") {	1575	if (clicked === "copy-thread-id") {
1144	copyThreadIdToClipboard(threadId, { threadId });	1576	copyThreadIdToClipboard(thread.id, { threadId: thread.id });
1145	return;	1577	return;
1146	}	1578	}
1147	if (clicked !== "delete") return;	1579	if (clicked !== "delete") return;
1148	if (appSettings.confirmThreadDelete) {	1580	if (appSettingsConfirmThreadDelete) {
1149	const confirmed = await api.dialogs.confirm(	1581	const confirmed = await api.dialogs.confirm(
1150	[	1582	[
1151	`Delete thread "${thread.title}"?`,	1583	`Delete thread "${thread.title}"?`,
@@ -1156,198 +1588,903 @@ export default function Sidebar() { · 4 unmodified lines
1156	return;	1588	return;
1157	}	1589	}
1158	}	1590	}
1159	await deleteThread(threadId);	1591	await deleteThread(threadRef);
1160	},	1592	},
1161	[	1593	[
1162	appSettings.confirmThreadDelete,	1594	appSettingsConfirmThreadDelete,
1163	copyPathToClipboard,	1595	copyPathToClipboard,
1164	copyThreadIdToClipboard,	1596	copyThreadIdToClipboard,
1165	deleteThread,	1597	deleteThread,
1166	markThreadUnread,	1598	markThreadUnread,
1167	projectCwdById,	1599	project.cwd,
1168	sidebarThreadsById,	1600	projectThreads,
1169	],	1601	],
1170	);	1602	);
1171		1603
1172	const handleMultiSelectContextMenu = useCallback(	1604	return (
1173	async (position: { x: number; y: number }) => {	1605	<>
1174	const api = readNativeApi();	1606	<div className="group/project-header relative">
1175	if (!api) return;	1607	<SidebarMenuButton
1176	const ids = [...selectedThreadIds];	1608	ref={isManualProjectSorting ? dragHandleProps?.setActivatorNodeRef : undefined}
1177	if (ids.length === 0) return;	1609	size="sm"
1178	const count = ids.length;	1610	className={`gap-2 px-2 py-1.5 text-left hover:bg-accent group-hover/project-header:bg-accent group-hover/project-header:text-sidebar-accent-foreground ${
1179		1611	isManualProjectSorting ? "cursor-grab active:cursor-grabbing" : "cursor-pointer"
1180	const clicked = await api.contextMenu.show(	1612	}`}
1181	[	1613	{...(isManualProjectSorting && dragHandleProps ? dragHandleProps.attributes : {})}
1182	{ id: "mark-unread", label: `Mark unread (${count})` },	1614	{...(isManualProjectSorting && dragHandleProps ? dragHandleProps.listeners : {})}
1183	{ id: "delete", label: `Delete (${count})`, destructive: true },	1615	onPointerDownCapture={handleProjectButtonPointerDownCapture}
1184	],	1616	onClick={handleProjectButtonClick}
1185	position,	1617	onKeyDown={handleProjectButtonKeyDown}
1186	);	1618	onContextMenu={handleProjectButtonContextMenu}
1187		1619	>
1188	if (clicked === "mark-unread") {	1620	{!projectExpanded && projectStatus ? (
1189	for (const id of ids) {	1621	<span
1190	const thread = sidebarThreadsById[id];	1622	aria-hidden="true"
1191	markThreadUnread(id, thread?.latestTurn?.completedAt);	1623	title={projectStatus.label}
1192	}	1624	className={`-ml-0.5 relative inline-flex size-3.5 shrink-0 items-center justify-center ${projectStatus.colorClass}`}
1193	clearSelection();	1625	>
1194	return;	1626	<span className="absolute inset-0 flex items-center justify-center transition-opacity duration-150 group-hover/project-header:opacity-0">
1195	}	1627	<span
1196		1628	className={`size-[9px] rounded-full ${projectStatus.dotClass} ${
1197	if (clicked !== "delete") return;	1629	projectStatus.pulse ? "animate-pulse" : ""
1198		1630	}`}
1199	if (appSettings.confirmThreadDelete) {	1631	/>
1200	const confirmed = await api.dialogs.confirm(	1632	</span>
1201	[	1633	<ChevronRightIcon className="absolute inset-0 m-auto size-3.5 text-muted-foreground/70 opacity-0 transition-opacity duration-150 group-hover/project-header:opacity-100" />
1202	`Delete ${count} thread${count === 1 ? "" : "s"}?`,	1634	</span>
1203	"This permanently clears conversation history for these threads.",	1635	) : (
1204	].join("\n"),	1636	<ChevronRightIcon
1205	);	1637	className={`-ml-0.5 size-3.5 shrink-0 text-muted-foreground/70 transition-transform duration-150 ${
1206	if (!confirmed) return;	1638	projectExpanded ? "rotate-90" : ""
1207	}	1639	}`}
1208		1640	/>
1209	const deletedIds = new Set<ThreadId>(ids);	1641	)}
1210	for (const id of ids) {	1642	<ProjectFavicon cwd={project.cwd} />
1211	await deleteThread(id, { deletedThreadIds: deletedIds });	1643	<span className="flex-1 truncate text-xs font-medium text-foreground/90">
1212	}	1644	{project.name}
1213	removeFromSelection(ids);	1645	</span>
1214	},	1646	</SidebarMenuButton>
1215	[	1647	<Tooltip>
1216	appSettings.confirmThreadDelete,	1648	<TooltipTrigger
1217	clearSelection,	1649	render={
1218	deleteThread,	1650	<SidebarMenuAction
1219	markThreadUnread,	1651	render={
1220	removeFromSelection,	1652	<button
1221	selectedThreadIds,	1653	type="button"
1222	sidebarThreadsById,	1654	aria-label={`Create new thread in ${project.name}`}
1223	],	1655	data-testid="new-thread-button"
		1656	/>
		1657	}
		1658	showOnHover
		1659	className="top-1 right-1.5 size-5 rounded-md p-0 text-muted-foreground/70 hover:bg-secondary hover:text-foreground"
		1660	onClick={handleCreateThreadClick}
		1661	>
		1662	<SquarePenIcon className="size-3.5" />
		1663	</SidebarMenuAction>
		1664	}
		1665	/>
		1666	<TooltipPopup side="top">
		1667	{newThreadShortcutLabel ? `New thread (${newThreadShortcutLabel})` : "New thread"}
		1668	</TooltipPopup>
		1669	</Tooltip>
		1670	</div>
		1671
		1672	<SidebarProjectThreadList
		1673	projectKey={project.projectKey}
		1674	projectExpanded={projectExpanded}
		1675	hasOverflowingThreads={hasOverflowingThreads}
		1676	hiddenThreadStatus={hiddenThreadStatus}
		1677	orderedProjectThreadKeys={orderedProjectThreadKeys}
		1678	renderedThreads={renderedThreads}
		1679	showEmptyThreadState={showEmptyThreadState}
		1680	shouldShowThreadPanel={shouldShowThreadPanel}
		1681	isThreadListExpanded={isThreadListExpanded}
		1682	projectCwd={project.cwd}
		1683	activeRouteThreadKey={activeRouteThreadKey}
		1684	threadJumpLabelByKey={threadJumpLabelByKey}
		1685	appSettingsConfirmThreadArchive={appSettingsConfirmThreadArchive}
		1686	renamingThreadKey={renamingThreadKey}
		1687	renamingTitle={renamingTitle}
		1688	setRenamingTitle={setRenamingTitle}
		1689	renamingInputRef={renamingInputRef}
		1690	renamingCommittedRef={renamingCommittedRef}
		1691	confirmingArchiveThreadKey={confirmingArchiveThreadKey}
		1692	setConfirmingArchiveThreadKey={setConfirmingArchiveThreadKey}
		1693	confirmArchiveButtonRefs={confirmArchiveButtonRefs}
		1694	attachThreadListAutoAnimateRef={attachThreadListAutoAnimateRef}
		1695	handleThreadClick={handleThreadClick}
		1696	navigateToThread={navigateToThread}
		1697	handleMultiSelectContextMenu={handleMultiSelectContextMenu}
		1698	handleThreadContextMenu={handleThreadContextMenu}
		1699	clearSelection={clearSelection}
		1700	commitRename={commitRename}
		1701	cancelRename={cancelRename}
		1702	attemptArchiveThread={attemptArchiveThread}
		1703	openPrLink={openPrLink}
		1704	expandThreadListForProject={expandThreadListForProject}
		1705	collapseThreadListForProject={collapseThreadListForProject}
		1706	/>
		1707	</>
1224	);	1708	);
		1709	});
1225		1710
1226	const handleThreadClick = useCallback(	1711	const SidebarProjectListRow = memo(function SidebarProjectListRow(props: SidebarProjectItemProps) {
1227	(event: MouseEvent, threadId: ThreadId, orderedProjectThreadIds: readonly ThreadId[]) => {	1712	return (
1228	const isMac = isMacPlatform(navigator.platform);	1713	<SidebarMenuItem className="rounded-md">
1229	const isModClick = isMac ? event.metaKey : event.ctrlKey;	1714	<SidebarProjectItem {...props} />
1230	const isShiftClick = event.shiftKey;	1715	</SidebarMenuItem>
1231
1232	if (isModClick) {
1233	event.preventDefault();
1234	toggleThreadSelection(threadId);
1235	return;
1236	}
1237
1238	if (isShiftClick) {
1239	event.preventDefault();
1240	rangeSelectTo(threadId, orderedProjectThreadIds);
1241	return;
1242	}
1243
1244	// Plain click — clear selection, set anchor for future shift-clicks, and navigate
1245	if (selectedThreadIds.size > 0) {
1246	clearSelection();
1247	}
1248	setSelectionAnchor(threadId);
1249	void navigate({
1250	to: "/$threadId",
1251	params: { threadId },
1252	});
1253	},
1254	[
1255	clearSelection,
1256	navigate,
1257	rangeSelectTo,
1258	selectedThreadIds.size,
1259	setSelectionAnchor,
1260	toggleThreadSelection,
1261	],
1262	);	1716	);
		1717	});
1263		1718
1264	const navigateToThread = useCallback(	1719	function T3Wordmark() {
1265	(threadId: ThreadId) => {	1720	return (
1266	if (selectedThreadIds.size > 0) {	1721	<svg
1267	clearSelection();	1722	aria-label="T3"
1268	}	1723	className="h-2.5 w-auto shrink-0 text-foreground"
1269	setSelectionAnchor(threadId);	1724	viewBox="15.5309 37 94.3941 56.96"
1270	void navigate({	1725	xmlns="http://www.w3.org/2000/svg"
1271	to: "/$threadId",	1726	>
1272	params: { threadId },	1727	<path
1273	});	1728	d="M33.4509 93V47.56H15.5309V37H64.3309V47.56H46.4109V93H33.4509ZM86.7253 93.96C82.832 93.96 78.9653 93.4533 75.1253 92.44C71.2853 91.3733 68.032 89.88 65.3653 87.96L70.4053 78.04C72.5386 79.5867 75.0186 80.8133 77.8453 81.72C80.672 82.6267 83.5253 83.08 86.4053 83.08C89.6586 83.08 92.2186 82.44 94.0853 81.16C95.952 79.88 96.8853 78.12 96.8853 75.88C96.8853 73.7467 96.0586 72.0667 94.4053 70.84C92.752 69.6133 90.0853 69 86.4053 69H80.4853V60.44L96.0853 42.76L97.5253 47.4H68.1653V37H107.365V45.4L91.8453 63.08L85.2853 59.32H89.0453C95.9253 59.32 101.125 60.8667 104.645 63.96C108.165 67.0533 109.925 71.0267 109.925 75.88C109.925 79.0267 109.099 81.9867 107.445 84.76C105.792 87.48 103.259 89.6933 99.8453 91.4C96.432 93.1067 92.0586 93.96 86.7253 93.96Z"
1274	},	1729	fill="currentColor"
1275	[clearSelection, navigate, selectedThreadIds.size, setSelectionAnchor],	1730	/>
		1731	</svg>
1276	);	1732	);
		1733	}
1277		1734
1278	const handleProjectContextMenu = useCallback(	1735	type SortableProjectHandleProps = Pick<
1279	async (projectId: ProjectId, position: { x: number; y: number }) => {	1736	ReturnType<typeof useSortable>,
1280	const api = readNativeApi();	1737	"attributes" \| "listeners" \| "setActivatorNodeRef"
1281	if (!api) return;	1738	>;
1282	const project = projects.find((entry) => entry.id === projectId);
1283	if (!project) return;
1284		1739
1285	const clicked = await api.contextMenu.show(	1740	function ProjectSortMenu({
1286	[	1741	projectSortOrder,
1287	{ id: "rename", label: "Rename project" },	1742	threadSortOrder,
1288	{ id: "copy-path", label: "Copy Project Path" },	1743	onProjectSortOrderChange,
1289	{ id: "delete", label: "Remove project", destructive: true },	1744	onThreadSortOrderChange,
1290	],	1745	}: {
1291	position,	1746	projectSortOrder: SidebarProjectSortOrder;
1292	);	1747	threadSortOrder: SidebarThreadSortOrder;
1293	if (clicked === "rename") {	1748	onProjectSortOrderChange: (sortOrder: SidebarProjectSortOrder) => void;
1294	setRenamingThreadId(null);	1749	onThreadSortOrderChange: (sortOrder: SidebarThreadSortOrder) => void;
1295	renamingInputRef.current = null;	1750	}) {
1296	setRenamingProjectId(projectId);	1751	return (
1297	setRenamingProjectTitle(project.name);	1752	<Menu>
1298	projectRenamingCommittedRef.current = false;	1753	<Tooltip>
1299	return;	1754	<TooltipTrigger
		1755	render={
		1756	<MenuTrigger className="inline-flex size-5 cursor-pointer items-center justify-center rounded-md text-muted-foreground/60 transition-colors hover:bg-accent hover:text-foreground" />
		1757	}
		1758	>
		1759	<ArrowUpDownIcon className="size-3.5" />
		1760	</TooltipTrigger>
		1761	<TooltipPopup side="right">Sort projects</TooltipPopup>
		1762	</Tooltip>
		1763	<MenuPopup align="end" side="bottom" className="min-w-44">
		1764	<MenuGroup>
		1765	<div className="px-2 py-1 sm:text-xs font-medium text-muted-foreground">
		1766	Sort projects
		1767	</div>
		1768	<MenuRadioGroup
		1769	value={projectSortOrder}
		1770	onValueChange={(value) => {
		1771	onProjectSortOrderChange(value as SidebarProjectSortOrder);
		1772	}}
		1773	>
		1774	{(Object.entries(SIDEBAR_SORT_LABELS) as Array<[SidebarProjectSortOrder, string]>).map(
		1775	([value, label]) => (
		1776	<MenuRadioItem key={value} value={value} className="min-h-7 py-1 sm:text-xs">
		1777	{label}
		1778	</MenuRadioItem>
		1779	),
		1780	)}
		1781	</MenuRadioGroup>
		1782	</MenuGroup>
		1783	<MenuGroup>
		1784	<div className="px-2 pt-2 pb-1 sm:text-xs font-medium text-muted-foreground">
		1785	Sort threads
		1786	</div>
		1787	<MenuRadioGroup
		1788	value={threadSortOrder}
		1789	onValueChange={(value) => {
		1790	onThreadSortOrderChange(value as SidebarThreadSortOrder);
		1791	}}
		1792	>
		1793	{(
		1794	Object.entries(SIDEBAR_THREAD_SORT_LABELS) as Array<[SidebarThreadSortOrder, string]>
		1795	).map(([value, label]) => (
		1796	<MenuRadioItem key={value} value={value} className="min-h-7 py-1 sm:text-xs">
		1797	{label}
		1798	</MenuRadioItem>
		1799	))}
		1800	</MenuRadioGroup>
		1801	</MenuGroup>
		1802	</MenuPopup>
		1803	</Menu>
		1804	);
		1805	}
		1806
		1807	function SortableProjectItem({
		1808	projectId,
		1809	disabled = false,
		1810	children,
		1811	}: {
		1812	projectId: string;
		1813	disabled?: boolean;
		1814	children: (handleProps: SortableProjectHandleProps) => React.ReactNode;
		1815	}) {
		1816	const {
		1817	attributes,
		1818	listeners,
		1819	setActivatorNodeRef,
		1820	setNodeRef,
		1821	transform,
		1822	transition,
		1823	isDragging,
		1824	isOver,
		1825	} = useSortable({ id: projectId, disabled });
		1826	return (
		1827	<li
		1828	ref={setNodeRef}
		1829	style={{
		1830	transform: CSS.Translate.toString(transform),
		1831	transition,
		1832	}}
		1833	className={`group/menu-item relative rounded-md ${
		1834	isDragging ? "z-20 opacity-80" : ""
		1835	} ${isOver && !isDragging ? "ring-1 ring-primary/40" : ""}`}
		1836	data-sidebar="menu-item"
		1837	data-slot="sidebar-menu-item"
		1838	>
		1839	{children({ attributes, listeners, setActivatorNodeRef })}
		1840	</li>
		1841	);
		1842	}
		1843
		1844	const SidebarChromeHeader = memo(function SidebarChromeHeader({
		1845	isElectron,
		1846	}: {
		1847	isElectron: boolean;
		1848	}) {
		1849	const wordmark = (
		1850	<div className="flex items-center gap-2">
		1851	<SidebarTrigger className="shrink-0 md:hidden" />
		1852	<Tooltip>
		1853	<TooltipTrigger
		1854	render={
		1855	<Link
		1856	aria-label="Go to threads"
		1857	className="ml-1 flex min-w-0 flex-1 cursor-pointer items-center gap-1 rounded-md outline-hidden ring-ring transition-colors hover:text-foreground focus-visible:ring-2"
		1858	to="/"
		1859	>
		1860	<T3Wordmark />
		1861	<span className="truncate text-sm font-medium tracking-tight text-muted-foreground">
		1862	Code
		1863	</span>
		1864	<span className="rounded-full bg-muted/50 px-1.5 py-0.5 text-[8px] font-medium uppercase tracking-[0.18em] text-muted-foreground/60">
		1865	{APP_STAGE_LABEL}
		1866	</span>
		1867	</Link>
		1868	}
		1869	/>
		1870	<TooltipPopup side="bottom" sideOffset={2}>
		1871	Version {APP_VERSION}
		1872	</TooltipPopup>
		1873	</Tooltip>
		1874	</div>
		1875	);
		1876
		1877	return isElectron ? (
		1878	<SidebarHeader className="drag-region h-[52px] flex-row items-center gap-2 px-4 py-0 pl-[90px]">
		1879	{wordmark}
		1880	</SidebarHeader>
		1881	) : (
		1882	<SidebarHeader className="gap-3 px-3 py-2 sm:gap-2.5 sm:px-4 sm:py-3">{wordmark}</SidebarHeader>
		1883	);
		1884	});
		1885
		1886	const SidebarChromeFooter = memo(function SidebarChromeFooter() {
		1887	const navigate = useNavigate();
		1888	const handleSettingsClick = useCallback(() => {
		1889	void navigate({ to: "/settings" });
		1890	}, [navigate]);
		1891
		1892	return (
		1893	<SidebarFooter className="p-2">
		1894	<SidebarUpdatePill />
		1895	<SidebarMenu>
		1896	<SidebarMenuItem>
		1897	<SidebarMenuButton
		1898	size="sm"
		1899	className="gap-2 px-2 py-1.5 text-muted-foreground/70 hover:bg-accent hover:text-foreground"
		1900	onClick={handleSettingsClick}
		1901	>
		1902	<SettingsIcon className="size-3.5" />
		1903	<span className="text-xs">Settings</span>
		1904	</SidebarMenuButton>
		1905	</SidebarMenuItem>
		1906	</SidebarMenu>
		1907	</SidebarFooter>
		1908	);
		1909	});
		1910
		1911	interface SidebarProjectsContentProps {
		1912	showArm64IntelBuildWarning: boolean;
		1913	arm64IntelBuildWarningDescription: string \| null;
		1914	desktopUpdateButtonAction: "download" \| "install" \| "none";
		1915	desktopUpdateButtonDisabled: boolean;
		1916	handleDesktopUpdateButtonClick: () => void;
		1917	projectSortOrder: SidebarProjectSortOrder;
		1918	threadSortOrder: SidebarThreadSortOrder;
		1919	updateSettings: ReturnType<typeof useUpdateSettings>["updateSettings"];
		1920	shouldShowProjectPathEntry: boolean;
		1921	handleStartAddProject: () => void;
		1922	isElectron: boolean;
		1923	isPickingFolder: boolean;
		1924	isAddingProject: boolean;
		1925	handlePickFolder: () => Promise<void>;
		1926	addProjectInputRef: React.RefObject<HTMLInputElement \| null>;
		1927	addProjectError: string \| null;
		1928	newCwd: string;
		1929	setNewCwd: React.Dispatch<React.SetStateAction<string>>;
		1930	setAddProjectError: React.Dispatch<React.SetStateAction<string \| null>>;
		1931	handleAddProject: () => void;
		1932	setAddingProject: React.Dispatch<React.SetStateAction<boolean>>;
		1933	canAddProject: boolean;
		1934	isManualProjectSorting: boolean;
		1935	projectDnDSensors: ReturnType<typeof useSensors>;
		1936	projectCollisionDetection: CollisionDetection;
		1937	handleProjectDragStart: (event: DragStartEvent) => void;
		1938	handleProjectDragEnd: (event: DragEndEvent) => void;
		1939	handleProjectDragCancel: (event: DragCancelEvent) => void;
		1940	handleNewThread: ReturnType<typeof useHandleNewThread>["handleNewThread"];
		1941	archiveThread: ReturnType<typeof useThreadActions>["archiveThread"];
		1942	deleteThread: ReturnType<typeof useThreadActions>["deleteThread"];
		1943	sortedProjects: readonly SidebarProjectSnapshot[];
		1944	expandedThreadListsByProject: ReadonlySet<string>;
		1945	activeRouteProjectKey: string \| null;
		1946	routeThreadKey: string \| null;
		1947	newThreadShortcutLabel: string \| null;
		1948	threadJumpLabelByKey: ReadonlyMap<string, string>;
		1949	attachThreadListAutoAnimateRef: (node: HTMLElement \| null) => void;
		1950	expandThreadListForProject: (projectKey: string) => void;
		1951	collapseThreadListForProject: (projectKey: string) => void;
		1952	dragInProgressRef: React.RefObject<boolean>;
		1953	suppressProjectClickAfterDragRef: React.RefObject<boolean>;
		1954	suppressProjectClickForContextMenuRef: React.RefObject<boolean>;
		1955	attachProjectListAutoAnimateRef: (node: HTMLElement \| null) => void;
		1956	projectsLength: number;
		1957	}
		1958
		1959	const SidebarProjectsContent = memo(function SidebarProjectsContent(
		1960	props: SidebarProjectsContentProps,
		1961	) {
		1962	const {
		1963	showArm64IntelBuildWarning,
		1964	arm64IntelBuildWarningDescription,
		1965	desktopUpdateButtonAction,
		1966	desktopUpdateButtonDisabled,
		1967	handleDesktopUpdateButtonClick,
		1968	projectSortOrder,
		1969	threadSortOrder,
		1970	updateSettings,
		1971	shouldShowProjectPathEntry,
		1972	handleStartAddProject,
		1973	isElectron,
		1974	isPickingFolder,
		1975	isAddingProject,
		1976	handlePickFolder,
		1977	addProjectInputRef,
		1978	addProjectError,
		1979	newCwd,
		1980	setNewCwd,
		1981	setAddProjectError,
		1982	handleAddProject,
		1983	setAddingProject,
		1984	canAddProject,
		1985	isManualProjectSorting,
		1986	projectDnDSensors,
		1987	projectCollisionDetection,
		1988	handleProjectDragStart,
		1989	handleProjectDragEnd,
		1990	handleProjectDragCancel,
		1991	handleNewThread,
		1992	archiveThread,
		1993	deleteThread,
		1994	sortedProjects,
		1995	expandedThreadListsByProject,
		1996	activeRouteProjectKey,
		1997	routeThreadKey,
		1998	newThreadShortcutLabel,
		1999	threadJumpLabelByKey,
		2000	attachThreadListAutoAnimateRef,
		2001	expandThreadListForProject,
		2002	collapseThreadListForProject,
		2003	dragInProgressRef,
		2004	suppressProjectClickAfterDragRef,
		2005	suppressProjectClickForContextMenuRef,
		2006	attachProjectListAutoAnimateRef,
		2007	projectsLength,
		2008	} = props;
		2009
		2010	const handleProjectSortOrderChange = useCallback(
		2011	(sortOrder: SidebarProjectSortOrder) => {
		2012	updateSettings({ sidebarProjectSortOrder: sortOrder });
		2013	},
		2014	[updateSettings],
		2015	);
		2016	const handleThreadSortOrderChange = useCallback(
		2017	(sortOrder: SidebarThreadSortOrder) => {
		2018	updateSettings({ sidebarThreadSortOrder: sortOrder });
		2019	},
		2020	[updateSettings],
		2021	);
		2022	const handleAddProjectInputChange = useCallback(
		2023	(event: React.ChangeEvent<HTMLInputElement>) => {
		2024	setNewCwd(event.target.value);
		2025	setAddProjectError(null);
		2026	},
		2027	[setAddProjectError, setNewCwd],
		2028	);
		2029	const handleAddProjectInputKeyDown = useCallback(
		2030	(event: React.KeyboardEvent<HTMLInputElement>) => {
		2031	if (event.key === "Enter") handleAddProject();
		2032	if (event.key === "Escape") {
		2033	setAddingProject(false);
		2034	setAddProjectError(null);
1300	}	2035	}
1301	if (clicked === "copy-path") {	2036	},
1302	copyPathToClipboard(project.cwd, { path: project.cwd });	2037	[handleAddProject, setAddProjectError, setAddingProject],
1303	return;	2038	);
		2039	const handleBrowseForFolderClick = useCallback(() => {
		2040	void handlePickFolder();
		2041	}, [handlePickFolder]);
		2042
		2043	return (
		2044	<SidebarContent className="gap-0">
		2045	{showArm64IntelBuildWarning && arm64IntelBuildWarningDescription ? (
		2046	<SidebarGroup className="px-2 pt-2 pb-0">
		2047	<Alert variant="warning" className="rounded-2xl border-warning/40 bg-warning/8">
		2048	<TriangleAlertIcon />
		2049	<AlertTitle>Intel build on Apple Silicon</AlertTitle>
		2050	<AlertDescription>{arm64IntelBuildWarningDescription}</AlertDescription>
		2051	{desktopUpdateButtonAction !== "none" ? (
		2052	<AlertAction>
		2053	<Button
		2054	size="xs"
		2055	variant="outline"
		2056	disabled={desktopUpdateButtonDisabled}
		2057	onClick={handleDesktopUpdateButtonClick}
		2058	>
		2059	{desktopUpdateButtonAction === "download"
		2060	? "Download ARM build"
		2061	: "Install ARM build"}
		2062	</Button>
		2063	</AlertAction>
		2064	) : null}
		2065	</Alert>
		2066	</SidebarGroup>
		2067	) : null}
		2068	<SidebarGroup className="px-2 py-2">
		2069	<div className="mb-1 flex items-center justify-between pl-2 pr-1.5">
		2070	<span className="text-[10px] font-medium uppercase tracking-wider text-muted-foreground/60">
		2071	Projects
		2072	</span>
		2073	<div className="flex items-center gap-1">
		2074	<ProjectSortMenu
		2075	projectSortOrder={projectSortOrder}
		2076	threadSortOrder={threadSortOrder}
		2077	onProjectSortOrderChange={handleProjectSortOrderChange}
		2078	onThreadSortOrderChange={handleThreadSortOrderChange}
		2079	/>
		2080	<Tooltip>
		2081	<TooltipTrigger
		2082	render={
		2083	<button
		2084	type="button"
		2085	aria-label={shouldShowProjectPathEntry ? "Cancel add project" : "Add project"}
		2086	aria-pressed={shouldShowProjectPathEntry}
		2087	className="inline-flex size-5 cursor-pointer items-center justify-center rounded-md text-muted-foreground/60 transition-colors hover:bg-accent hover:text-foreground"
		2088	onClick={handleStartAddProject}
		2089	/>
		2090	}
		2091	>
		2092	<PlusIcon
		2093	className={`size-3.5 transition-transform duration-150 ${
		2094	shouldShowProjectPathEntry ? "rotate-45" : "rotate-0"
		2095	}`}
		2096	/>
		2097	</TooltipTrigger>
		2098	<TooltipPopup side="right">
		2099	{shouldShowProjectPathEntry ? "Cancel add project" : "Add project"}
		2100	</TooltipPopup>
		2101	</Tooltip>
		2102	</div>
		2103	</div>
		2104	{shouldShowProjectPathEntry && (
		2105	<div className="mb-2 px-1">
		2106	{isElectron && (
		2107	<button
		2108	type="button"
		2109	className="mb-1.5 flex w-full items-center justify-center gap-2 rounded-md border border-border bg-secondary py-1.5 text-xs text-foreground/80 transition-colors duration-150 hover:bg-accent hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
		2110	onClick={handleBrowseForFolderClick}
		2111	disabled={isPickingFolder \|\| isAddingProject}
		2112	>
		2113	<FolderIcon className="size-3.5" />
		2114	{isPickingFolder ? "Picking folder..." : "Browse for folder"}
		2115	</button>
		2116	)}
		2117	<div className="flex gap-1.5">
		2118	<input
		2119	ref={addProjectInputRef}
		2120	className={`min-w-0 flex-1 rounded-md border bg-secondary px-2 py-1 font-mono text-xs text-foreground placeholder:text-muted-foreground/40 focus:outline-none ${
		2121	addProjectError
		2122	? "border-red-500/70 focus:border-red-500"
		2123	: "border-border focus:border-ring"
		2124	}`}
		2125	placeholder="/path/to/project"
		2126	value={newCwd}
		2127	onChange={handleAddProjectInputChange}
		2128	onKeyDown={handleAddProjectInputKeyDown}
		2129	autoFocus
		2130	/>
		2131	<button
		2132	type="button"
		2133	className="shrink-0 rounded-md bg-primary px-2.5 py-1 text-xs font-medium text-primary-foreground transition-colors duration-150 hover:bg-primary/90 disabled:opacity-60"
		2134	onClick={handleAddProject}
		2135	disabled={!canAddProject}
		2136	>
		2137	{isAddingProject ? "Adding..." : "Add"}
		2138	</button>
		2139	</div>
		2140	{addProjectError && (
		2141	<p className="mt-1 px-0.5 text-[11px] leading-tight text-red-400">
		2142	{addProjectError}
		2143	</p>
		2144	)}
		2145	</div>
		2146	)}
		2147
		2148	{isManualProjectSorting ? (
		2149	<DndContext
		2150	sensors={projectDnDSensors}
		2151	collisionDetection={projectCollisionDetection}
		2152	modifiers={[restrictToVerticalAxis, restrictToFirstScrollableAncestor]}
		2153	onDragStart={handleProjectDragStart}
		2154	onDragEnd={handleProjectDragEnd}
		2155	onDragCancel={handleProjectDragCancel}
		2156	>
		2157	<SidebarMenu>
		2158	<SortableContext
		2159	items={sortedProjects.map((project) => project.projectKey)}
		2160	strategy={verticalListSortingStrategy}
		2161	>
		2162	{sortedProjects.map((project) => (
		2163	<SortableProjectItem key={project.projectKey} projectId={project.projectKey}>
		2164	{(dragHandleProps) => (
		2165	<SidebarProjectItem
		2166	project={project}
		2167	isThreadListExpanded={expandedThreadListsByProject.has(project.projectKey)}
		2168	activeRouteThreadKey={
		2169	activeRouteProjectKey === project.projectKey ? routeThreadKey : null
		2170	}
		2171	newThreadShortcutLabel={newThreadShortcutLabel}
		2172	handleNewThread={handleNewThread}
		2173	archiveThread={archiveThread}
		2174	deleteThread={deleteThread}
		2175	threadJumpLabelByKey={threadJumpLabelByKey}
		2176	attachThreadListAutoAnimateRef={attachThreadListAutoAnimateRef}
		2177	expandThreadListForProject={expandThreadListForProject}
		2178	collapseThreadListForProject={collapseThreadListForProject}
		2179	dragInProgressRef={dragInProgressRef}
		2180	suppressProjectClickAfterDragRef={suppressProjectClickAfterDragRef}
		2181	suppressProjectClickForContextMenuRef={
		2182	suppressProjectClickForContextMenuRef
		2183	}
		2184	isManualProjectSorting={isManualProjectSorting}
		2185	dragHandleProps={dragHandleProps}
		2186	/>
		2187	)}
		2188	</SortableProjectItem>
		2189	))}
		2190	</SortableContext>
		2191	</SidebarMenu>
		2192	</DndContext>
		2193	) : (
		2194	<SidebarMenu ref={attachProjectListAutoAnimateRef}>
		2195	{sortedProjects.map((project) => (
		2196	<SidebarProjectListRow
		2197	key={project.projectKey}
		2198	project={project}
		2199	isThreadListExpanded={expandedThreadListsByProject.has(project.projectKey)}
		2200	activeRouteThreadKey={
		2201	activeRouteProjectKey === project.projectKey ? routeThreadKey : null
		2202	}
		2203	newThreadShortcutLabel={newThreadShortcutLabel}
		2204	handleNewThread={handleNewThread}
		2205	archiveThread={archiveThread}
		2206	deleteThread={deleteThread}
		2207	threadJumpLabelByKey={threadJumpLabelByKey}
		2208	attachThreadListAutoAnimateRef={attachThreadListAutoAnimateRef}
		2209	expandThreadListForProject={expandThreadListForProject}
		2210	collapseThreadListForProject={collapseThreadListForProject}
		2211	dragInProgressRef={dragInProgressRef}
		2212	suppressProjectClickAfterDragRef={suppressProjectClickAfterDragRef}
		2213	suppressProjectClickForContextMenuRef={suppressProjectClickForContextMenuRef}
		2214	isManualProjectSorting={isManualProjectSorting}
		2215	dragHandleProps={null}
		2216	/>
		2217	))}
		2218	</SidebarMenu>
		2219	)}
		2220
		2221	{projectsLength === 0 && !shouldShowProjectPathEntry && (
		2222	<div className="px-2 pt-4 text-center text-xs text-muted-foreground/60">
		2223	No projects yet
		2224	</div>
		2225	)}
		2226	</SidebarGroup>
		2227	</SidebarContent>
		2228	);
		2229	});
		2230
		2231	export default function Sidebar() {
		2232	const projects = useStore(useShallow(selectProjectsAcrossEnvironments));
		2233	const sidebarThreads = useStore(useShallow(selectSidebarThreadsAcrossEnvironments));
		2234	const activeEnvironmentId = useStore((store) => store.activeEnvironmentId);
		2235	const projectExpandedById = useUiStateStore((store) => store.projectExpandedById);
		2236	const projectOrder = useUiStateStore((store) => store.projectOrder);
		2237	const reorderProjects = useUiStateStore((store) => store.reorderProjects);
		2238	const navigate = useNavigate();
		2239	const pathname = useLocation({ select: (loc) => loc.pathname });
		2240	const isOnSettings = pathname.startsWith("/settings");
		2241	const appSettings = useSettings();
		2242	const { updateSettings } = useUpdateSettings();
		2243	const { handleNewThread } = useHandleNewThread();
		2244	const { archiveThread, deleteThread } = useThreadActions();
		2245	const routeThreadRef = useParams({
		2246	strict: false,
		2247	select: (params) => resolveThreadRouteRef(params),
		2248	});
		2249	const routeThreadKey = routeThreadRef ? scopedThreadKey(routeThreadRef) : null;
		2250	const keybindings = useServerKeybindings();
		2251	const [addingProject, setAddingProject] = useState(false);
		2252	const [newCwd, setNewCwd] = useState("");
		2253	const [isPickingFolder, setIsPickingFolder] = useState(false);
		2254	const [isAddingProject, setIsAddingProject] = useState(false);
		2255	const [addProjectError, setAddProjectError] = useState<string \| null>(null);
		2256	const addProjectInputRef = useRef<HTMLInputElement \| null>(null);
		2257	const [expandedThreadListsByProject, setExpandedThreadListsByProject] = useState<
		2258	ReadonlySet<string>
		2259	>(() => new Set());
		2260	const { showThreadJumpHints, updateThreadJumpHintsVisibility } = useThreadJumpHintVisibility();
		2261	const dragInProgressRef = useRef(false);
		2262	const suppressProjectClickAfterDragRef = useRef(false);
		2263	const suppressProjectClickForContextMenuRef = useRef(false);
		2264	const [desktopUpdateState, setDesktopUpdateState] = useState<DesktopUpdateState \| null>(null);
		2265	const selectedThreadCount = useThreadSelectionStore((s) => s.selectedThreadKeys.size);
		2266	const clearSelection = useThreadSelectionStore((s) => s.clearSelection);
		2267	const setSelectionAnchor = useThreadSelectionStore((s) => s.setAnchor);
		2268	const isLinuxDesktop = isElectron && isLinuxPlatform(navigator.platform);
		2269	const platform = navigator.platform;
		2270	const shouldBrowseForProjectImmediately = isElectron && !isLinuxDesktop;
		2271	const shouldShowProjectPathEntry = addingProject && !shouldBrowseForProjectImmediately;
		2272	const orderedProjects = useMemo(() => {
		2273	return orderItemsByPreferredIds({
		2274	items: projects,
		2275	preferredIds: projectOrder,
		2276	getId: (project) => scopedProjectKey(scopeProjectRef(project.environmentId, project.id)),
		2277	});
		2278	}, [projectOrder, projects]);
		2279	const sidebarProjects = useMemo<SidebarProjectSnapshot[]>(
		2280	() =>
		2281	orderedProjects.map((project) => ({
		2282	...project,
		2283	projectKey: scopedProjectKey(scopeProjectRef(project.environmentId, project.id)),
		2284	})),
		2285	[orderedProjects],
		2286	);
		2287	const sidebarProjectByKey = useMemo(
		2288	() => new Map(sidebarProjects.map((project) => [project.projectKey, project] as const)),
		2289	[sidebarProjects],
		2290	);
		2291	const sidebarThreadByKey = useMemo(
		2292	() =>
		2293	new Map(
		2294	sidebarThreads.map(
		2295	(thread) =>
		2296	[scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)), thread] as const,
		2297	),
		2298	),
		2299	[sidebarThreads],
		2300	);
		2301	const activeRouteProjectKey = useMemo(() => {
		2302	if (!routeThreadKey) {
		2303	return null;
		2304	}
		2305	const activeThread = sidebarThreadByKey.get(routeThreadKey);
		2306	return activeThread
		2307	? scopedProjectKey(scopeProjectRef(activeThread.environmentId, activeThread.projectId))
		2308	: null;
		2309	}, [routeThreadKey, sidebarThreadByKey]);
		2310	const threadsByProjectKey = useMemo(() => {
		2311	const next = new Map<string, SidebarThreadSummary[]>();
		2312	for (const thread of sidebarThreads) {
		2313	const projectKey = scopedProjectKey(scopeProjectRef(thread.environmentId, thread.projectId));
		2314	const existing = next.get(projectKey);
		2315	if (existing) {
		2316	existing.push(thread);
		2317	} else {
		2318	next.set(projectKey, [thread]);
1304	}	2319	}
1305	if (clicked !== "delete") return;	2320	}
		2321	return next;
		2322	}, [sidebarThreads]);
		2323	const getCurrentSidebarShortcutContext = useCallback(
		2324	() => ({
		2325	terminalFocus: isTerminalFocused(),
		2326	terminalOpen: routeThreadRef
		2327	? selectThreadTerminalState(
		2328	useTerminalStateStore.getState().terminalStateByThreadKey,
		2329	routeThreadRef,
		2330	).terminalOpen
		2331	: false,
		2332	}),
		2333	[routeThreadRef],
		2334	);
		2335	const newThreadShortcutLabelOptions = useMemo(
		2336	() => ({
		2337	platform,
		2338	context: {
		2339	terminalFocus: false,
		2340	terminalOpen: false,
		2341	},
		2342	}),
		2343	[platform],
		2344	);
		2345	const newThreadShortcutLabel =
		2346	shortcutLabelForCommand(keybindings, "chat.newLocal", newThreadShortcutLabelOptions) ??
		2347	shortcutLabelForCommand(keybindings, "chat.new", newThreadShortcutLabelOptions);
		2348	const focusMostRecentThreadForProject = useCallback(
		2349	(projectRef: { environmentId: EnvironmentId; projectId: ProjectId }) => {
		2350	const projectKey = scopedProjectKey(
		2351	scopeProjectRef(projectRef.environmentId, projectRef.projectId),
		2352	);
		2353	const latestThread = sortThreadsForSidebar(
		2354	(threadsByProjectKey.get(projectKey) ?? []).filter((thread) => thread.archivedAt === null),
		2355	appSettings.sidebarThreadSortOrder,
		2356	)[0];
		2357	if (!latestThread) return;
1306		2358
1307	const projectThreadIds = threadIdsByProjectId[projectId] ?? [];	2359	void navigate({
1308	if (projectThreadIds.length > 0) {	2360	to: "/$environmentId/$threadId",
1309	toastManager.add({	2361	params: buildThreadRouteParams(scopeThreadRef(latestThread.environmentId, latestThread.id)),
1310	type: "warning",	2362	});
1311	title: "Project is not empty",	2363	},
1312	description: "Delete all threads in this project before removing it.",	2364	[appSettings.sidebarThreadSortOrder, navigate, threadsByProjectKey],
		2365	);
		2366
		2367	const addProjectFromPath = useCallback(
		2368	async (rawCwd: string) => {
		2369	const cwd = rawCwd.trim();
		2370	if (!cwd \|\| isAddingProject) return;
		2371	const api = activeEnvironmentId ? readEnvironmentApi(activeEnvironmentId) : undefined;
		2372	if (!api) return;
		2373
		2374	setIsAddingProject(true);
		2375	const finishAddingProject = () => {
		2376	setIsAddingProject(false);
		2377	setNewCwd("");
		2378	setAddProjectError(null);
		2379	setAddingProject(false);
		2380	};
		2381
		2382	const existing = projects.find((project) => project.cwd === cwd);
		2383	if (existing) {
		2384	focusMostRecentThreadForProject({
		2385	environmentId: existing.environmentId,
		2386	projectId: existing.id,
1313	});	2387	});
		2388	finishAddingProject();
1314	return;	2389	return;
1315	}	2390	}
1316		2391
1317	const confirmed = await api.dialogs.confirm(`Remove project "${project.name}"?`);	2392	const projectId = newProjectId();
1318	if (!confirmed) return;	2393	const createdAt = new Date().toISOString();
1319		2394	const title = cwd.split(/[/\\]/).findLast(isNonEmptyString) ?? cwd;
1320	try {	2395	try {
1321	const projectDraftThread = getDraftThreadByProjectId(projectId);
1322	if (projectDraftThread) {
1323	clearComposerDraftForThread(projectDraftThread.threadId);
1324	}
1325	clearProjectDraftThreadId(projectId);
1326	await api.orchestration.dispatchCommand({	2396	await api.orchestration.dispatchCommand({
1327	type: "project.delete",	2397	type: "project.create",
1328	commandId: newCommandId(),	2398	commandId: newCommandId(),
1329	projectId,	2399	projectId,
		2400	title,
		2401	workspaceRoot: cwd,
		2402	defaultModelSelection: {
		2403	provider: "codex",
		2404	model: DEFAULT_MODEL_BY_PROVIDER.codex,
		2405	},
		2406	createdAt,
1330	});	2407	});
		2408	if (activeEnvironmentId !== null) {
		2409	await handleNewThread(scopeProjectRef(activeEnvironmentId, projectId), {
		2410	envMode: appSettings.defaultThreadEnvMode,
		2411	}).catch(() => undefined);
		2412	}
1331	} catch (error) {	2413	} catch (error) {
1332	const message = error instanceof Error ? error.message : "Unknown error removing project.";	2414	const description =
1333	console.error("Failed to remove project", { projectId, error });	2415	error instanceof Error ? error.message : "An error occurred while adding the project.";
1334	toastManager.add({	2416	setIsAddingProject(false);
1335	type: "error",	2417	if (shouldBrowseForProjectImmediately) {
1336	title: `Failed to remove "${project.name}"`,	2418	toastManager.add({
1337	description: message,	2419	type: "error",
1338	});	2420	title: "Failed to add project",
		2421	description,
		2422	});
		2423	} else {
		2424	setAddProjectError(description);
		2425	}
		2426	return;
1339	}	2427	}
		2428	finishAddingProject();
1340	},	2429	},
1341	[	2430	[
1342	clearComposerDraftForThread,	2431	focusMostRecentThreadForProject,
1343	clearProjectDraftThreadId,	2432	activeEnvironmentId,
1344	copyPathToClipboard,	2433	handleNewThread,
1345	getDraftThreadByProjectId,	2434	isAddingProject,
1346	projects,	2435	projects,
1347	threadIdsByProjectId,	2436	shouldBrowseForProjectImmediately,
		2437	appSettings.defaultThreadEnvMode,
1348	],	2438	],
1349	);	2439	);
1350		2440
		2441	const handleAddProject = () => {
		2442	void addProjectFromPath(newCwd);
		2443	};
		2444
		2445	const canAddProject = newCwd.trim().length > 0 && !isAddingProject;
		2446
		2447	const handlePickFolder = async () => {
		2448	const api = readLocalApi();
		2449	if (!api \|\| isPickingFolder) return;
		2450	setIsPickingFolder(true);
		2451	let pickedPath: string \| null = null;
		2452	try {
		2453	pickedPath = await api.dialogs.pickFolder();
		2454	} catch {
		2455	// Ignore picker failures and leave the current thread selection unchanged.
		2456	}
		2457	if (pickedPath) {
		2458	await addProjectFromPath(pickedPath);
		2459	} else if (!shouldBrowseForProjectImmediately) {
		2460	addProjectInputRef.current?.focus();
		2461	}
		2462	setIsPickingFolder(false);
		2463	};
		2464
		2465	const handleStartAddProject = () => {
		2466	setAddProjectError(null);
		2467	if (shouldBrowseForProjectImmediately) {
		2468	void handlePickFolder();
		2469	return;
		2470	}
		2471	setAddingProject((prev) => !prev);
		2472	};
		2473
		2474	const navigateToThread = useCallback(
		2475	(threadRef: ScopedThreadRef) => {
		2476	if (useThreadSelectionStore.getState().selectedThreadKeys.size > 0) {
		2477	clearSelection();
		2478	}
		2479	setSelectionAnchor(scopedThreadKey(threadRef));
		2480	void navigate({
		2481	to: "/$environmentId/$threadId",
		2482	params: buildThreadRouteParams(threadRef),
		2483	});
		2484	},
		2485	[clearSelection, navigate, setSelectionAnchor],
		2486	);
		2487
1351	const projectDnDSensors = useSensors(	2488	const projectDnDSensors = useSensors(
1352	useSensor(PointerSensor, {	2489	useSensor(PointerSensor, {
1353	activationConstraint: { distance: 6 },	2490	activationConstraint: { distance: 6 },
@@ -1371,10 +2508,10 @@ export default function Sidebar() { · 17 unmodified lines
1371	dragInProgressRef.current = false;	2508	dragInProgressRef.current = false;
1372	const { active, over } = event;	2509	const { active, over } = event;
1373	if (!over \|\| active.id === over.id) return;	2510	if (!over \|\| active.id === over.id) return;
1374	const activeProject = sidebarProjects.find((project) => project.id === active.id);	2511	const activeProject = sidebarProjects.find((project) => project.projectKey === active.id);
1375	const overProject = sidebarProjects.find((project) => project.id === over.id);	2512	const overProject = sidebarProjects.find((project) => project.projectKey === over.id);
1376	if (!activeProject \|\| !overProject) return;	2513	if (!activeProject \|\| !overProject) return;
1377	reorderProjects(activeProject.id, overProject.id);	2514	reorderProjects(activeProject.projectKey, overProject.projectKey);
1378	},	2515	},
1379	[appSettings.sidebarProjectSortOrder, reorderProjects, sidebarProjects],	2516	[appSettings.sidebarProjectSortOrder, reorderProjects, sidebarProjects],
1380	);	2517	);
@@ -1412,148 +2549,117 @@ export default function Sidebar() { · 31 unmodified lines
1412	animatedThreadListsRef.current.add(node);	2549	animatedThreadListsRef.current.add(node);
1413	}, []);	2550	}, []);
1414		2551
1415	const handleProjectTitlePointerDownCapture = useCallback(
1416	(event: PointerEvent<HTMLButtonElement>) => {
1417	suppressProjectClickForContextMenuRef.current = false;
1418	if (
1419	isContextMenuPointerDown({
1420	button: event.button,
1421	ctrlKey: event.ctrlKey,
1422	isMac: isMacPlatform(navigator.platform),
1423	})
1424	) {
1425	// Keep context-menu gestures from arming the sortable drag sensor.
1426	event.stopPropagation();
1427	}
1428
1429	suppressProjectClickAfterDragRef.current = false;
1430	},
1431	[],
1432	);
1433
1434	const visibleThreads = useMemo(	2552	const visibleThreads = useMemo(
1435	() => sidebarThreads.filter((thread) => thread.archivedAt === null),	2553	() => sidebarThreads.filter((thread) => thread.archivedAt === null),
1436	[sidebarThreads],	2554	[sidebarThreads],
1437	);	2555	);
1438	const sortedProjects = useMemo(	2556	const sortedProjects = useMemo(() => {
1439	() =>	2557	const sortableProjects = sidebarProjects.map((project) => ({
1440	sortProjectsForSidebar(sidebarProjects, visibleThreads, appSettings.sidebarProjectSortOrder),	2558	...project,
1441	[appSettings.sidebarProjectSortOrder, sidebarProjects, visibleThreads],	2559	id: project.projectKey,
1442	);	2560	}));
		2561	const sortableThreads = visibleThreads.map((thread) => ({
		2562	...thread,
		2563	projectId: scopedProjectKey(
		2564	scopeProjectRef(thread.environmentId, thread.projectId),
		2565	) as ProjectId,
		2566	}));
		2567	return sortProjectsForSidebar(
		2568	sortableProjects,
		2569	sortableThreads,
		2570	appSettings.sidebarProjectSortOrder,
		2571	).flatMap((project) => {
		2572	const resolvedProject = sidebarProjectByKey.get(project.id);
		2573	return resolvedProject ? [resolvedProject] : [];
		2574	});
		2575	}, [appSettings.sidebarProjectSortOrder, sidebarProjectByKey, sidebarProjects, visibleThreads]);
1443	const isManualProjectSorting = appSettings.sidebarProjectSortOrder === "manual";	2576	const isManualProjectSorting = appSettings.sidebarProjectSortOrder === "manual";
1444	const renderedProjects = useMemo(	2577	const visibleSidebarThreadKeys = useMemo(
1445	() =>	2578	() =>
1446	sortedProjects.map((project) => {	2579	sortedProjects.flatMap((project) => {
1447	const resolveProjectThreadStatus = (thread: (typeof visibleThreads)[number]) =>
1448	resolveThreadStatusPill({
1449	thread: {
1450	...thread,
1451	lastVisitedAt: threadLastVisitedAtById[thread.id],
1452	},
1453	});
1454	const projectThreads = sortThreadsForSidebar(	2580	const projectThreads = sortThreadsForSidebar(
1455	(threadIdsByProjectId[project.id] ?? [])	2581	(threadsByProjectKey.get(project.projectKey) ?? []).filter(
1456	.map((threadId) => sidebarThreadsById[threadId])	2582	(thread) => thread.archivedAt === null,
1457	.filter((thread): thread is NonNullable<typeof thread> => thread !== undefined)	2583	),
1458	.filter((thread) => thread.archivedAt === null),
1459	appSettings.sidebarThreadSortOrder,	2584	appSettings.sidebarThreadSortOrder,
1460	);	2585	);
1461	const projectStatus = resolveProjectStatusIndicator(	2586	const projectExpanded = projectExpandedById[project.projectKey] ?? true;
1462	projectThreads.map((thread) => resolveProjectThreadStatus(thread)),	2587	const activeThreadKey = routeThreadKey ?? undefined;
1463	);
1464	const activeThreadId = routeThreadId ?? undefined;
1465	const isThreadListExpanded = expandedThreadListsByProject.has(project.id);
1466	const pinnedCollapsedThread =	2588	const pinnedCollapsedThread =
1467	!project.expanded && activeThreadId	2589	!projectExpanded && activeThreadKey
1468	? (projectThreads.find((thread) => thread.id === activeThreadId) ?? null)	2590	? (projectThreads.find(
		2591	(thread) =>
		2592	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)) ===
		2593	activeThreadKey,
		2594	) ?? null)
1469	: null;	2595	: null;
1470	const shouldShowThreadPanel = project.expanded \|\| pinnedCollapsedThread !== null;	2596	const shouldShowThreadPanel = projectExpanded \|\| pinnedCollapsedThread !== null;
1471	const {	2597	if (!shouldShowThreadPanel) {
1472	hasHiddenThreads,	2598	return [];
1473	hiddenThreads,	2599	}
1474	visibleThreads: visibleProjectThreads,	2600	const isThreadListExpanded = expandedThreadListsByProject.has(project.projectKey);
1475	} = getVisibleThreadsForProject({	2601	const hasOverflowingThreads = projectThreads.length > THREAD_PREVIEW_LIMIT;
1476	threads: projectThreads,	2602	const previewThreads =
1477	activeThreadId,	2603	isThreadListExpanded \|\| !hasOverflowingThreads
1478	isThreadListExpanded,	2604	? projectThreads
1479	previewLimit: THREAD_PREVIEW_LIMIT,	2605	: projectThreads.slice(0, THREAD_PREVIEW_LIMIT);
1480	});	2606	const renderedThreads = pinnedCollapsedThread ? [pinnedCollapsedThread] : previewThreads;
1481	const hiddenThreadStatus = resolveProjectStatusIndicator(	2607	return renderedThreads.map((thread) =>
1482	hiddenThreads.map((thread) => resolveProjectThreadStatus(thread)),	2608	scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
1483	);	2609	);
1484	const orderedProjectThreadIds = projectThreads.map((thread) => thread.id);
1485	const renderedThreadIds = pinnedCollapsedThread
1486	? [pinnedCollapsedThread.id]
1487	: visibleProjectThreads.map((thread) => thread.id);
1488	const showEmptyThreadState = project.expanded && projectThreads.length === 0;
1489
1490	return {
1491	hasHiddenThreads,
1492	hiddenThreadStatus,
1493	orderedProjectThreadIds,
1494	project,
1495	projectStatus,
1496	renderedThreadIds,
1497	showEmptyThreadState,
1498	shouldShowThreadPanel,
1499	isThreadListExpanded,
1500	};
1501	}),	2610	}),
1502	[	2611	[
1503	appSettings.sidebarThreadSortOrder,	2612	appSettings.sidebarThreadSortOrder,
1504	expandedThreadListsByProject,	2613	expandedThreadListsByProject,
1505	routeThreadId,	2614	projectExpandedById,
		2615	routeThreadKey,
1506	sortedProjects,	2616	sortedProjects,
1507	sidebarThreadsById,	2617	threadsByProjectKey,
1508	threadIdsByProjectId,
1509	threadLastVisitedAtById,
1510	],	2618	],
1511	);	2619	);
1512	const visibleSidebarThreadIds = useMemo(	2620	const threadJumpCommandByKey = useMemo(() => {
1513	() => getVisibleSidebarThreadIds(renderedProjects),	2621	const mapping = new Map<string, NonNullable<ReturnType<typeof threadJumpCommandForIndex>>>();
1514	[renderedProjects],	2622	for (const [visibleThreadIndex, threadKey] of visibleSidebarThreadKeys.entries()) {
1515	);
1516	const threadJumpCommandById = useMemo(() => {
1517	const mapping = new Map<ThreadId, NonNullable<ReturnType<typeof threadJumpCommandForIndex>>>();
1518	for (const [visibleThreadIndex, threadId] of visibleSidebarThreadIds.entries()) {
1519	const jumpCommand = threadJumpCommandForIndex(visibleThreadIndex);	2623	const jumpCommand = threadJumpCommandForIndex(visibleThreadIndex);
1520	if (!jumpCommand) {	2624	if (!jumpCommand) {
1521	return mapping;	2625	return mapping;
1522	}	2626	}
1523	mapping.set(threadId, jumpCommand);	2627	mapping.set(threadKey, jumpCommand);
1524	}	2628	}
1525		2629
1526	return mapping;	2630	return mapping;
1527	}, [visibleSidebarThreadIds]);	2631	}, [visibleSidebarThreadKeys]);
1528	const threadJumpThreadIds = useMemo(	2632	const threadJumpThreadKeys = useMemo(
1529	() => [...threadJumpCommandById.keys()],	2633	() => [...threadJumpCommandByKey.keys()],
1530	[threadJumpCommandById],	2634	[threadJumpCommandByKey],
1531	);	2635	);
1532	const threadJumpLabelById = useMemo(() => {	2636	const [threadJumpLabelByKey, setThreadJumpLabelByKey] =
1533	const mapping = new Map<ThreadId, string>();	2637	useState<ReadonlyMap<string, string>>(EMPTY_THREAD_JUMP_LABELS);
1534	for (const [threadId, command] of threadJumpCommandById) {	2638	const visibleThreadJumpLabelByKey = showThreadJumpHints
1535	const label = shortcutLabelForCommand(keybindings, command, sidebarShortcutLabelOptions);	2639	? threadJumpLabelByKey
1536	if (label) {	2640	: EMPTY_THREAD_JUMP_LABELS;
1537	mapping.set(threadId, label);	2641	const orderedSidebarThreadKeys = visibleSidebarThreadKeys;
1538	}
1539	}
1540	return mapping;
1541	}, [keybindings, sidebarShortcutLabelOptions, threadJumpCommandById]);
1542	const orderedSidebarThreadIds = visibleSidebarThreadIds;
1543		2642
1544	useEffect(() => {	2643	useEffect(() => {
1545	const getShortcutContext = () => ({
1546	terminalFocus: isTerminalFocused(),
1547	terminalOpen: routeTerminalOpen,
1548	});
1549
1550	const onWindowKeyDown = (event: globalThis.KeyboardEvent) => {	2644	const onWindowKeyDown = (event: globalThis.KeyboardEvent) => {
1551	updateThreadJumpHintsVisibility(	2645	const shortcutContext = getCurrentSidebarShortcutContext();
1552	shouldShowThreadJumpHints(event, keybindings, {	2646	const shouldShowHints = shouldShowThreadJumpHints(event, keybindings, {
		2647	platform,
		2648	context: shortcutContext,
		2649	});
		2650	setThreadJumpLabelByKey((current) => {
		2651	if (!shouldShowHints) {
		2652	return current === EMPTY_THREAD_JUMP_LABELS ? current : EMPTY_THREAD_JUMP_LABELS;
		2653	}
		2654	const nextLabelMap = buildThreadJumpLabelMap({
		2655	keybindings,
1553	platform,	2656	platform,
1554	context: getShortcutContext(),	2657	terminalOpen: shortcutContext.terminalOpen,
1555	}),	2658	threadJumpCommandByKey,
1556	);	2659	});
		2660	return threadJumpLabelMapsEqual(current, nextLabelMap) ? current : nextLabelMap;
		2661	});
		2662	updateThreadJumpHintsVisibility(shouldShowHints);
1557		2663
1558	if (event.defaultPrevented \|\| event.repeat) {	2664	if (event.defaultPrevented \|\| event.repeat) {
1559	return;	2665	return;
@@ -1561,22 +2667,26 @@ export default function Sidebar() { · 1 unmodified line
1561		2667
1562	const command = resolveShortcutCommand(event, keybindings, {	2668	const command = resolveShortcutCommand(event, keybindings, {
1563	platform,	2669	platform,
1564	context: getShortcutContext(),	2670	context: shortcutContext,
1565	});	2671	});
1566	const traversalDirection = threadTraversalDirectionFromCommand(command);	2672	const traversalDirection = threadTraversalDirectionFromCommand(command);
1567	if (traversalDirection !== null) {	2673	if (traversalDirection !== null) {
1568	const targetThreadId = resolveAdjacentThreadId({	2674	const targetThreadKey = resolveAdjacentThreadId({
1569	threadIds: orderedSidebarThreadIds,	2675	threadIds: orderedSidebarThreadKeys,
1570	currentThreadId: routeThreadId,	2676	currentThreadId: routeThreadKey,
1571	direction: traversalDirection,	2677	direction: traversalDirection,
1572	});	2678	});
1573	if (!targetThreadId) {	2679	if (!targetThreadKey) {
		2680	return;
		2681	}
		2682	const targetThread = sidebarThreadByKey.get(targetThreadKey);
		2683	if (!targetThread) {
1574	return;	2684	return;
1575	}	2685	}
1576		2686
1577	event.preventDefault();	2687	event.preventDefault();
1578	event.stopPropagation();	2688	event.stopPropagation();
1579	navigateToThread(targetThreadId);	2689	navigateToThread(scopeThreadRef(targetThread.environmentId, targetThread.id));
1580	return;	2690	return;
1581	}	2691	}
1582		2692
@@ -1585,26 +2695,45 @@ export default function Sidebar() { · 2 unmodified lines
1585	return;	2695	return;
1586	}	2696	}
1587		2697
1588	const targetThreadId = threadJumpThreadIds[jumpIndex];	2698	const targetThreadKey = threadJumpThreadKeys[jumpIndex];
1589	if (!targetThreadId) {	2699	if (!targetThreadKey) {
		2700	return;
		2701	}
		2702	const targetThread = sidebarThreadByKey.get(targetThreadKey);
		2703	if (!targetThread) {
1590	return;	2704	return;
1591	}	2705	}
1592		2706
1593	event.preventDefault();	2707	event.preventDefault();
1594	event.stopPropagation();	2708	event.stopPropagation();
1595	navigateToThread(targetThreadId);	2709	navigateToThread(scopeThreadRef(targetThread.environmentId, targetThread.id));
1596	};	2710	};
1597		2711
1598	const onWindowKeyUp = (event: globalThis.KeyboardEvent) => {	2712	const onWindowKeyUp = (event: globalThis.KeyboardEvent) => {
1599	updateThreadJumpHintsVisibility(	2713	const shortcutContext = getCurrentSidebarShortcutContext();
1600	shouldShowThreadJumpHints(event, keybindings, {	2714	const shouldShowHints = shouldShowThreadJumpHints(event, keybindings, {
		2715	platform,
		2716	context: shortcutContext,
		2717	});
		2718	setThreadJumpLabelByKey((current) => {
		2719	if (!shouldShowHints) {
		2720	return current === EMPTY_THREAD_JUMP_LABELS ? current : EMPTY_THREAD_JUMP_LABELS;
		2721	}
		2722	const nextLabelMap = buildThreadJumpLabelMap({
		2723	keybindings,
1601	platform,	2724	platform,
1602	context: getShortcutContext(),	2725	terminalOpen: shortcutContext.terminalOpen,
1603	}),	2726	threadJumpCommandByKey,
1604	);	2727	});
		2728	return threadJumpLabelMapsEqual(current, nextLabelMap) ? current : nextLabelMap;
		2729	});
		2730	updateThreadJumpHintsVisibility(shouldShowHints);
1605	};	2731	};
1606		2732
1607	const onWindowBlur = () => {	2733	const onWindowBlur = () => {
		2734	setThreadJumpLabelByKey((current) =>
		2735	current === EMPTY_THREAD_JUMP_LABELS ? current : EMPTY_THREAD_JUMP_LABELS,
		2736	);
1608	updateThreadJumpHintsVisibility(false);	2737	updateThreadJumpHintsVisibility(false);
1609	};	2738	};
1610		2739
@@ -1618,301 +2747,21 @@ export default function Sidebar() { · 7 unmodified lines
1618	window.removeEventListener("blur", onWindowBlur);	2747	window.removeEventListener("blur", onWindowBlur);
1619	};	2748	};
1620	}, [	2749	}, [
		2750	getCurrentSidebarShortcutContext,
1621	keybindings,	2751	keybindings,
1622	navigateToThread,	2752	navigateToThread,
1623	orderedSidebarThreadIds,	2753	orderedSidebarThreadKeys,
1624	platform,	2754	platform,
1625	routeTerminalOpen,	2755	routeThreadKey,
1626	routeThreadId,	2756	sidebarThreadByKey,
1627	threadJumpThreadIds,	2757	threadJumpCommandByKey,
		2758	threadJumpThreadKeys,
1628	updateThreadJumpHintsVisibility,	2759	updateThreadJumpHintsVisibility,
1629	]);	2760	]);
1630		2761
1631	function renderProjectItem(
1632	renderedProject: (typeof renderedProjects)[number],
1633	dragHandleProps: SortableProjectHandleProps \| null,
1634	) {
1635	const {
1636	hasHiddenThreads,
1637	hiddenThreadStatus,
1638	orderedProjectThreadIds,
1639	project,
1640	projectStatus,
1641	renderedThreadIds,
1642	showEmptyThreadState,
1643	shouldShowThreadPanel,
1644	isThreadListExpanded,
1645	} = renderedProject;
1646	return (
1647	<>
1648	<div className="group/project-header relative">
1649	<SidebarMenuButton
1650	ref={isManualProjectSorting ? dragHandleProps?.setActivatorNodeRef : undefined}
1651	size="sm"
1652	className={`gap-2 px-2 py-1.5 text-left hover:bg-accent group-hover/project-header:bg-accent group-hover/project-header:text-sidebar-accent-foreground ${
1653	isManualProjectSorting ? "cursor-grab active:cursor-grabbing" : "cursor-pointer"
1654	}`}
1655	{...(isManualProjectSorting && dragHandleProps ? dragHandleProps.attributes : {})}
1656	{...(isManualProjectSorting && dragHandleProps ? dragHandleProps.listeners : {})}
1657	onPointerDownCapture={handleProjectTitlePointerDownCapture}
1658	onClick={(event) => handleProjectTitleClick(event, project.id)}
1659	onKeyDown={(event) => handleProjectTitleKeyDown(event, project.id)}
1660	onContextMenu={(event) => {
1661	event.preventDefault();
1662	suppressProjectClickForContextMenuRef.current = true;
1663	void handleProjectContextMenu(project.id, {
1664	x: event.clientX,
1665	y: event.clientY,
1666	});
1667	}}
1668	>
1669	{!project.expanded && projectStatus ? (
1670	<span
1671	aria-hidden="true"
1672	title={projectStatus.label}
1673	className={`-ml-0.5 relative inline-flex size-3.5 shrink-0 items-center justify-center ${projectStatus.colorClass}`}
1674	>
1675	<span className="absolute inset-0 flex items-center justify-center transition-opacity duration-150 group-hover/project-header:opacity-0">
1676	<span
1677	className={`size-[9px] rounded-full ${projectStatus.dotClass} ${
1678	projectStatus.pulse ? "animate-pulse" : ""
1679	}`}
1680	/>
1681	</span>
1682	<ChevronRightIcon className="absolute inset-0 m-auto size-3.5 text-muted-foreground/70 opacity-0 transition-opacity duration-150 group-hover/project-header:opacity-100" />
1683	</span>
1684	) : (
1685	<ChevronRightIcon
1686	className={`-ml-0.5 size-3.5 shrink-0 text-muted-foreground/70 transition-transform duration-150 ${
1687	project.expanded ? "rotate-90" : ""
1688	}`}
1689	/>
1690	)}
1691	<ProjectFavicon cwd={project.cwd} />
1692	{renamingProjectId === project.id ? (
1693	<input
1694	ref={(element) => {
1695	if (element && projectRenamingInputRef.current !== element) {
1696	projectRenamingInputRef.current = element;
1697	element.focus();
1698	element.select();
1699	}
1700	}}
1701	className="min-w-0 flex-1 truncate rounded border border-ring bg-transparent px-0.5 text-xs font-medium text-foreground/90 outline-none"
1702	value={renamingProjectTitle}
1703	onChange={(event) => setRenamingProjectTitle(event.target.value)}
1704	onKeyDown={(event) => {
1705	event.stopPropagation();
1706	if (event.key === "Enter") {
1707	event.preventDefault();
1708	projectRenamingCommittedRef.current = true;
1709	void commitProjectRename(project.id, renamingProjectTitle, project.name);
1710	} else if (event.key === "Escape") {
1711	event.preventDefault();
1712	projectRenamingCommittedRef.current = true;
1713	cancelProjectRename();
1714	}
1715	}}
1716	onBlur={() => {
1717	if (!projectRenamingCommittedRef.current) {
1718	void commitProjectRename(project.id, renamingProjectTitle, project.name);
1719	}
1720	}}
1721	onClick={(event) => event.stopPropagation()}
1722	onPointerDown={(event) => event.stopPropagation()}
1723	/>
1724	) : (
1725	<span className="flex-1 truncate text-xs font-medium text-foreground/90">
1726	{project.name}
1727	</span>
1728	)}
1729	</SidebarMenuButton>
1730	<Tooltip>
1731	<TooltipTrigger
1732	render={
1733	<SidebarMenuAction
1734	render={
1735	<button
1736	type="button"
1737	aria-label={`Create new thread in ${project.name}`}
1738	data-testid="new-thread-button"
1739	/>
1740	}
1741	showOnHover
1742	className="top-1 right-1.5 size-5 rounded-md p-0 text-muted-foreground/70 hover:bg-secondary hover:text-foreground"
1743	onClick={(event) => {
1744	event.preventDefault();
1745	event.stopPropagation();
1746	const seedContext = resolveSidebarNewThreadSeedContext({
1747	projectId: project.id,
1748	defaultEnvMode: resolveSidebarNewThreadEnvMode({
1749	defaultEnvMode: appSettings.defaultThreadEnvMode,
1750	}),
1751	activeThread:
1752	activeThread && activeThread.projectId === project.id
1753	? {
1754	projectId: activeThread.projectId,
1755	branch: activeThread.branch,
1756	worktreePath: activeThread.worktreePath,
1757	}
1758	: null,
1759	activeDraftThread:
1760	activeDraftThread && activeDraftThread.projectId === project.id
1761	? {
1762	projectId: activeDraftThread.projectId,
1763	branch: activeDraftThread.branch,
1764	worktreePath: activeDraftThread.worktreePath,
1765	envMode: activeDraftThread.envMode,
1766	}
1767	: null,
1768	});
1769	void handleNewThread(project.id, {
1770	...(seedContext.branch !== undefined ? { branch: seedContext.branch } : {}),
1771	...(seedContext.worktreePath !== undefined
1772	? { worktreePath: seedContext.worktreePath }
1773	: {}),
1774	envMode: seedContext.envMode,
1775	});
1776	}}
1777	>
1778	<SquarePenIcon className="size-3.5" />
1779	</SidebarMenuAction>
1780	}
1781	/>
1782	<TooltipPopup side="top">
1783	{newThreadShortcutLabel ? `New thread (${newThreadShortcutLabel})` : "New thread"}
1784	</TooltipPopup>
1785	</Tooltip>
1786	</div>
1787
1788	<SidebarMenuSub
1789	ref={attachThreadListAutoAnimateRef}
1790	className="mx-1 my-0 w-full translate-x-0 gap-0.5 overflow-hidden px-1.5 py-0"
1791	>
1792	{shouldShowThreadPanel && showEmptyThreadState ? (
1793	<SidebarMenuSubItem className="w-full" data-thread-selection-safe>
1794	<div
1795	data-thread-selection-safe
1796	className="flex h-6 w-full translate-x-0 items-center px-2 text-left text-[10px] text-muted-foreground/60"
1797	>
1798	<span>No threads yet</span>
1799	</div>
1800	</SidebarMenuSubItem>
1801	) : null}
1802	{shouldShowThreadPanel &&
1803	renderedThreadIds.map((threadId) => (
1804	<SidebarThreadRow
1805	key={threadId}
1806	threadId={threadId}
1807	projectCwd={project.cwd}
1808	orderedProjectThreadIds={orderedProjectThreadIds}
1809	routeThreadId={routeThreadId}
1810	selectedThreadIds={selectedThreadIds}
1811	showThreadJumpHints={showThreadJumpHints}
1812	jumpLabel={threadJumpLabelById.get(threadId) ?? null}
1813	appSettingsConfirmThreadArchive={appSettings.confirmThreadArchive}
1814	renamingThreadId={renamingThreadId}
1815	renamingTitle={renamingTitle}
1816	setRenamingTitle={setRenamingTitle}
1817	onRenamingInputMount={handleRenamingInputMount}
1818	hasRenameCommitted={hasRenameCommitted}
1819	markRenameCommitted={markRenameCommitted}
1820	confirmingArchiveThreadId={confirmingArchiveThreadId}
1821	setConfirmingArchiveThreadId={setConfirmingArchiveThreadId}
1822	confirmArchiveButtonRefs={confirmArchiveButtonRefs}
1823	handleThreadClick={handleThreadClick}
1824	navigateToThread={navigateToThread}
1825	handleMultiSelectContextMenu={handleMultiSelectContextMenu}
1826	handleThreadContextMenu={handleThreadContextMenu}
1827	clearSelection={clearSelection}
1828	commitRename={commitRename}
1829	cancelRename={cancelRename}
1830	attemptArchiveThread={attemptArchiveThread}
1831	openPrLink={openPrLink}
1832	/>
1833	))}
1834
1835	{project.expanded && hasHiddenThreads && !isThreadListExpanded && (
1836	<SidebarMenuSubItem className="w-full">
1837	<SidebarMenuSubButton
1838	render={<button type="button" />}
1839	data-thread-selection-safe
1840	size="sm"
1841	className="h-6 w-full translate-x-0 justify-start px-2 text-left text-[10px] text-muted-foreground/60 hover:bg-accent hover:text-muted-foreground/80"
1842	onClick={() => {
1843	expandThreadListForProject(project.id);
1844	}}
1845	>
1846	<span className="flex min-w-0 flex-1 items-center gap-2">
1847	{hiddenThreadStatus && <ThreadStatusLabel status={hiddenThreadStatus} compact />}
1848	<span>Show more</span>
1849	</span>
1850	</SidebarMenuSubButton>
1851	</SidebarMenuSubItem>
1852	)}
1853	{project.expanded && hasHiddenThreads && isThreadListExpanded && (
1854	<SidebarMenuSubItem className="w-full">
1855	<SidebarMenuSubButton
1856	render={<button type="button" />}
1857	data-thread-selection-safe
1858	size="sm"
1859	className="h-6 w-full translate-x-0 justify-start px-2 text-left text-[10px] text-muted-foreground/60 hover:bg-accent hover:text-muted-foreground/80"
1860	onClick={() => {
1861	collapseThreadListForProject(project.id);
1862	}}
1863	>
1864	<span>Show less</span>
1865	</SidebarMenuSubButton>
1866	</SidebarMenuSubItem>
1867	)}
1868	</SidebarMenuSub>
1869	</>
1870	);
1871	}
1872
1873	const handleProjectTitleClick = useCallback(
1874	(event: MouseEvent<HTMLButtonElement>, projectId: ProjectId) => {
1875	if (suppressProjectClickForContextMenuRef.current) {
1876	suppressProjectClickForContextMenuRef.current = false;
1877	event.preventDefault();
1878	event.stopPropagation();
1879	return;
1880	}
1881	if (dragInProgressRef.current) {
1882	event.preventDefault();
1883	event.stopPropagation();
1884	return;
1885	}
1886	if (suppressProjectClickAfterDragRef.current) {
1887	// Consume the synthetic click emitted after a drag release.
1888	suppressProjectClickAfterDragRef.current = false;
1889	event.preventDefault();
1890	event.stopPropagation();
1891	return;
1892	}
1893	if (selectedThreadIds.size > 0) {
1894	clearSelection();
1895	}
1896	toggleProject(projectId);
1897	},
1898	[clearSelection, selectedThreadIds.size, toggleProject],
1899	);
1900
1901	const handleProjectTitleKeyDown = useCallback(
1902	(event: KeyboardEvent<HTMLButtonElement>, projectId: ProjectId) => {
1903	if (event.key !== "Enter" && event.key !== " ") return;
1904	event.preventDefault();
1905	if (dragInProgressRef.current) {
1906	return;
1907	}
1908	toggleProject(projectId);
1909	},
1910	[toggleProject],
1911	);
1912
1913	useEffect(() => {	2762	useEffect(() => {
1914	const onMouseDown = (event: globalThis.MouseEvent) => {	2763	const onMouseDown = (event: globalThis.MouseEvent) => {
1915	if (selectedThreadIds.size === 0) return;	2764	if (selectedThreadCount === 0) return;
1916	const target = event.target instanceof HTMLElement ? event.target : null;	2765	const target = event.target instanceof HTMLElement ? event.target : null;
1917	if (!shouldClearThreadSelectionOnMouseDown(target)) return;	2766	if (!shouldClearThreadSelectionOnMouseDown(target)) return;
1918	clearSelection();	2767	clearSelection();
@@ -1922,7 +2771,7 @@ export default function Sidebar() { · 3 unmodified lines
1922	return () => {	2771	return () => {
1923	window.removeEventListener("mousedown", onMouseDown);	2772	window.removeEventListener("mousedown", onMouseDown);
1924	};	2773	};
1925	}, [clearSelection, selectedThreadIds.size]);	2774	}, [clearSelection, selectedThreadCount]);
1926		2775
1927	useEffect(() => {	2776	useEffect(() => {
1928	if (!isElectron) return;	2777	if (!isElectron) return;
@@ -1967,10 +2816,6 @@ export default function Sidebar() { · 38 unmodified lines
1967	desktopUpdateState && showArm64IntelBuildWarning	2816	desktopUpdateState && showArm64IntelBuildWarning
1968	? getArm64IntelBuildWarningDescription(desktopUpdateState)	2817	? getArm64IntelBuildWarningDescription(desktopUpdateState)
1969	: null;	2818	: null;
1970	const newThreadShortcutLabel =
1971	shortcutLabelForCommand(keybindings, "chat.newLocal", sidebarShortcutLabelOptions) ??
1972	shortcutLabelForCommand(keybindings, "chat.new", sidebarShortcutLabelOptions);
1973
1974	const handleDesktopUpdateButtonClick = useCallback(() => {	2819	const handleDesktopUpdateButtonClick = useCallback(() => {
1975	const bridge = window.desktopBridge;	2820	const bridge = window.desktopBridge;
1976	if (!bridge \|\| !desktopUpdateState) return;	2821	if (!bridge \|\| !desktopUpdateState) return;
@@ -2033,246 +2878,82 @@ export default function Sidebar() { · 56 unmodified lines
2033	}	2878	}
2034	}, [desktopUpdateButtonAction, desktopUpdateButtonDisabled, desktopUpdateState]);	2879	}, [desktopUpdateButtonAction, desktopUpdateButtonDisabled, desktopUpdateState]);
2035		2880
2036	const expandThreadListForProject = useCallback((projectId: ProjectId) => {	2881	const expandThreadListForProject = useCallback((projectKey: string) => {
2037	setExpandedThreadListsByProject((current) => {	2882	setExpandedThreadListsByProject((current) => {
2038	if (current.has(projectId)) return current;	2883	if (current.has(projectKey)) return current;
2039	const next = new Set(current);	2884	const next = new Set(current);
2040	next.add(projectId);	2885	next.add(projectKey);
2041	return next;	2886	return next;
2042	});	2887	});
2043	}, []);	2888	}, []);
2044		2889
2045	const collapseThreadListForProject = useCallback((projectId: ProjectId) => {	2890	const collapseThreadListForProject = useCallback((projectKey: string) => {
2046	setExpandedThreadListsByProject((current) => {	2891	setExpandedThreadListsByProject((current) => {
2047	if (!current.has(projectId)) return current;	2892	if (!current.has(projectKey)) return current;
2048	const next = new Set(current);	2893	const next = new Set(current);
2049	next.delete(projectId);	2894	next.delete(projectKey);
2050	return next;	2895	return next;
2051	});	2896	});
2052	}, []);	2897	}, []);
2053		2898
2054	const wordmark = (
2055	<div className="flex items-center gap-2">
2056	<SidebarTrigger className="shrink-0 md:hidden" />
2057	<Tooltip>
2058	<TooltipTrigger
2059	render={
2060	<Link
2061	aria-label="Go to threads"
2062	className="ml-1 flex min-w-0 flex-1 cursor-pointer items-center gap-1 rounded-md outline-hidden ring-ring transition-colors hover:text-foreground focus-visible:ring-2"
2063	to="/"
2064	>
2065	<T3Wordmark />
2066	<span className="truncate text-sm font-medium tracking-tight text-muted-foreground">
2067	Code
2068	</span>
2069	<span className="rounded-full bg-muted/50 px-1.5 py-0.5 text-[8px] font-medium uppercase tracking-[0.18em] text-muted-foreground/60">
2070	{APP_STAGE_LABEL}
2071	</span>
2072	</Link>
2073	}
2074	/>
2075	<TooltipPopup side="bottom" sideOffset={2}>
2076	Version {APP_VERSION}
2077	</TooltipPopup>
2078	</Tooltip>
2079	</div>
2080	);
2081
2082	return (	2899	return (
2083	<>	2900	<>
2084	{isElectron ? (	2901	<SidebarChromeHeader isElectron={isElectron} />
2085	<SidebarHeader className="drag-region h-[52px] flex-row items-center gap-2 px-4 py-0 pl-[90px]">
2086	{wordmark}
2087	</SidebarHeader>
2088	) : (
2089	<SidebarHeader className="gap-3 px-3 py-2 sm:gap-2.5 sm:px-4 sm:py-3">
2090	{wordmark}
2091	</SidebarHeader>
2092	)}
2093		2902
2094	{isOnSettings ? (	2903	{isOnSettings ? (
2095	<SettingsSidebarNav pathname={pathname} />	2904	<SettingsSidebarNav pathname={pathname} />
2096	) : (	2905	) : (
2097	<>	2906	<>
2098	<SidebarContent className="gap-0">	2907	<SidebarProjectsContent
2099	{showArm64IntelBuildWarning && arm64IntelBuildWarningDescription ? (	2908	showArm64IntelBuildWarning={showArm64IntelBuildWarning}
2100	<SidebarGroup className="px-2 pt-2 pb-0">	2909	arm64IntelBuildWarningDescription={arm64IntelBuildWarningDescription}
2101	<Alert variant="warning" className="rounded-2xl border-warning/40 bg-warning/8">	2910	desktopUpdateButtonAction={desktopUpdateButtonAction}
2102	<TriangleAlertIcon />	2911	desktopUpdateButtonDisabled={desktopUpdateButtonDisabled}
2103	<AlertTitle>Intel build on Apple Silicon</AlertTitle>	2912	handleDesktopUpdateButtonClick={handleDesktopUpdateButtonClick}
2104	<AlertDescription>{arm64IntelBuildWarningDescription}</AlertDescription>	2913	projectSortOrder={appSettings.sidebarProjectSortOrder}
2105	{desktopUpdateButtonAction !== "none" ? (	2914	threadSortOrder={appSettings.sidebarThreadSortOrder}
2106	<AlertAction>	2915	updateSettings={updateSettings}
2107	<Button	2916	shouldShowProjectPathEntry={shouldShowProjectPathEntry}
2108	size="xs"	2917	handleStartAddProject={handleStartAddProject}
2109	variant="outline"	2918	isElectron={isElectron}
2110	disabled={desktopUpdateButtonDisabled}	2919	isPickingFolder={isPickingFolder}
2111	onClick={handleDesktopUpdateButtonClick}	2920	isAddingProject={isAddingProject}
2112	>	2921	handlePickFolder={handlePickFolder}
2113	{desktopUpdateButtonAction === "download"	2922	addProjectInputRef={addProjectInputRef}
2114	? "Download ARM build"	2923	addProjectError={addProjectError}
2115	: "Install ARM build"}	2924	newCwd={newCwd}
2116	</Button>	2925	setNewCwd={setNewCwd}
2117	</AlertAction>	2926	setAddProjectError={setAddProjectError}
2118	) : null}	2927	handleAddProject={handleAddProject}
2119	</Alert>	2928	setAddingProject={setAddingProject}
2120	</SidebarGroup>	2929	canAddProject={canAddProject}
2121	) : null}	2930	isManualProjectSorting={isManualProjectSorting}
2122	<SidebarGroup className="px-2 py-2">	2931	projectDnDSensors={projectDnDSensors}
2123	<div className="mb-1 flex items-center justify-between pl-2 pr-1.5">	2932	projectCollisionDetection={projectCollisionDetection}
2124	<span className="text-[10px] font-medium uppercase tracking-wider text-muted-foreground/60">	2933	handleProjectDragStart={handleProjectDragStart}
2125	Projects	2934	handleProjectDragEnd={handleProjectDragEnd}
2126	</span>	2935	handleProjectDragCancel={handleProjectDragCancel}
2127	<div className="flex items-center gap-1">	2936	handleNewThread={handleNewThread}
2128	<ProjectSortMenu	2937	archiveThread={archiveThread}
2129	projectSortOrder={appSettings.sidebarProjectSortOrder}	2938	deleteThread={deleteThread}
2130	threadSortOrder={appSettings.sidebarThreadSortOrder}	2939	sortedProjects={sortedProjects}
2131	onProjectSortOrderChange={(sortOrder) => {	2940	expandedThreadListsByProject={expandedThreadListsByProject}
2132	updateSettings({ sidebarProjectSortOrder: sortOrder });	2941	activeRouteProjectKey={activeRouteProjectKey}
2133	}}	2942	routeThreadKey={routeThreadKey}
2134	onThreadSortOrderChange={(sortOrder) => {	2943	newThreadShortcutLabel={newThreadShortcutLabel}
2135	updateSettings({ sidebarThreadSortOrder: sortOrder });	2944	threadJumpLabelByKey={visibleThreadJumpLabelByKey}
2136	}}	2945	attachThreadListAutoAnimateRef={attachThreadListAutoAnimateRef}
2137	/>	2946	expandThreadListForProject={expandThreadListForProject}
2138	<Tooltip>	2947	collapseThreadListForProject={collapseThreadListForProject}
2139	<TooltipTrigger	2948	dragInProgressRef={dragInProgressRef}
2140	render={	2949	suppressProjectClickAfterDragRef={suppressProjectClickAfterDragRef}
2141	<button	2950	suppressProjectClickForContextMenuRef={suppressProjectClickForContextMenuRef}
2142	type="button"	2951	attachProjectListAutoAnimateRef={attachProjectListAutoAnimateRef}
2143	aria-label={	2952	projectsLength={projects.length}
2144	shouldShowProjectPathEntry ? "Cancel add project" : "Add project"	2953	/>
2145	}
2146	aria-pressed={shouldShowProjectPathEntry}
2147	className="inline-flex size-5 cursor-pointer items-center justify-center rounded-md text-muted-foreground/60 transition-colors hover:bg-accent hover:text-foreground"
2148	onClick={handleStartAddProject}
2149	/>
2150	}
2151	>
2152	<PlusIcon
2153	className={`size-3.5 transition-transform duration-150 ${
2154	shouldShowProjectPathEntry ? "rotate-45" : "rotate-0"
2155	}`}
2156	/>
2157	</TooltipTrigger>
2158	<TooltipPopup side="right">
2159	{shouldShowProjectPathEntry ? "Cancel add project" : "Add project"}
2160	</TooltipPopup>
2161	</Tooltip>
2162	</div>
2163	</div>
2164	{shouldShowProjectPathEntry && (
2165	<div className="mb-2 px-1">
2166	{isElectron && (
2167	<button
2168	type="button"
2169	className="mb-1.5 flex w-full items-center justify-center gap-2 rounded-md border border-border bg-secondary py-1.5 text-xs text-foreground/80 transition-colors duration-150 hover:bg-accent hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
2170	onClick={() => void handlePickFolder()}
2171	disabled={isPickingFolder \|\| isAddingProject}
2172	>
2173	<FolderIcon className="size-3.5" />
2174	{isPickingFolder ? "Picking folder..." : "Browse for folder"}
2175	</button>
2176	)}
2177	<div className="flex gap-1.5">
2178	<input
2179	ref={addProjectInputRef}
2180	className={`min-w-0 flex-1 rounded-md border bg-secondary px-2 py-1 font-mono text-xs text-foreground placeholder:text-muted-foreground/40 focus:outline-none ${
2181	addProjectError
2182	? "border-red-500/70 focus:border-red-500"
2183	: "border-border focus:border-ring"
2184	}`}
2185	placeholder="/path/to/project"
2186	value={newCwd}
2187	onChange={(event) => {
2188	setNewCwd(event.target.value);
2189	setAddProjectError(null);
2190	}}
2191	onKeyDown={(event) => {
2192	if (event.key === "Enter") handleAddProject();
2193	if (event.key === "Escape") {
2194	setAddingProject(false);
2195	setAddProjectError(null);
2196	}
2197	}}
2198	autoFocus
2199	/>
2200	<button
2201	type="button"
2202	className="shrink-0 rounded-md bg-primary px-2.5 py-1 text-xs font-medium text-primary-foreground transition-colors duration-150 hover:bg-primary/90 disabled:opacity-60"
2203	onClick={handleAddProject}
2204	disabled={!canAddProject}
2205	>
2206	{isAddingProject ? "Adding..." : "Add"}
2207	</button>
2208	</div>
2209	{addProjectError && (
2210	<p className="mt-1 px-0.5 text-[11px] leading-tight text-red-400">
2211	{addProjectError}
2212	</p>
2213	)}
2214	</div>
2215	)}
2216
2217	{isManualProjectSorting ? (
2218	<DndContext
2219	sensors={projectDnDSensors}
2220	collisionDetection={projectCollisionDetection}
2221	modifiers={[restrictToVerticalAxis, restrictToFirstScrollableAncestor]}
2222	onDragStart={handleProjectDragStart}
2223	onDragEnd={handleProjectDragEnd}
2224	onDragCancel={handleProjectDragCancel}
2225	>
2226	<SidebarMenu>
2227	<SortableContext
2228	items={renderedProjects.map((renderedProject) => renderedProject.project.id)}
2229	strategy={verticalListSortingStrategy}
2230	>
2231	{renderedProjects.map((renderedProject) => (
2232	<SortableProjectItem
2233	key={renderedProject.project.id}
2234	projectId={renderedProject.project.id}
2235	>
2236	{(dragHandleProps) => renderProjectItem(renderedProject, dragHandleProps)}
2237	</SortableProjectItem>
2238	))}
2239	</SortableContext>
2240	</SidebarMenu>
2241	</DndContext>
2242	) : (
2243	<SidebarMenu ref={attachProjectListAutoAnimateRef}>
2244	{renderedProjects.map((renderedProject) => (
2245	<SidebarMenuItem key={renderedProject.project.id} className="rounded-md">
2246	{renderProjectItem(renderedProject, null)}
2247	</SidebarMenuItem>
2248	))}
2249	</SidebarMenu>
2250	)}
2251
2252	{projects.length === 0 && !shouldShowProjectPathEntry && (
2253	<div className="px-2 pt-4 text-center text-xs text-muted-foreground/60">
2254	No projects yet
2255	</div>
2256	)}
2257	</SidebarGroup>
2258	</SidebarContent>
2259		2954
2260	<SidebarSeparator />	2955	<SidebarSeparator />
2261	<SidebarFooter className="p-2">	2956	<SidebarChromeFooter />
2262	<SidebarUpdatePill />
2263	<SidebarMenu>
2264	<SidebarMenuItem>
2265	<SidebarMenuButton
2266	size="sm"
2267	className="gap-2 px-2 py-1.5 text-muted-foreground/70 hover:bg-accent hover:text-foreground"
2268	onClick={() => void navigate({ to: "/settings" })}
2269	>
2270	<SettingsIcon className="size-3.5" />
2271	<span className="text-xs">Settings</span>
2272	</SidebarMenuButton>
2273	</SidebarMenuItem>
2274	</SidebarMenu>
2275	</SidebarFooter>
2276	</>	2957	</>
2277	)}	2958	)}
2278	</>	2959	</>

apps/web/src/components/ThreadTerminalDrawer.browser.tsx+247−0

@@ -0,0 +1,247 @@
	1	import "../index.css";
	2
	3	import { scopeThreadRef } from "@t3tools/client-runtime";
	4	import { ThreadId } from "@t3tools/contracts";
	5	import { afterEach, describe, expect, it, vi } from "vitest";
	6	import { render } from "vitest-browser-react";
	7
	8	const {
	9	terminalConstructorSpy,
	10	terminalDisposeSpy,
	11	fitAddonFitSpy,
	12	fitAddonLoadSpy,
	13	environmentApiById,
	14	readEnvironmentApiMock,
	15	readLocalApiMock,
	16	} = vi.hoisted(() => ({
	17	terminalConstructorSpy: vi.fn(),
	18	terminalDisposeSpy: vi.fn(),
	19	fitAddonFitSpy: vi.fn(),
	20	fitAddonLoadSpy: vi.fn(),
	21	environmentApiById: new Map<string, { terminal: { open: ReturnType<typeof vi.fn> } }>(),
	22	readEnvironmentApiMock: vi.fn((environmentId: string) => environmentApiById.get(environmentId)),
	23	readLocalApiMock: vi.fn<
	24	() =>
	25	\| {
	26	contextMenu: { show: ReturnType<typeof vi.fn> };
	27	shell: { openExternal: ReturnType<typeof vi.fn> };
	28	}
	29	\| undefined
	30	>(() => ({
	31	contextMenu: { show: vi.fn(async () => null) },
	32	shell: { openExternal: vi.fn(async () => undefined) },
	33	})),
	34	}));
	35
	36	vi.mock("@xterm/addon-fit", () => ({
	37	FitAddon: class MockFitAddon {
	38	fit = fitAddonFitSpy;
	39	},
	40	}));
	41
	42	vi.mock("@xterm/xterm", () => ({
	43	Terminal: class MockTerminal {
	44	cols = 80;
	45	rows = 24;
	46	options: { theme?: unknown } = {};
	47	buffer = {
	48	active: {
	49	viewportY: 0,
	50	baseY: 0,
	51	getLine: vi.fn(() => null),
	52	},
	53	};
	54
	55	constructor(options: unknown) {
	56	terminalConstructorSpy(options);
	57	}
	58
	59	loadAddon(addon: unknown) {
	60	fitAddonLoadSpy(addon);
	61	}
	62
	63	open() {}
	64
	65	write() {}
	66
	67	clear() {}
	68
	69	clearSelection() {}
	70
	71	focus() {}
	72
	73	refresh() {}
	74
	75	scrollToBottom() {}
	76
	77	hasSelection() {
	78	return false;
	79	}
	80
	81	getSelection() {
	82	return "";
	83	}
	84
	85	getSelectionPosition() {
	86	return null;
	87	}
	88
	89	attachCustomKeyEventHandler() {
	90	return true;
	91	}
	92
	93	registerLinkProvider() {
	94	return { dispose: vi.fn() };
	95	}
	96
	97	onData() {
	98	return { dispose: vi.fn() };
	99	}
	100
	101	onSelectionChange() {
	102	return { dispose: vi.fn() };
	103	}
	104
	105	dispose() {
	106	terminalDisposeSpy();
	107	}
	108	},
	109	}));
	110
	111	vi.mock("~/environmentApi", () => ({
	112	readEnvironmentApi: readEnvironmentApiMock,
	113	}));
	114
	115	vi.mock("~/localApi", () => ({
	116	readLocalApi: readLocalApiMock,
	117	}));
	118
	119	import { TerminalViewport } from "./ThreadTerminalDrawer";
	120
	121	const THREAD_ID = ThreadId.makeUnsafe("thread-terminal-browser");
	122
	123	function createEnvironmentApi() {
	124	return {
	125	terminal: {
	126	open: vi.fn(async () => ({
	127	threadId: THREAD_ID,
	128	terminalId: "default",
	129	cwd: "/repo/project",
	130	worktreePath: null,
	131	status: "running" as const,
	132	pid: 123,
	133	history: "",
	134	exitCode: null,
	135	exitSignal: null,
	136	updatedAt: "2026-04-07T00:00:00.000Z",
	137	})),
	138	write: vi.fn(async () => undefined),
	139	resize: vi.fn(async () => undefined),
	140	},
	141	};
	142	}
	143
	144	async function mountTerminalViewport(props: { threadRef: ReturnType<typeof scopeThreadRef> }) {
	145	const host = document.createElement("div");
	146	host.style.width = "800px";
	147	host.style.height = "400px";
	148	document.body.append(host);
	149
	150	const screen = await render(
	151	<TerminalViewport
	152	threadRef={props.threadRef}
	153	threadId={THREAD_ID}
	154	terminalId="default"
	155	terminalLabel="Terminal"
	156	cwd="/repo/project"
	157	onSessionExited={() => undefined}
	158	onAddTerminalContext={() => undefined}
	159	focusRequestId={0}
	160	autoFocus={false}
	161	resizeEpoch={0}
	162	drawerHeight={320}
	163	/>,
	164	{ container: host },
	165	);
	166
	167	return {
	168	rerender: async (nextProps: { threadRef: ReturnType<typeof scopeThreadRef> }) => {
	169	await screen.rerender(
	170	<TerminalViewport
	171	threadRef={nextProps.threadRef}
	172	threadId={THREAD_ID}
	173	terminalId="default"
	174	terminalLabel="Terminal"
	175	cwd="/repo/project"
	176	onSessionExited={() => undefined}
	177	onAddTerminalContext={() => undefined}
	178	focusRequestId={0}
	179	autoFocus={false}
	180	resizeEpoch={0}
	181	drawerHeight={320}
	182	/>,
	183	);
	184	},
	185	cleanup: async () => {
	186	await screen.unmount();
	187	host.remove();
	188	},
	189	};
	190	}
	191
	192	describe("TerminalViewport", () => {
	193	afterEach(() => {
	194	environmentApiById.clear();
	195	readEnvironmentApiMock.mockClear();
	196	readLocalApiMock.mockClear();
	197	terminalConstructorSpy.mockClear();
	198	terminalDisposeSpy.mockClear();
	199	fitAddonFitSpy.mockClear();
	200	fitAddonLoadSpy.mockClear();
	201	});
	202
	203	it("does not create a terminal when APIs are unavailable", async () => {
	204	readEnvironmentApiMock.mockReturnValueOnce(undefined);
	205	readLocalApiMock.mockReturnValueOnce(undefined);
	206
	207	const mounted = await mountTerminalViewport({
	208	threadRef: scopeThreadRef("environment-a" as never, THREAD_ID),
	209	});
	210
	211	try {
	212	await vi.waitFor(() => {
	213	expect(terminalConstructorSpy).not.toHaveBeenCalled();
	214	});
	215	} finally {
	216	await mounted.cleanup();
	217	}
	218	});
	219
	220	it("reopens the terminal when the scoped thread reference changes", async () => {
	221	const environmentA = createEnvironmentApi();
	222	const environmentB = createEnvironmentApi();
	223	environmentApiById.set("environment-a", environmentA);
	224	environmentApiById.set("environment-b", environmentB);
	225
	226	const mounted = await mountTerminalViewport({
	227	threadRef: scopeThreadRef("environment-a" as never, THREAD_ID),
	228	});
	229
	230	try {
	231	await vi.waitFor(() => {
	232	expect(environmentA.terminal.open).toHaveBeenCalledTimes(1);
	233	});
	234
	235	await mounted.rerender({
	236	threadRef: scopeThreadRef("environment-b" as never, THREAD_ID),
	237	});
	238
	239	await vi.waitFor(() => {
	240	expect(environmentB.terminal.open).toHaveBeenCalledTimes(1);
	241	});
	242	expect(terminalDisposeSpy).toHaveBeenCalledTimes(1);
	243	} finally {
	244	await mounted.cleanup();
	245	}
	246	});
	247	});

apps/web/src/components/ThreadTerminalDrawer.tsx+22−14

 import { FitAddon } from "@xterm/addon-fit";
 import { Plus, SquareSplitHorizontal, TerminalSquare, Trash2, XIcon } from "lucide-react";
 import {
+  type ScopedThreadRef,
   type TerminalEvent,
   type TerminalSessionSnapshot,
   type ThreadId,
   MAX_TERMINALS_PER_GROUP,
   type ThreadTerminalGroup,
 } from "../types";
-import { readNativeApi } from "~/nativeApi";
+import { readEnvironmentApi } from "~/environmentApi";
+import { readLocalApi } from "~/localApi";
 import { selectTerminalEventEntries, useTerminalStateStore } from "../terminalStateStore";
 const MIN_DRAWER_HEIGHT = 180;
 }
 interface TerminalViewportProps {
+  threadRef: ScopedThreadRef;
   threadId: ThreadId;
   terminalId: string;
   terminalLabel: string;
   drawerHeight: number;
 }
-function TerminalViewport({
+export function TerminalViewport({
+  threadRef,
   threadId,
   terminalId,
   terminalLabel,
     if (!mount) return;
     let disposed = false;
+    const api = readEnvironmentApi(threadRef.environmentId);
+    const localApi = readLocalApi();
+    if (!api || !localApi) return;
     const fitAddon = new FitAddon();
     const terminal = new Terminal({
     terminalRef.current = terminal;
     fitAddonRef.current = fitAddon;
-    const api = readNativeApi();
-    if (!api) return;
     const clearSelectionAction = () => {
       selectionActionRequestIdRef.current += 1;
       if (selectionActionTimerRef.current !== null) {
       const requestId = ++selectionActionRequestIdRef.current;
       selectionActionOpenRef.current = true;
       try {
-        const clicked = await api.contextMenu.show(
+        const clicked = await localApi.contextMenu.show(
           [{ id: "add-to-chat", label: "Add to chat" }],
           nextAction.position,
         );
               if (!latestTerminal) return;
               if (match.kind === "url") {
-                void api.shell.openExternal(match.text).catch((error) => {
+                void localApi.shell.openExternal(match.text).catch((error: unknown) => {
                   writeSystemMessage(
                     latestTerminal,
                     error instanceof Error ? error.message : "Unable to open link",
               }
               const target = resolvePathLinkTarget(match.text, cwd);
-              void openInPreferredEditor(api, target).catch((error) => {
+              void openInPreferredEditor(localApi, target).catch((error) => {
                 writeSystemMessage(
                   latestTerminal,
                   error instanceof Error ? error.message : "Unable to open path",
       const previousLastEntryId =
         selectTerminalEventEntries(
           previousState.terminalEventEntriesByKey,
-          threadId,
+          threadRef,
           terminalId,
         ).at(-1)?.id ?? 0;
       const nextEntries = selectTerminalEventEntries(
         state.terminalEventEntriesByKey,
-        threadId,
+        threadRef,
         terminalId,
       );
       const nextLastEntryId = nextEntries.at(-1)?.id ?? 0;
         writeTerminalSnapshot(activeTerminal, snapshot);
         const bufferedEntries = selectTerminalEventEntries(
           useTerminalStateStore.getState().terminalEventEntriesByKey,
-          threadId,
+          threadRef,
           terminalId,
         );
         const replayEntries = selectTerminalEventEntriesAfterSnapshot(
     // autoFocus is intentionally omitted;
     // it is only read at mount time and must not trigger terminal teardown/recreation.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [cwd, runtimeEnv, terminalId, threadId]);
+  }, [cwd, runtimeEnv, terminalId, threadId, threadRef]);
   useEffect(() => {
     if (!autoFocus) return;
   }, [autoFocus, focusRequestId]);
   useEffect(() => {
-    const api = readNativeApi();
+    const api = readEnvironmentApi(threadRef.environmentId);
     const terminal = terminalRef.current;
     const fitAddon = fitAddonRef.current;
     if (!api || !terminal || !fitAddon) return;
     return () => {
       window.cancelAnimationFrame(frame);
     };
-  }, [drawerHeight, resizeEpoch, terminalId, threadId]);
+  }, [drawerHeight, resizeEpoch, terminalId, threadId, threadRef]);
   return (
     <div ref={containerRef} className="relative h-full w-full overflow-hidden rounded-[4px]" />
   );
 }
 interface ThreadTerminalDrawerProps {
+  threadRef: ScopedThreadRef;
   threadId: ThreadId;
   cwd: string;
   worktreePath?: string | null;
 }
 export default function ThreadTerminalDrawer({
+  threadRef,
   threadId,
   cwd,
   worktreePath,
                   >
                     <div className="h-full p-1">
                       <TerminalViewport
+                        threadRef={threadRef}
                         threadId={threadId}
                         terminalId={terminalId}
                         terminalLabel={terminalLabelById.get(terminalId) ?? "Terminal"}
               <div className="h-full p-1">
                 <TerminalViewport
                   key={resolvedActiveTerminalId}
+                  threadRef={threadRef}
                   threadId={threadId}
                   terminalId={resolvedActiveTerminalId}
                   terminalLabel={terminalLabelById.get(resolvedActiveTerminalId) ?? "Terminal"}

apps/web/src/components/chat/ChatHeader.tsx+10−1

 import {
+  type EnvironmentId,
   type EditorId,
   type ProjectScript,
   type ResolvedKeybindingsConfig,
   type ThreadId,
 } from "@t3tools/contracts";
+import { scopeThreadRef } from "@t3tools/client-runtime";
 import { memo } from "react";
 import GitActionsControl from "../GitActionsControl";
 import { DiffIcon, TerminalSquareIcon } from "lucide-react";
 import { OpenInPicker } from "./OpenInPicker";
 interface ChatHeaderProps {
+  activeThreadEnvironmentId: EnvironmentId;
   activeThreadId: ThreadId;
   activeThreadTitle: string;
   activeProjectName: string | undefined;
 }
 export const ChatHeader = memo(function ChatHeader({
+  activeThreadEnvironmentId,
   activeThreadId,
   activeThreadTitle,
   activeProjectName,
             openInCwd={openInCwd}
           />
         )}
-        {activeProjectName && <GitActionsControl gitCwd={gitCwd} activeThreadId={activeThreadId} />}
+        {activeProjectName && (
+          <GitActionsControl
+            gitCwd={gitCwd}
+            activeThreadRef={scopeThreadRef(activeThreadEnvironmentId, activeThreadId)}
+          />
+        )}
         <Tooltip>
           <TooltipTrigger
             render={

apps/web/src/components/chat/CompactComposerControlsMenu.browser.tsx+35−27

-import { DEFAULT_MODEL_BY_PROVIDER, ModelSelection, ThreadId } from "@t3tools/contracts";
+import {
+  DEFAULT_MODEL_BY_PROVIDER,
+  EnvironmentId,
+  ModelSelection,
+  ThreadId,
+} from "@t3tools/contracts";
+import { scopedThreadKey, scopeThreadRef } from "@t3tools/client-runtime";
 import "../../index.css";
 import { page } from "vitest/browser";
 import { TraitsMenuContent } from "./TraitsPicker";
 import { useComposerDraftStore } from "../../composerDraftStore";
+const LOCAL_ENVIRONMENT_ID = EnvironmentId.makeUnsafe("environment-local");
 async function mountMenu(props?: { modelSelection?: ModelSelection; prompt?: string }) {
   const threadId = ThreadId.makeUnsafe("thread-compact-menu");
+  const threadRef = scopeThreadRef(LOCAL_ENVIRONMENT_ID, threadId);
+  const threadKey = scopedThreadKey(threadRef);
   const provider = props?.modelSelection?.provider ?? "claudeAgent";
-  const draftsByThreadId = {} as ReturnType<
-    typeof useComposerDraftStore.getState
-  >["draftsByThreadId"];
   const model = props?.modelSelection?.model ?? DEFAULT_MODEL_BY_PROVIDER[provider];
-  draftsByThreadId[threadId] = {
+  useComposerDraftStore.setState({
-    prompt: props?.prompt ?? "",
+    draftsByThreadKey: {
-    images: [],
+      [threadKey]: {
-    nonPersistedImageIds: [],
+        prompt: props?.prompt ?? "",
-    persistedAttachments: [],
+        images: [],
-    terminalContexts: [],
+        nonPersistedImageIds: [],
-    modelSelectionByProvider: {
+        persistedAttachments: [],
-      [provider]: {
+        terminalContexts: [],
-        provider,
+        modelSelectionByProvider: {
-        model,
+          [provider]: {
-        ...(props?.modelSelection?.options ? { options: props.modelSelection.options } : {}),
+            provider,
+            model,
+            ...(props?.modelSelection?.options ? { options: props.modelSelection.options } : {}),
+          },
+        },
+        activeProvider: provider,
+        runtimeMode: null,
+        interactionMode: null,
       },
     },
-    activeProvider: provider,
+    draftThreadsByThreadKey: {},
-    runtimeMode: null,
+    logicalProjectDraftThreadKeyByLogicalProjectKey: {},
-    interactionMode: null,
-  };
-  useComposerDraftStore.setState({
-    draftsByThreadId,
-    draftThreadsByThreadId: {},
-    projectDraftThreadIdByProjectId: {},
   });
   const host = document.createElement("div");
   document.body.append(host);
         <TraitsMenuContent
           provider={provider}
           models={models}
-          threadId={threadId}
+          threadRef={threadRef}
           model={model}
           prompt={props?.prompt ?? ""}
           modelOptions={providerOptions}
   afterEach(() => {
     document.body.innerHTML = "";
     useComposerDraftStore.setState({
-      draftsByThreadId: {},
+      draftsByThreadKey: {},
-      draftThreadsByThreadId: {},
+      draftThreadsByThreadKey: {},
-      projectDraftThreadIdByProjectId: {},
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
       stickyModelSelectionByProvider: {},
     });
   });

apps/web/src/components/chat/ComposerPendingUserInputPanel.tsx+20−18

 import { type ApprovalRequestId } from "@t3tools/contracts";
-import { memo, useCallback, useEffect, useRef } from "react";
+import { memo, useEffect, useEffectEvent, useRef } from "react";
 import { type PendingUserInput } from "../../session-logic";
 import {
   derivePendingUserInputProgress,
   const progress = derivePendingUserInputProgress(prompt.questions, answers, questionIndex);
   const activeQuestion = progress.activeQuestion;
   const autoAdvanceTimerRef = useRef<number | null>(null);
+  const onAdvanceRef = useRef(onAdvance);
+  useEffect(() => {
+    onAdvanceRef.current = onAdvance;
+  }, [onAdvance]);
   // Clear auto-advance timer on unmount
   useEffect(() => {
     };
   }, []);
-  const handleOptionSelection = useCallback(
+  const handleOptionSelection = useEffectEvent((questionId: string, optionLabel: string) => {
-    (questionId: string, optionLabel: string) => {
+    onToggleOption(questionId, optionLabel);
-      onToggleOption(questionId, optionLabel);
+    if (activeQuestion?.multiSelect) {
-      if (activeQuestion?.multiSelect) {
+      return;
-        return;
+    }
-      }
+    if (autoAdvanceTimerRef.current !== null) {
-      if (autoAdvanceTimerRef.current !== null) {
+      window.clearTimeout(autoAdvanceTimerRef.current);
-        window.clearTimeout(autoAdvanceTimerRef.current);
+    }
-      }
+    autoAdvanceTimerRef.current = window.setTimeout(() => {
-      autoAdvanceTimerRef.current = window.setTimeout(() => {
+      autoAdvanceTimerRef.current = null;
-        autoAdvanceTimerRef.current = null;
+      onAdvanceRef.current();
-        onAdvance();
+    }, 200);
-      }, 200);
+  });
-    },
-    [activeQuestion?.multiSelect, onAdvance, onToggleOption],
-  );
   // Keyboard shortcut: number keys 1-9 select corresponding options when focus is
   // outside editable fields. Multi-select prompts toggle options in place; single-
     };
     document.addEventListener("keydown", handler);
     return () => document.removeEventListener("keydown", handler);
-  }, [activeQuestion, handleOptionSelection, isResponding]);
+  }, [activeQuestion, isResponding]);
   if (!activeQuestion) {
     return null;

apps/web/src/components/chat/MessagesTimeline.test.tsx+4−0

   });
 });
+const ACTIVE_THREAD_ENVIRONMENT_ID = "environment-local" as never;
 describe("MessagesTimeline", () => {
   it("renders inline terminal labels with the composer chip UI", async () => {
     const { MessagesTimeline } = await import("./MessagesTimeline");
         onRevertUserMessage={() => {}}
         isRevertingCheckpoint={false}
         onImageExpand={() => {}}
+        activeThreadEnvironmentId={ACTIVE_THREAD_ENVIRONMENT_ID}
         markdownCwd={undefined}
         resolvedTheme="light"
         timestampFormat="locale"
         onRevertUserMessage={() => {}}
         isRevertingCheckpoint={false}
         onImageExpand={() => {}}
+        activeThreadEnvironmentId={ACTIVE_THREAD_ENVIRONMENT_ID}
         markdownCwd={undefined}
         resolvedTheme="light"
         timestampFormat="locale"

apps/web/src/components/chat/MessagesTimeline.tsx+4−1

-import { type MessageId, type TurnId } from "@t3tools/contracts";
+import { type EnvironmentId, type MessageId, type TurnId } from "@t3tools/contracts";
 import {
   memo,
   useCallback,
   onRevertUserMessage: (messageId: MessageId) => void;
   isRevertingCheckpoint: boolean;
   onImageExpand: (preview: ExpandedImagePreview) => void;
+  activeThreadEnvironmentId: EnvironmentId;
   markdownCwd: string | undefined;
   resolvedTheme: "light" | "dark";
   timestampFormat: TimestampFormat;
   onRevertUserMessage,
   isRevertingCheckpoint,
   onImageExpand,
+  activeThreadEnvironmentId,
   markdownCwd,
   resolvedTheme,
   timestampFormat,
         <div className="min-w-0 px-1 py-0.5">
           <ProposedPlanCard
             planMarkdown={row.proposedPlan.planMarkdown}
+            environmentId={activeThreadEnvironmentId}
             cwd={markdownCwd}
             workspaceRoot={workspaceRoot}
           />

apps/web/src/components/chat/MessagesTimeline.virtualization.browser.tsx+23−6

   height: 1_100,
 };
 const MARKDOWN_CWD = "/repo/project";
+const ACTIVE_THREAD_ENVIRONMENT_ID = "environment-local" as never;
 interface RowMeasurement {
   actualHeightPx: number;
 interface VirtualizationScenario {
   name: string;
   targetRowId: string;
-  props: Omit<ComponentProps<typeof MessagesTimeline>, "scrollContainer">;
+  props: Omit<
+    ComponentProps<typeof MessagesTimeline>,
+    "scrollContainer" | "activeThreadEnvironmentId"
+  >;
   maxEstimateDeltaPx: number;
 }
 }
 function MessagesTimelineBrowserHarness(
-  props: Omit<ComponentProps<typeof MessagesTimeline>, "scrollContainer">,
+  props: Omit<
+    ComponentProps<typeof MessagesTimeline>,
+    "scrollContainer" | "activeThreadEnvironmentId"
+  >,
 ) {
   const [scrollContainer, setScrollContainer] = useState<HTMLDivElement | null>(null);
   const [expandedWorkGroups, setExpandedWorkGroups] = useState<Record<string, boolean>>(
     >
       <MessagesTimeline
         {...props}
+        activeThreadEnvironmentId={ACTIVE_THREAD_ENVIRONMENT_ID}
         scrollContainer={scrollContainer}
         expandedWorkGroups={expandedWorkGroups}
         onToggleWorkGroup={handleToggleWorkGroup}
   completionDividerBeforeEntryId?: string | null;
   turnDiffSummaryByAssistantMessageId?: Map<MessageId, TurnDiffSummary>;
   onVirtualizerSnapshot?: ComponentProps<typeof MessagesTimeline>["onVirtualizerSnapshot"];
-}): Omit<ComponentProps<typeof MessagesTimeline>, "scrollContainer"> {
+}): Omit<ComponentProps<typeof MessagesTimeline>, "scrollContainer" | "activeThreadEnvironmentId"> {
   return {
     hasMessages: true,
     isWorking: false,
 async function measureTimelineRow(input: {
   host: HTMLElement;
-  props: Omit<ComponentProps<typeof MessagesTimeline>, "scrollContainer">;
+  props: Omit<
+    ComponentProps<typeof MessagesTimeline>,
+    "scrollContainer" | "activeThreadEnvironmentId"
+  >;
   targetRowId: string;
 }): Promise<RowMeasurement> {
   const scrollContainer = await waitForElement(
 }
 async function mountMessagesTimeline(input: {
-  props: Omit<ComponentProps<typeof MessagesTimeline>, "scrollContainer">;
+  props: Omit<
+    ComponentProps<typeof MessagesTimeline>,
+    "scrollContainer" | "activeThreadEnvironmentId"
+  >;
   viewport?: { width: number; height: number };
 }) {
   const viewport = input.viewport ?? DEFAULT_VIEWPORT;
   return {
     host,
     rerender: async (
-      nextProps: Omit<ComponentProps<typeof MessagesTimeline>, "scrollContainer">,
+      nextProps: Omit<
+        ComponentProps<typeof MessagesTimeline>,
+        "scrollContainer" | "activeThreadEnvironmentId"
+      >,
     ) => {
       await screen.rerender(<MessagesTimelineBrowserHarness {...nextProps} />);
       await waitForLayout();

apps/web/src/components/chat/OpenInPicker.tsx+3−3

@@ -18,7 +18,7 @@ import { · 17 unmodified lines
18	Zed,	18	Zed,
19	} from "../Icons";	19	} from "../Icons";
20	import { isMacPlatform, isWindowsPlatform } from "~/lib/utils";	20	import { isMacPlatform, isWindowsPlatform } from "~/lib/utils";
21	import { readNativeApi } from "~/nativeApi";	21	import { readLocalApi } from "~/localApi";
22		22
23	const resolveOptions = (platform: string, availableEditors: ReadonlyArray<EditorId>) => {	23	const resolveOptions = (platform: string, availableEditors: ReadonlyArray<EditorId>) => {
24	const baseOptions: ReadonlyArray<{ label: string; Icon: Icon; value: EditorId }> = [	24	const baseOptions: ReadonlyArray<{ label: string; Icon: Icon; value: EditorId }> = [
@@ -93,7 +93,7 @@ export const OpenInPicker = memo(function OpenInPicker({ · 68 unmodified lines
93		93
94	const openInEditor = useCallback(	94	const openInEditor = useCallback(
95	(editorId: EditorId \| null) => {	95	(editorId: EditorId \| null) => {
96	const api = readNativeApi();	96	const api = readLocalApi();
97	if (!api \|\| !openInCwd) return;	97	if (!api \|\| !openInCwd) return;
98	const editor = editorId ?? preferredEditor;	98	const editor = editorId ?? preferredEditor;
99	if (!editor) return;	99	if (!editor) return;
@@ -110,7 +110,7 @@ export const OpenInPicker = memo(function OpenInPicker({ · 10 unmodified lines
110		110
111	useEffect(() => {	111	useEffect(() => {
112	const handler = (e: globalThis.KeyboardEvent) => {	112	const handler = (e: globalThis.KeyboardEvent) => {
113	const api = readNativeApi();	113	const api = readLocalApi();
114	if (!isOpenFavoriteEditorShortcut(e, keybindings)) return;	114	if (!isOpenFavoriteEditorShortcut(e, keybindings)) return;
115	if (!api \|\| !openInCwd) return;	115	if (!api \|\| !openInCwd) return;
116	if (!preferredEditor) return;	116	if (!preferredEditor) return;

apps/web/src/components/chat/ProposedPlanCard.tsx+5−2

 import { memo, useState, useId } from "react";
+import type { EnvironmentId } from "@t3tools/contracts";
 import {
   buildCollapsedProposedPlanPreviewMarkdown,
   buildProposedPlanMarkdownFilename,
   DialogTitle,
 } from "../ui/dialog";
 import { toastManager } from "../ui/toast";
-import { readNativeApi } from "~/nativeApi";
+import { readEnvironmentApi } from "~/environmentApi";
 import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";
 export const ProposedPlanCard = memo(function ProposedPlanCard({
   planMarkdown,
+  environmentId,
   cwd,
   workspaceRoot,
 }: {
   planMarkdown: string;
+  environmentId: EnvironmentId;
   cwd: string | undefined;
   workspaceRoot: string | undefined;
 }) {
   };
   const handleSaveToWorkspace = () => {
-    const api = readNativeApi();
+    const api = readEnvironmentApi(environmentId);
     const relativePath = savePath.trim();
     if (!api || !workspaceRoot) {
       return;

apps/web/src/components/chat/TraitsPicker.browser.tsx+30−24

   CodexModelOptions,
   DEFAULT_MODEL_BY_PROVIDER,
   DEFAULT_SERVER_SETTINGS,
-  ProjectId,
+  EnvironmentId,
   type ServerProvider,
   ThreadId,
 } from "@t3tools/contracts";
+import { scopedThreadKey, scopeThreadRef } from "@t3tools/client-runtime";
 import { page } from "vitest/browser";
 import { useCallback } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 // ── Claude TraitsPicker tests ─────────────────────────────────────────
+const LOCAL_ENVIRONMENT_ID = EnvironmentId.makeUnsafe("environment-local");
 const CLAUDE_THREAD_ID = ThreadId.makeUnsafe("thread-claude-traits");
+const CLAUDE_THREAD_REF = scopeThreadRef(LOCAL_ENVIRONMENT_ID, CLAUDE_THREAD_ID);
+const CLAUDE_THREAD_KEY = scopedThreadKey(CLAUDE_THREAD_REF);
+const CODEX_THREAD_ID = ThreadId.makeUnsafe("thread-codex-traits");
+const CODEX_THREAD_REF = scopeThreadRef(LOCAL_ENVIRONMENT_ID, CODEX_THREAD_ID);
+const CODEX_THREAD_KEY = scopedThreadKey(CODEX_THREAD_REF);
 const TEST_PROVIDERS: ReadonlyArray<ServerProvider> = [
   {
     provider: "codex",
   fallbackModelSelection: ModelSelection | null;
   triggerVariant?: "ghost" | "outline";
 }) {
-  const prompt = useComposerThreadDraft(CLAUDE_THREAD_ID).prompt;
+  const prompt = useComposerThreadDraft(CLAUDE_THREAD_REF).prompt;
   const setPrompt = useComposerDraftStore((store) => store.setPrompt);
   const { modelOptions, selectedModel } = useEffectiveComposerModelState({
-    threadId: CLAUDE_THREAD_ID,
+    threadRef: CLAUDE_THREAD_REF,
     providers: TEST_PROVIDERS,
     selectedProvider: "claudeAgent",
     threadModelSelection: props.fallbackModelSelection,
   });
   const handlePromptChange = useCallback(
     (nextPrompt: string) => {
-      setPrompt(CLAUDE_THREAD_ID, nextPrompt);
+      setPrompt(CLAUDE_THREAD_REF, nextPrompt);
     },
     [setPrompt],
   );
     <TraitsPicker
       provider="claudeAgent"
       models={TEST_PROVIDERS[1]!.models}
-      threadId={CLAUDE_THREAD_ID}
+      threadRef={CLAUDE_THREAD_REF}
       model={selectedModel ?? props.model}
       prompt={prompt}
       modelOptions={modelOptions?.claudeAgent}
 }) {
   const model = props?.model ?? "claude-opus-4-6";
   const claudeOptions = !props?.skipDraftModelOptions ? props?.options : undefined;
-  const draftsByThreadId: Record<ThreadId, ComposerThreadDraftState> = {
+  const draftsByThreadKey: Record<string, ComposerThreadDraftState> = {
-    [CLAUDE_THREAD_ID]: {
+    [CLAUDE_THREAD_KEY]: {
       prompt: props?.prompt ?? "",
       images: [],
       nonPersistedImageIds: [],
     },
   };
   useComposerDraftStore.setState({
-    draftsByThreadId,
+    draftsByThreadKey,
-    draftThreadsByThreadId: {},
+    draftThreadsByThreadKey: {},
-    projectDraftThreadIdByProjectId: {},
+    logicalProjectDraftThreadKeyByLogicalProjectKey: {},
   });
   const host = document.createElement("div");
   document.body.append(host);
   afterEach(() => {
     document.body.innerHTML = "";
     useComposerDraftStore.setState({
-      draftsByThreadId: {},
+      draftsByThreadKey: {},
-      draftThreadsByThreadId: {},
+      draftThreadsByThreadKey: {},
-      projectDraftThreadIdByProjectId: {},
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
       stickyModelSelectionByProvider: {},
     });
   });
 // ── Codex TraitsPicker tests ──────────────────────────────────────────
 async function mountCodexPicker(props: { model?: string; options?: CodexModelOptions }) {
-  const threadId = ThreadId.makeUnsafe("thread-codex-traits");
   const model = props.model ?? DEFAULT_MODEL_BY_PROVIDER.codex;
-  const draftsByThreadId: Record<ThreadId, ComposerThreadDraftState> = {
+  const draftsByThreadKey: Record<string, ComposerThreadDraftState> = {
-    [threadId]: {
+    [CODEX_THREAD_KEY]: {
       prompt: "",
       images: [],
       nonPersistedImageIds: [],
   };
   useComposerDraftStore.setState({
-    draftsByThreadId,
+    draftsByThreadKey,
-    draftThreadsByThreadId: {},
+    draftThreadsByThreadKey: {},
-    projectDraftThreadIdByProjectId: {
+    logicalProjectDraftThreadKeyByLogicalProjectKey: {
-      [ProjectId.makeUnsafe("project-codex-traits")]: threadId,
+      "environment-local:project-codex-traits": CODEX_THREAD_KEY,
     },
   });
   const host = document.createElement("div");
     <TraitsPicker
       provider="codex"
       models={TEST_PROVIDERS[0]!.models}
-      threadId={threadId}
+      threadRef={CODEX_THREAD_REF}
       model={props.model ?? DEFAULT_MODEL_BY_PROVIDER.codex}
       prompt=""
       modelOptions={props.options}
     document.body.innerHTML = "";
     localStorage.removeItem(COMPOSER_DRAFT_STORAGE_KEY);
     useComposerDraftStore.setState({
-      draftsByThreadId: {},
+      draftsByThreadKey: {},
-      draftThreadsByThreadId: {},
+      draftThreadsByThreadKey: {},
-      projectDraftThreadIdByProjectId: {},
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
       stickyModelSelectionByProvider: {},
     });
   });

apps/web/src/components/chat/TraitsPicker.tsx+12−5

   type CodexModelOptions,
   type ProviderKind,
   type ProviderModelOptions,
+  type ScopedThreadRef,
   type ServerProviderModel,
-  type ThreadId,
 } from "@t3tools/contracts";
 import {
   applyClaudePromptEffortPrefix,
   MenuSeparator as MenuDivider,
   MenuTrigger,
 } from "../ui/menu";
-import { useComposerDraftStore } from "../../composerDraftStore";
+import { useComposerDraftStore, DraftId } from "../../composerDraftStore";
 import { getProviderModelCapabilities } from "../../providerModels";
 import { cn } from "~/lib/utils";
 type ProviderOptions = ProviderModelOptions[ProviderKind];
 type TraitsPersistence =
   | {
-      threadId: ThreadId;
+      threadRef?: ScopedThreadRef;
+      draftId?: DraftId;
       onModelOptionsChange?: never;
     }
   | {
-      threadId?: undefined;
+      threadRef?: undefined;
       onModelOptionsChange: (nextOptions: ProviderOptions | undefined) => void;
     };
         persistence.onModelOptionsChange(nextOptions);
         return;
       }
-      setProviderModelOptions(persistence.threadId, provider, nextOptions, { persistSticky: true });
+      const threadTarget = persistence.threadRef ?? persistence.draftId;
+      if (!threadTarget) {
+        return;
+      }
+      setProviderModelOptions(threadTarget, provider, nextOptions, {
+        persistSticky: true,
+      });
     },
     [persistence, provider, setProviderModelOptions],
   );

apps/web/src/components/chat/composerProviderRegistry.test.tsx+33−1

@@ -1,6 +1,10 @@
1	import { describe, expect, it } from "vitest";	1	import { describe, expect, it } from "vitest";
2	import type { ServerProviderModel } from "@t3tools/contracts";	2	import type { ServerProviderModel } from "@t3tools/contracts";
3	import { getComposerProviderState } from "./composerProviderRegistry";	3	import {
		4	getComposerProviderState,
		5	renderProviderTraitsMenuContent,
		6	renderProviderTraitsPicker,
		7	} from "./composerProviderRegistry";
4		8
5	const CODEX_MODELS: ReadonlyArray<ServerProviderModel> = [	9	const CODEX_MODELS: ReadonlyArray<ServerProviderModel> = [
6	{	10	{
@@ -417,3 +421,31 @@ describe("getComposerProviderState", () => { · 410 unmodified lines
417	expect(state.modelOptionsForDispatch).not.toHaveProperty("fastMode");	421	expect(state.modelOptionsForDispatch).not.toHaveProperty("fastMode");
418	});	422	});
419	});	423	});
		424
		425	describe("provider traits render guards", () => {
		426	it("returns null for codex traits picker when no thread target is provided", () => {
		427	const content = renderProviderTraitsPicker({
		428	provider: "codex",
		429	model: "gpt-5.4",
		430	models: CODEX_MODELS,
		431	modelOptions: undefined,
		432	prompt: "",
		433	onPromptChange: () => {},
		434	});
		435
		436	expect(content).toBeNull();
		437	});
		438
		439	it("returns null for claude traits menu content when no thread target is provided", () => {
		440	const content = renderProviderTraitsMenuContent({
		441	provider: "claudeAgent",
		442	model: "claude-sonnet-4-6",
		443	models: CLAUDE_MODELS,
		444	modelOptions: undefined,
		445	prompt: "",
		446	onPromptChange: () => {},
		447	});
		448
		449	expect(content).toBeNull();
		450	});
		451	});

apps/web/src/components/chat/composerProviderRegistry.tsx+93−53

 import {
   type ProviderKind,
   type ProviderModelOptions,
+  type ScopedThreadRef,
   type ServerProviderModel,
-  type ThreadId,
 } from "@t3tools/contracts";
 import { isClaudeUltrathinkPrompt, resolveEffort } from "@t3tools/shared/model";
 import type { ReactNode } from "react";
+import type { DraftId } from "../../composerDraftStore";
 import { getProviderModelCapabilities } from "../../providerModels";
 import { TraitsMenuContent, TraitsPicker } from "./TraitsPicker";
 import {
 type ProviderRegistryEntry = {
   getState: (input: ComposerProviderStateInput) => ComposerProviderState;
   renderTraitsMenuContent: (input: {
-    threadId: ThreadId;
+    threadRef?: ScopedThreadRef;
+    draftId?: DraftId;
     model: string;
     models: ReadonlyArray<ServerProviderModel>;
     modelOptions: ProviderModelOptions[ProviderKind] | undefined;
     onPromptChange: (prompt: string) => void;
   }) => ReactNode;
   renderTraitsPicker: (input: {
-    threadId: ThreadId;
+    threadRef?: ScopedThreadRef;
+    draftId?: DraftId;
     model: string;
     models: ReadonlyArray<ServerProviderModel>;
     modelOptions: ProviderModelOptions[ProviderKind] | undefined;
   }) => ReactNode;
 };
+function hasComposerTraitsTarget(input: {
+  threadRef: ScopedThreadRef | undefined;
+  draftId: DraftId | undefined;
+}): boolean {
+  return input.threadRef !== undefined || input.draftId !== undefined;
+}
 function getProviderStateFromCapabilities(
   input: ComposerProviderStateInput,
 ): ComposerProviderState {
   codex: {
     getState: (input) => getProviderStateFromCapabilities(input),
     renderTraitsMenuContent: ({
-      threadId,
+      threadRef,
+      draftId,
+      model,
+      models,
+      modelOptions,
+      prompt,
+      onPromptChange,
+    }) =>
+      !hasComposerTraitsTarget({ threadRef, draftId }) ? null : (
+        <TraitsMenuContent
+          provider="codex"
+          models={models}
+          {...(threadRef ? { threadRef } : {})}
+          {...(draftId ? { draftId } : {})}
+          model={model}
+          modelOptions={modelOptions}
+          prompt={prompt}
+          onPromptChange={onPromptChange}
+        />
+      ),
+    renderTraitsPicker: ({
+      threadRef,
+      draftId,
       model,
       models,
       modelOptions,
       prompt,
       onPromptChange,
-    }) => (
+    }) =>
-      <TraitsMenuContent
+      !hasComposerTraitsTarget({ threadRef, draftId }) ? null : (
-        provider="codex"
+        <TraitsPicker
-        models={models}
+          provider="codex"
-        threadId={threadId}
+          models={models}
-        model={model}
+          {...(threadRef ? { threadRef } : {})}
-        modelOptions={modelOptions}
+          {...(draftId ? { draftId } : {})}
-        prompt={prompt}
+          model={model}
-        onPromptChange={onPromptChange}
+          modelOptions={modelOptions}
-      />
+          prompt={prompt}
-    ),
+          onPromptChange={onPromptChange}
-    renderTraitsPicker: ({ threadId, model, models, modelOptions, prompt, onPromptChange }) => (
+        />
-      <TraitsPicker
+      ),
-        provider="codex"
-        models={models}
-        threadId={threadId}
-        model={model}
-        modelOptions={modelOptions}
-        prompt={prompt}
-        onPromptChange={onPromptChange}
-      />
-    ),
   },
   claudeAgent: {
     getState: (input) => getProviderStateFromCapabilities(input),
     renderTraitsMenuContent: ({
-      threadId,
+      threadRef,
+      draftId,
+      model,
+      models,
+      modelOptions,
+      prompt,
+      onPromptChange,
+    }) =>
+      !hasComposerTraitsTarget({ threadRef, draftId }) ? null : (
+        <TraitsMenuContent
+          provider="claudeAgent"
+          models={models}
+          {...(threadRef ? { threadRef } : {})}
+          {...(draftId ? { draftId } : {})}
+          model={model}
+          modelOptions={modelOptions}
+          prompt={prompt}
+          onPromptChange={onPromptChange}
+        />
+      ),
+    renderTraitsPicker: ({
+      threadRef,
+      draftId,
       model,
       models,
       modelOptions,
       prompt,
       onPromptChange,
-    }) => (
+    }) =>
-      <TraitsMenuContent
+      !hasComposerTraitsTarget({ threadRef, draftId }) ? null : (
-        provider="claudeAgent"
+        <TraitsPicker
-        models={models}
+          provider="claudeAgent"
-        threadId={threadId}
+          models={models}
-        model={model}
+          {...(threadRef ? { threadRef } : {})}
-        modelOptions={modelOptions}
+          {...(draftId ? { draftId } : {})}
-        prompt={prompt}
+          model={model}
-        onPromptChange={onPromptChange}
+          modelOptions={modelOptions}
-      />
+          prompt={prompt}
-    ),
+          onPromptChange={onPromptChange}
-    renderTraitsPicker: ({ threadId, model, models, modelOptions, prompt, onPromptChange }) => (
+        />
-      <TraitsPicker
+      ),
-        provider="claudeAgent"
-        models={models}
-        threadId={threadId}
-        model={model}
-        modelOptions={modelOptions}
-        prompt={prompt}
-        onPromptChange={onPromptChange}
-      />
-    ),
   },
 };
 export function renderProviderTraitsMenuContent(input: {
   provider: ProviderKind;
-  threadId: ThreadId;
+  threadRef?: ScopedThreadRef;
+  draftId?: DraftId;
   model: string;
   models: ReadonlyArray<ServerProviderModel>;
   modelOptions: ProviderModelOptions[ProviderKind] | undefined;
   onPromptChange: (prompt: string) => void;
 }): ReactNode {
   return composerProviderRegistry[input.provider].renderTraitsMenuContent({
-    threadId: input.threadId,
+    ...(input.threadRef ? { threadRef: input.threadRef } : {}),
+    ...(input.draftId ? { draftId: input.draftId } : {}),
     model: input.model,
     models: input.models,
     modelOptions: input.modelOptions,
 export function renderProviderTraitsPicker(input: {
   provider: ProviderKind;
-  threadId: ThreadId;
+  threadRef?: ScopedThreadRef;
+  draftId?: DraftId;
   model: string;
   models: ReadonlyArray<ServerProviderModel>;
   modelOptions: ProviderModelOptions[ProviderKind] | undefined;
   onPromptChange: (prompt: string) => void;
 }): ReactNode {
   return composerProviderRegistry[input.provider].renderTraitsPicker({
-    threadId: input.threadId,
+    ...(input.threadRef ? { threadRef: input.threadRef } : {}),
+    ...(input.draftId ? { draftId: input.draftId } : {}),
     model: input.model,
     models: input.models,
     modelOptions: input.modelOptions,

apps/web/src/components/settings/SettingsPanels.browser.tsx+18−6

 import "../../index.css";
-import { DEFAULT_SERVER_SETTINGS, type NativeApi, type ServerConfig } from "@t3tools/contracts";
+import {
+  DEFAULT_SERVER_SETTINGS,
+  EnvironmentId,
+  type LocalApi,
+  type ServerConfig,
+} from "@t3tools/contracts";
 import { page } from "vitest/browser";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { render } from "vitest-browser-react";
-import { __resetNativeApiForTests } from "../../nativeApi";
+import { __resetLocalApiForTests } from "../../localApi";
 import { AppAtomRegistryProvider } from "../../rpc/atomRegistry";
 import { resetServerStateForTests, setServerConfigSnapshot } from "../../rpc/serverState";
 import { GeneralSettingsPanel } from "./SettingsPanels";
 function createBaseServerConfig(): ServerConfig {
   return {
+    environment: {
+      environmentId: EnvironmentId.makeUnsafe("environment-local"),
+      label: "Local environment",
+      platform: { os: "darwin" as const, arch: "arm64" as const },
+      serverVersion: "0.0.0-test",
+      capabilities: { repositoryIdentity: true },
+    },
     cwd: "/repo/project",
     keybindingsConfigPath: "/repo/project/.t3code-keybindings.json",
     keybindings: [],
 describe("GeneralSettingsPanel observability", () => {
   beforeEach(async () => {
     resetServerStateForTests();
-    await __resetNativeApiForTests();
+    await __resetLocalApiForTests();
     localStorage.clear();
     document.body.innerHTML = "";
   });
   afterEach(async () => {
     resetServerStateForTests();
-    await __resetNativeApiForTests();
+    await __resetLocalApiForTests();
     document.body.innerHTML = "";
   });
   });
   it("opens the logs folder in the preferred editor", async () => {
-    const openInEditor = vi.fn<NativeApi["shell"]["openInEditor"]>().mockResolvedValue(undefined);
+    const openInEditor = vi.fn<LocalApi["shell"]["openInEditor"]>().mockResolvedValue(undefined);
     window.nativeApi = {
       shell: {
         openInEditor,
       },
-    } as unknown as NativeApi;
+    } as unknown as LocalApi;
     setServerConfigSnapshot(createBaseServerConfig());

apps/web/src/components/settings/SettingsPanels.tsx+36−35

 import { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   PROVIDER_DISPLAY_NAMES,
+  type ScopedThreadRef,
   type ProviderKind,
   type ServerProvider,
   type ServerProviderModel,
-  ThreadId,
 } from "@t3tools/contracts";
+import { scopeThreadRef } from "@t3tools/client-runtime";
 import { DEFAULT_UNIFIED_SETTINGS } from "@t3tools/contracts/settings";
 import { normalizeModelSlug } from "@t3tools/shared/model";
 import { Equal } from "effect";
   getCustomModelOptionsByProvider,
   resolveAppModelSelectionState,
 } from "../../modelSelection";
-import { ensureNativeApi, readNativeApi } from "../../nativeApi";
+import { ensureLocalApi, readLocalApi } from "../../localApi";
-import { useStore } from "../../store";
+import {
+  selectProjectsAcrossEnvironments,
+  selectThreadsAcrossEnvironments,
+  useStore,
+} from "../../store";
 import { formatRelativeTime, formatRelativeTimeLabel } from "../../timestampFormat";
 import { cn } from "../../lib/utils";
 import { Button } from "../ui/button";
   const restoreDefaults = useCallback(async () => {
     if (changedSettingLabels.length === 0) return;
-    const api = readNativeApi();
+    const api = readLocalApi();
-    const confirmed = await (api ?? ensureNativeApi()).dialogs.confirm(
+    const confirmed = await (api ?? ensureLocalApi()).dialogs.confirm(
       ["Restore default settings?", `This will reset: ${changedSettingLabels.join(", ")}.`].join(
         "\n",
       ),
     if (refreshingRef.current) return;
     refreshingRef.current = true;
     setIsRefreshingProviders(true);
-    void ensureNativeApi()
+    void ensureLocalApi()
       .server.refreshProviders()
       .catch((error: unknown) => {
         console.warn("Failed to refresh providers", error);
         return;
       }
-      void ensureNativeApi()
+      void ensureLocalApi()
         .shell.openInEditor(path, editor)
         .catch((error) => {
           setOpenPathErrorByTarget((existing) => ({
 }
 export function ArchivedThreadsPanel() {
-  const projectIds = useStore((store) => store.projectIds);
+  const projects = useStore(selectProjectsAcrossEnvironments);
-  const projectById = useStore((store) => store.projectById);
+  const threads = useStore(selectThreadsAcrossEnvironments);
-  const threadIds = useStore((store) => store.threadIds);
-  const threadShellById = useStore((store) => store.threadShellById);
   const { unarchiveThread, confirmAndDeleteThread } = useThreadActions();
   const archivedGroups = useMemo(() => {
-    const projects = projectIds.flatMap((projectId) => {
-      const project = projectById[projectId];
-      return project ? [project] : [];
-    });
-    const threads = threadIds.flatMap((threadId) => {
-      const thread = threadShellById[threadId];
-      return thread ? [thread] : [];
-    });
     return projects
       .map((project) => ({
         project,
           }),
       }))
       .filter((group) => group.threads.length > 0);
-  }, [projectById, projectIds, threadIds, threadShellById]);
+  }, [projects, threads]);
   const handleArchivedThreadContextMenu = useCallback(
-    async (threadId: ThreadId, position: { x: number; y: number }) => {
+    async (threadRef: ScopedThreadRef, position: { x: number; y: number }) => {
-      const api = readNativeApi();
+      const api = readLocalApi();
       if (!api) return;
       const clicked = await api.contextMenu.show(
         [
       if (clicked === "unarchive") {
         try {
-          await unarchiveThread(threadId);
+          await unarchiveThread(threadRef);
         } catch (error) {
           toastManager.add({
             type: "error",
       }
       if (clicked === "delete") {
-        await confirmAndDeleteThread(threadId);
+        await confirmAndDeleteThread(threadRef);
       }
     },
     [confirmAndDeleteThread, unarchiveThread],
                 className="flex items-center justify-between gap-3 border-t border-border px-4 py-3 first:border-t-0 sm:px-5"
                 onContextMenu={(event) => {
                   event.preventDefault();
-                  void handleArchivedThreadContextMenu(thread.id, {
+                  void handleArchivedThreadContextMenu(
-                    x: event.clientX,
+                    scopeThreadRef(thread.environmentId, thread.id),
-                    y: event.clientY,
+                    {
-                  });
+                      x: event.clientX,
+                      y: event.clientY,
+                    },
+                  );
                 }}
               >
                 <div className="min-w-0 flex-1">
                   size="sm"
                   className="h-7 shrink-0 cursor-pointer gap-1.5 px-2.5"
                   onClick={() =>
-                    void unarchiveThread(thread.id).catch((error) => {
+                    void unarchiveThread(scopeThreadRef(thread.environmentId, thread.id)).catch(
-                      toastManager.add({
+                      (error) => {
-                        type: "error",
+                        toastManager.add({
-                        title: "Failed to unarchive thread",
+                          type: "error",
-                        description: error instanceof Error ? error.message : "An error occurred.",
+                          title: "Failed to unarchive thread",
-                      });
+                          description:
-                    })
+                            error instanceof Error ? error.message : "An error occurred.",
+                        });
+                      },
+                    )
                   }
                 >
                   <ArchiveX className="size-3.5" />

apps/web/src/composerDraftStore.test.ts+302−188

+import {
+  scopedProjectKey,
+  scopedThreadKey,
+  scopeProjectRef,
+  scopeThreadRef,
+} from "@t3tools/client-runtime";
 import * as Schema from "effect/Schema";
 import {
+  EnvironmentId,
   ProjectId,
   ThreadId,
   type ModelSelection,
 import {
   COMPOSER_DRAFT_STORAGE_KEY,
-  clearPromotedDraftThread,
+  finalizePromotedDraftThreadByRef,
-  clearPromotedDraftThreads,
+  markPromotedDraftThread,
+  markPromotedDraftThreadByRef,
+  markPromotedDraftThreads,
+  markPromotedDraftThreadsByRef,
   type ComposerImageAttachment,
   useComposerDraftStore,
+  DraftId,
 } from "./composerDraftStore";
 import { removeLocalStorageItem, setLocalStorageItem } from "./hooks/useLocalStorage";
 import {
 function resetComposerDraftStore() {
   useComposerDraftStore.setState({
-    draftsByThreadId: {},
+    draftsByThreadKey: {},
-    draftThreadsByThreadId: {},
+    draftThreadsByThreadKey: {},
-    projectDraftThreadIdByProjectId: {},
+    logicalProjectDraftThreadKeyByLogicalProjectKey: {},
     stickyModelSelectionByProvider: {},
     stickyActiveProvider: null,
   });
   return options;
 }
+const TEST_ENVIRONMENT_ID = EnvironmentId.makeUnsafe("environment-local");
+const OTHER_TEST_ENVIRONMENT_ID = EnvironmentId.makeUnsafe("environment-remote");
+const LEGACY_TEST_ENVIRONMENT_ID = EnvironmentId.makeUnsafe("__legacy__");
+function threadKeyFor(
+  threadId: ThreadId,
+  environmentId: EnvironmentId = LEGACY_TEST_ENVIRONMENT_ID,
+): string {
+  if (environmentId === LEGACY_TEST_ENVIRONMENT_ID) {
+    return threadId;
+  }
+  return scopedThreadKey(scopeThreadRef(environmentId, threadId));
+}
+function draftFor(threadId: ThreadId, environmentId: EnvironmentId = LEGACY_TEST_ENVIRONMENT_ID) {
+  const store = useComposerDraftStore.getState().draftsByThreadKey;
+  return store[threadKeyFor(threadId, environmentId)] ?? store[threadId] ?? undefined;
+}
+function draftByKey(key: string) {
+  return useComposerDraftStore.getState().draftsByThreadKey[key] ?? undefined;
+}
 describe("composerDraftStore addImages", () => {
   const threadId = ThreadId.makeUnsafe("thread-dedupe");
+  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
   let originalRevokeObjectUrl: typeof URL.revokeObjectURL;
   let revokeSpy: ReturnType<typeof vi.fn<(url: string) => void>>;
       lastModified: 12345,
     });
-    useComposerDraftStore.getState().addImages(threadId, [first, duplicate]);
+    useComposerDraftStore.getState().addImages(threadRef, [first, duplicate]);
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft?.images.map((image) => image.id)).toEqual(["img-1"]);
     expect(revokeSpy).toHaveBeenCalledWith("blob:duplicate");
   });
       lastModified: 999,
     });
-    useComposerDraftStore.getState().addImage(threadId, first);
+    useComposerDraftStore.getState().addImage(threadRef, first);
-    useComposerDraftStore.getState().addImage(threadId, duplicateLater);
+    useComposerDraftStore.getState().addImage(threadRef, duplicateLater);
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft?.images.map((image) => image.id)).toEqual(["img-a"]);
     expect(revokeSpy).toHaveBeenCalledWith("blob:b");
   });
       previewUrl: "blob:shared",
     });
-    useComposerDraftStore.getState().addImages(threadId, [first, duplicateSameUrl]);
+    useComposerDraftStore.getState().addImages(threadRef, [first, duplicateSameUrl]);
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft?.images.map((image) => image.id)).toEqual(["img-shared"]);
     expect(revokeSpy).not.toHaveBeenCalledWith("blob:shared");
   });
 describe("composerDraftStore clearComposerContent", () => {
   const threadId = ThreadId.makeUnsafe("thread-clear");
+  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
   let originalRevokeObjectUrl: typeof URL.revokeObjectURL;
   let revokeSpy: ReturnType<typeof vi.fn<(url: string) => void>>;
       id: "img-optimistic",
       previewUrl: "blob:optimistic",
     });
-    useComposerDraftStore.getState().addImage(threadId, first);
+    useComposerDraftStore.getState().addImage(threadRef, first);
-    useComposerDraftStore.getState().clearComposerContent(threadId);
+    useComposerDraftStore.getState().clearComposerContent(threadRef);
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft).toBeUndefined();
     expect(revokeSpy).not.toHaveBeenCalledWith("blob:optimistic");
   });
 describe("composerDraftStore syncPersistedAttachments", () => {
   const threadId = ThreadId.makeUnsafe("thread-sync-persisted");
+  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
   beforeEach(() => {
     removeLocalStorageItem(COMPOSER_DRAFT_STORAGE_KEY);
     useComposerDraftStore.setState({
-      draftsByThreadId: {},
+      draftsByThreadKey: {},
-      draftThreadsByThreadId: {},
+      draftThreadsByThreadKey: {},
-      projectDraftThreadIdByProjectId: {},
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
       stickyModelSelectionByProvider: {},
       stickyActiveProvider: null,
     });
       id: "img-persisted",
       previewUrl: "blob:persisted",
     });
-    useComposerDraftStore.getState().addImage(threadId, image);
+    useComposerDraftStore.getState().addImage(threadRef, image);
     setLocalStorageItem(
       COMPOSER_DRAFT_STORAGE_KEY,
       {
       Schema.Unknown,
     );
-    useComposerDraftStore.getState().syncPersistedAttachments(threadId, [
+    useComposerDraftStore.getState().syncPersistedAttachments(threadRef, [
       {
         id: image.id,
         name: image.name,
     ]);
     await Promise.resolve();
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.persistedAttachments).toEqual([]);
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.persistedAttachments,
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.nonPersistedImageIds).toEqual([image.id]);
-    ).toEqual([]);
-    expect(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.nonPersistedImageIds,
-    ).toEqual([image.id]);
   });
 });
 describe("composerDraftStore terminal contexts", () => {
   const threadId = ThreadId.makeUnsafe("thread-dedupe");
+  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
   beforeEach(() => {
     useComposerDraftStore.setState({
-      draftsByThreadId: {},
+      draftsByThreadKey: {},
-      draftThreadsByThreadId: {},
+      draftThreadsByThreadKey: {},
-      projectDraftThreadIdByProjectId: {},
+      logicalProjectDraftThreadKeyByLogicalProjectKey: {},
       stickyModelSelectionByProvider: {},
       stickyActiveProvider: null,
     });
     const first = makeTerminalContext({ id: "ctx-1" });
     const duplicate = makeTerminalContext({ id: "ctx-2" });
-    useComposerDraftStore.getState().addTerminalContexts(threadId, [first, duplicate]);
+    useComposerDraftStore.getState().addTerminalContexts(threadRef, [first, duplicate]);
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft?.terminalContexts.map((context) => context.id)).toEqual(["ctx-1"]);
   });
   it("clears terminal contexts when clearing composer content", () => {
     useComposerDraftStore
       .getState()
-      .addTerminalContext(threadId, makeTerminalContext({ id: "ctx-1" }));
+      .addTerminalContext(threadRef, makeTerminalContext({ id: "ctx-1" }));
-    useComposerDraftStore.getState().clearComposerContent(threadId);
+    useComposerDraftStore.getState().clearComposerContent(threadRef);
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toBeUndefined();
   });
   it("inserts terminal contexts at the requested inline prompt position", () => {
       useComposerDraftStore
         .getState()
         .insertTerminalContext(
-          threadId,
+          threadRef,
           firstInsertion.prompt,
           makeTerminalContext({ id: "ctx-1" }),
           firstInsertion.contextIndex,
     ).toBe(true);
     expect(
       useComposerDraftStore.getState().insertTerminalContext(
-        threadId,
+        threadRef,
         secondInsertion.prompt,
         makeTerminalContext({
           id: "ctx-2",
       ),
     ).toBe(true);
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft?.prompt).toBe(
       `${INLINE_TERMINAL_CONTEXT_PLACEHOLDER} alpha ${INLINE_TERMINAL_CONTEXT_PLACEHOLDER} beta`,
     );
   it("omits terminal context text from persisted drafts", () => {
     useComposerDraftStore
       .getState()
-      .addTerminalContext(threadId, makeTerminalContext({ id: "ctx-persist" }));
+      .addTerminalContext(threadRef, makeTerminalContext({ id: "ctx-persist" }));
     const persistApi = useComposerDraftStore.persist as unknown as {
       getOptions: () => {
       };
     };
     const persistedState = persistApi.getOptions().partialize(useComposerDraftStore.getState()) as {
-      draftsByThreadId?: Record<string, { terminalContexts?: Array<Record<string, unknown>> }>;
+      draftsByThreadKey?: Record<string, { terminalContexts?: Array<Record<string, unknown>> }>;
     };
     expect(
-      persistedState.draftsByThreadId?.[threadId]?.terminalContexts?.[0],
+      persistedState.draftsByThreadKey?.[threadKeyFor(threadId, TEST_ENVIRONMENT_ID)]
+        ?.terminalContexts?.[0],
       "Expected terminal context metadata to be persisted.",
     ).toMatchObject({
       id: "ctx-persist",
       lineEnd: 5,
     });
     expect(
-      persistedState.draftsByThreadId?.[threadId]?.terminalContexts?.[0]?.text,
+      persistedState.draftsByThreadKey?.[threadKeyFor(threadId, TEST_ENVIRONMENT_ID)]
+        ?.terminalContexts?.[0]?.text,
     ).toBeUndefined();
   });
           },
         },
         draftThreadsByThreadId: {},
-        projectDraftThreadIdByProjectId: {},
+        projectDraftThreadIdByProjectKey: {},
       },
       useComposerDraftStore.getInitialState(),
     );
-    expect(mergedState.draftsByThreadId[threadId]?.terminalContexts).toMatchObject([
+    expect(mergedState.draftsByThreadKey[threadKeyFor(threadId)]?.terminalContexts).toMatchObject([
       {
         id: "ctx-rehydrated",
         terminalId: "default",
           },
         },
         draftThreadsByThreadId: "not-an-object",
-        projectDraftThreadIdByProjectId: "not-an-object",
+        projectDraftThreadIdByProjectKey: "not-an-object",
       },
       useComposerDraftStore.getInitialState(),
     );
-    expect(mergedState.draftsByThreadId[threadId]).toBeUndefined();
+    expect(mergedState.draftsByThreadKey[threadKeyFor(threadId)]).toBeUndefined();
-    expect(mergedState.draftThreadsByThreadId).toEqual({});
+    expect(mergedState.draftThreadsByThreadKey).toEqual({});
-    expect(mergedState.projectDraftThreadIdByProjectId).toEqual({});
+    expect(mergedState.logicalProjectDraftThreadKeyByLogicalProjectKey).toEqual({});
   });
 });
 describe("composerDraftStore project draft thread mapping", () => {
   const projectId = ProjectId.makeUnsafe("project-a");
   const otherProjectId = ProjectId.makeUnsafe("project-b");
+  const projectRef = scopeProjectRef(TEST_ENVIRONMENT_ID, projectId);
+  const otherProjectRef = scopeProjectRef(TEST_ENVIRONMENT_ID, otherProjectId);
+  const remoteProjectRef = scopeProjectRef(OTHER_TEST_ENVIRONMENT_ID, projectId);
   const threadId = ThreadId.makeUnsafe("thread-a");
   const otherThreadId = ThreadId.makeUnsafe("thread-b");
+  const draftId = DraftId.makeUnsafe("draft-a");
+  const otherDraftId = DraftId.makeUnsafe("draft-b");
+  const sharedDraftId = DraftId.makeUnsafe("draft-shared");
+  const localDraftId = DraftId.makeUnsafe("draft-local");
+  const remoteDraftId = DraftId.makeUnsafe("draft-remote");
   beforeEach(() => {
     resetComposerDraftStore();
   it("stores and reads project draft thread ids via actions", () => {
     const store = useComposerDraftStore.getState();
-    expect(store.getDraftThreadByProjectId(projectId)).toBeNull();
+    expect(store.getDraftThreadByProjectRef(projectRef)).toBeNull();
-    expect(store.getDraftThread(threadId)).toBeNull();
+    expect(store.getDraftThread(draftId)).toBeNull();
-    store.setProjectDraftThreadId(projectId, threadId, {
+    store.setProjectDraftThreadId(projectRef, draftId, {
+      threadId,
       branch: "feature/test",
       worktreePath: "/tmp/worktree-test",
       createdAt: "2026-01-01T00:00:00.000Z",
     });
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)).toEqual({
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toMatchObject({
       threadId,
+      environmentId: TEST_ENVIRONMENT_ID,
       projectId,
+      logicalProjectKey: scopedProjectKey(projectRef),
       branch: "feature/test",
       worktreePath: "/tmp/worktree-test",
       envMode: "worktree",
       interactionMode: "default",
       createdAt: "2026-01-01T00:00:00.000Z",
     });
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toEqual({
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
+      environmentId: TEST_ENVIRONMENT_ID,
       projectId,
+      logicalProjectKey: scopedProjectKey(projectRef),
       branch: "feature/test",
       worktreePath: "/tmp/worktree-test",
       envMode: "worktree",
   it("clears only matching project draft mapping entries", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId);
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
-    store.setPrompt(threadId, "hello");
+    store.setPrompt(draftId, "hello");
-    store.clearProjectDraftThreadById(projectId, otherThreadId);
+    store.clearProjectDraftThreadById(projectRef, otherDraftId);
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)?.threadId).toBe(
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
       threadId,
     );
-    store.clearProjectDraftThreadById(projectId, threadId);
+    store.clearProjectDraftThreadById(projectRef, draftId);
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+    expect(draftByKey(draftId)).toBeUndefined();
   });
   it("clears project draft mapping by project id", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId);
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
-    store.setPrompt(threadId, "hello");
+    store.setPrompt(draftId, "hello");
-    store.clearProjectDraftThreadId(projectId);
+    store.clearProjectDraftThreadId(projectRef);
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+    expect(draftByKey(draftId)).toBeUndefined();
   });
   it("clears orphaned composer drafts when remapping a project to a new draft thread", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId);
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
-    store.setPrompt(threadId, "orphan me");
+    store.setPrompt(draftId, "orphan me");
-    store.setProjectDraftThreadId(projectId, otherThreadId);
+    store.setProjectDraftThreadId(projectRef, otherDraftId, { threadId: otherThreadId });
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)?.threadId).toBe(
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
       otherThreadId,
     );
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+    expect(draftByKey(draftId)).toBeUndefined();
   });
   it("keeps composer drafts when the thread is still mapped by another project", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId);
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
-    store.setProjectDraftThreadId(otherProjectId, threadId);
+    store.setProjectDraftThreadId(otherProjectRef, sharedDraftId, { threadId });
-    store.setPrompt(threadId, "keep me");
+    store.setPrompt(sharedDraftId, "keep me");
-    store.clearProjectDraftThreadId(projectId);
+    store.clearProjectDraftThreadId(projectRef);
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
     expect(
-      useComposerDraftStore.getState().getDraftThreadByProjectId(otherProjectId)?.threadId,
+      useComposerDraftStore.getState().getDraftThreadByProjectRef(otherProjectRef)?.threadId,
     ).toBe(threadId);
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]?.prompt).toBe("keep me");
+    expect(draftByKey(sharedDraftId)?.prompt).toBe("keep me");
   });
   it("clears draft registration independently", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId);
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
-    store.setPrompt(threadId, "remove me");
+    store.setPrompt(draftId, "remove me");
-    store.clearDraftThread(threadId);
+    store.clearDraftThread(draftId);
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+    expect(draftByKey(draftId)).toBeUndefined();
+  });
+  it("marks a promoted draft by thread id without deleting composer state", () => {
+    const store = useComposerDraftStore.getState();
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
+    store.setPrompt(draftId, "promote me");
+    markPromotedDraftThread(threadId);
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)?.promotedTo).toEqual(
+      scopeThreadRef(TEST_ENVIRONMENT_ID, threadId),
+    );
+    expect(draftByKey(draftId)?.prompt).toBe("promote me");
   });
-  it("clears a promoted draft by thread id", () => {
+  it("reads local draft composer state through a scoped thread ref", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId);
+    const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
-    store.setPrompt(threadId, "promote me");
-    clearPromotedDraftThread(threadId);
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
+    store.setPrompt(draftId, "scoped access");
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)).toBeNull();
+    expect(store.getComposerDraft(draftId)?.prompt).toBe("scoped access");
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+    expect(store.getComposerDraft(threadRef)?.prompt).toBe("scoped access");
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
   });
   it("does not clear composer drafts for existing server threads during promotion cleanup", () => {
     const store = useComposerDraftStore.getState();
-    store.setPrompt(threadId, "keep me");
+    const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
+    store.setPrompt(threadRef, "keep me");
-    clearPromotedDraftThread(threadId);
+    markPromotedDraftThread(threadId);
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(threadRef)).toBeNull();
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]?.prompt).toBe("keep me");
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.prompt).toBe("keep me");
   });
-  it("clears promoted drafts from an iterable of server thread ids", () => {
+  it("marks promoted drafts from an iterable of server thread ids", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId);
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
-    store.setPrompt(threadId, "promote me");
+    store.setPrompt(draftId, "promote me");
-    store.setProjectDraftThreadId(otherProjectId, otherThreadId);
+    store.setProjectDraftThreadId(otherProjectRef, otherDraftId, { threadId: otherThreadId });
-    store.setPrompt(otherThreadId, "keep me");
+    store.setPrompt(otherDraftId, "keep me");
-    clearPromotedDraftThreads([threadId]);
+    markPromotedDraftThreads([threadId]);
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)?.promotedTo).toEqual(
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+      scopeThreadRef(TEST_ENVIRONMENT_ID, threadId),
+    );
+    expect(draftByKey(draftId)?.prompt).toBe("promote me");
     expect(
-      useComposerDraftStore.getState().getDraftThreadByProjectId(otherProjectId)?.threadId,
+      useComposerDraftStore.getState().getDraftThreadByProjectRef(otherProjectRef)?.threadId,
     ).toBe(otherThreadId);
-    expect(useComposerDraftStore.getState().draftsByThreadId[otherThreadId]?.prompt).toBe(
+    expect(draftByKey(otherDraftId)?.prompt).toBe("keep me");
-      "keep me",
+  });
+  it("marks every matching scoped draft when multiple environments share a thread id", () => {
+    const store = useComposerDraftStore.getState();
+    const localThreadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
+    const remoteThreadRef = scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, threadId);
+    store.setProjectDraftThreadId(projectRef, localDraftId, { threadId });
+    store.setPrompt(localDraftId, "local draft");
+    store.setProjectDraftThreadId(remoteProjectRef, remoteDraftId, { threadId });
+    store.setPrompt(remoteDraftId, "remote draft");
+    markPromotedDraftThread(threadId);
+    expect(store.getDraftThreadByProjectRef(projectRef)).toBeNull();
+    expect(store.getDraftThreadByProjectRef(remoteProjectRef)).toBeNull();
+    expect(store.getDraftThreadByRef(localThreadRef)?.promotedTo).toEqual(localThreadRef);
+    expect(store.getDraftThreadByRef(remoteThreadRef)?.promotedTo).toEqual(remoteThreadRef);
+    expect(draftByKey(localDraftId)?.prompt).toBe("local draft");
+    expect(draftByKey(remoteDraftId)?.prompt).toBe("remote draft");
+  });
+  it("only marks promoted drafts for the matching environment ref", () => {
+    const store = useComposerDraftStore.getState();
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
+    store.setPrompt(draftId, "promote me");
+    markPromotedDraftThreadByRef(scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, threadId));
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
+      threadId,
+    );
+    expect(draftByKey(draftId)?.prompt).toBe("promote me");
+  });
+  it("only marks iterable promotion cleanup entries for the matching environment refs", () => {
+    const store = useComposerDraftStore.getState();
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
+    store.setPrompt(draftId, "promote me");
+    markPromotedDraftThreadsByRef([scopeThreadRef(OTHER_TEST_ENVIRONMENT_ID, threadId)]);
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
+      threadId,
     );
+    expect(draftByKey(draftId)?.prompt).toBe("promote me");
   });
   it("keeps existing server-thread composer drafts during iterable promotion cleanup", () => {
     const store = useComposerDraftStore.getState();
-    store.setPrompt(threadId, "keep me");
+    const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
+    store.setPrompt(threadRef, "keep me");
-    clearPromotedDraftThreads([threadId]);
+    markPromotedDraftThreads([threadId]);
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(threadRef)).toBeNull();
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]?.prompt).toBe("keep me");
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.prompt).toBe("keep me");
+  });
+  it("finalizes a promoted draft after the canonical thread route is active", () => {
+    const store = useComposerDraftStore.getState();
+    store.setProjectDraftThreadId(projectRef, draftId, { threadId });
+    store.setPrompt(draftId, "promote me");
+    markPromotedDraftThread(threadId);
+    finalizePromotedDraftThreadByRef(scopeThreadRef(TEST_ENVIRONMENT_ID, threadId));
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)).toBeNull();
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toBeNull();
+    expect(draftByKey(draftId)).toBeUndefined();
   });
   it("updates branch context on an existing draft thread", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId, {
+    store.setProjectDraftThreadId(projectRef, draftId, {
+      threadId,
       branch: "main",
       worktreePath: null,
     });
-    store.setDraftThreadContext(threadId, {
+    store.setDraftThreadContext(draftId, {
       branch: "feature/next",
       worktreePath: "/tmp/feature-next",
     });
-    expect(useComposerDraftStore.getState().getDraftThreadByProjectId(projectId)?.threadId).toBe(
+    expect(useComposerDraftStore.getState().getDraftThreadByProjectRef(projectRef)?.threadId).toBe(
       threadId,
     );
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toMatchObject({
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
+      environmentId: TEST_ENVIRONMENT_ID,
       projectId,
       branch: "feature/next",
       worktreePath: "/tmp/feature-next",
   it("preserves existing branch and worktree when setProjectDraftThreadId receives undefined", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId, {
+    store.setProjectDraftThreadId(projectRef, draftId, {
+      threadId,
       branch: "main",
       worktreePath: "/tmp/main-worktree",
     });
       branch?: string | null;
       worktreePath?: string | null;
     };
-    store.setProjectDraftThreadId(projectId, threadId, runtimeUndefinedOptions);
+    store.setProjectDraftThreadId(projectRef, draftId, runtimeUndefinedOptions);
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toMatchObject({
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
+      environmentId: TEST_ENVIRONMENT_ID,
       projectId,
       branch: "main",
       worktreePath: "/tmp/main-worktree",
   it("preserves worktree env mode without a worktree path", () => {
     const store = useComposerDraftStore.getState();
-    store.setProjectDraftThreadId(projectId, threadId, {
+    store.setProjectDraftThreadId(projectRef, draftId, {
+      threadId,
       branch: "feature/base",
       worktreePath: null,
       envMode: "worktree",
       worktreePath?: string | null;
       envMode?: "local" | "worktree";
     };
-    store.setProjectDraftThreadId(projectId, threadId, runtimeUndefinedOptions);
+    store.setProjectDraftThreadId(projectRef, draftId, runtimeUndefinedOptions);
-    expect(useComposerDraftStore.getState().getDraftThread(threadId)).toMatchObject({
+    expect(useComposerDraftStore.getState().getDraftThread(draftId)).toMatchObject({
+      environmentId: TEST_ENVIRONMENT_ID,
       projectId,
       branch: "feature/base",
       worktreePath: null,
 describe("composerDraftStore modelSelection", () => {
   const threadId = ThreadId.makeUnsafe("thread-model-options");
+  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
   beforeEach(() => {
     resetComposerDraftStore();
   it("stores a model selection in the draft", () => {
     const store = useComposerDraftStore.getState();
     store.setModelSelection(
-      threadId,
+      threadRef,
       modelSelection("codex", "gpt-5.3-codex", {
         reasoningEffort: "xhigh",
         fastMode: true,
       }),
     );
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider.codex).toEqual(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.modelSelectionByProvider.codex,
-    ).toEqual(
       modelSelection("codex", "gpt-5.3-codex", {
         reasoningEffort: "xhigh",
         fastMode: true,
   it("keeps default-only model selections on the draft", () => {
     const store = useComposerDraftStore.getState();
-    store.setModelSelection(threadId, modelSelection("codex", "gpt-5.4"));
+    store.setModelSelection(threadRef, modelSelection("codex", "gpt-5.4"));
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider.codex).toEqual(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.modelSelectionByProvider.codex,
+      modelSelection("codex", "gpt-5.4"),
-    ).toEqual(modelSelection("codex", "gpt-5.4"));
+    );
   });
   it("replaces only the targeted provider options on the current model selection", () => {
     const store = useComposerDraftStore.getState();
     store.setModelSelection(
-      threadId,
+      threadRef,
       modelSelection("claudeAgent", "claude-opus-4-6", {
         effort: "max",
         fastMode: true,
     );
     store.setProviderModelOptions(
-      threadId,
+      threadRef,
       "claudeAgent",
       {
         thinking: false,
       { persistSticky: true },
     );
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider.claudeAgent).toEqual(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.modelSelectionByProvider
-        .claudeAgent,
-    ).toEqual(
       modelSelection("claudeAgent", "claude-opus-4-6", {
         thinking: false,
       }),
     const store = useComposerDraftStore.getState();
     store.setModelSelection(
-      threadId,
+      threadRef,
       modelSelection("claudeAgent", "claude-opus-4-6", {
         effort: "max",
       }),
     );
-    store.setProviderModelOptions(threadId, "claudeAgent", {
+    store.setProviderModelOptions(threadRef, "claudeAgent", {
       thinking: true,
     });
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider.claudeAgent).toEqual(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.modelSelectionByProvider
-        .claudeAgent,
-    ).toEqual(
       modelSelection("claudeAgent", "claude-opus-4-6", {
         thinking: true,
       }),
   it("keeps explicit off/default codex overrides on the selection", () => {
     const store = useComposerDraftStore.getState();
-    store.setModelSelection(threadId, modelSelection("codex", "gpt-5.4", { fastMode: true }));
+    store.setModelSelection(threadRef, modelSelection("codex", "gpt-5.4", { fastMode: true }));
-    store.setProviderModelOptions(threadId, "codex", {
+    store.setProviderModelOptions(threadRef, "codex", {
       reasoningEffort: "high",
       fastMode: false,
     });
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider.codex).toEqual(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.modelSelectionByProvider.codex,
-    ).toEqual(
       modelSelection("codex", "gpt-5.4", {
         reasoningEffort: "high",
         fastMode: false,
       modelSelection("claudeAgent", "claude-opus-4-6", { effort: "max" }),
     );
     store.setModelSelection(
-      threadId,
+      threadRef,
       modelSelection("claudeAgent", "claude-opus-4-6", { effort: "max" }),
     );
-    store.setProviderModelOptions(threadId, "claudeAgent", {
+    store.setProviderModelOptions(threadRef, "claudeAgent", {
       thinking: false,
     });
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider.claudeAgent).toEqual(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.modelSelectionByProvider
-        .claudeAgent,
-    ).toEqual(
       modelSelection("claudeAgent", "claude-opus-4-6", {
         thinking: false,
       }),
     // Set options for both providers
     store.setModelOptions(
-      threadId,
+      threadRef,
       providerModelOptions({
         codex: { fastMode: true },
         claudeAgent: { effort: "max" },
     );
     // Now set options for only codex — claudeAgent should be untouched
-    store.setModelOptions(threadId, providerModelOptions({ codex: { reasoningEffort: "xhigh" } }));
+    store.setModelOptions(threadRef, providerModelOptions({ codex: { reasoningEffort: "xhigh" } }));
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft?.modelSelectionByProvider.codex?.options).toEqual({ reasoningEffort: "xhigh" });
     expect(draft?.modelSelectionByProvider.claudeAgent?.options).toEqual({ effort: "max" });
   });
     const store = useComposerDraftStore.getState();
     store.setModelOptions(
-      threadId,
+      threadRef,
       providerModelOptions({
         codex: { fastMode: true },
         claudeAgent: { effort: "max" },
       }),
     );
-    store.setModelSelection(threadId, modelSelection("claudeAgent", "claude-opus-4-6"));
+    store.setModelSelection(threadRef, modelSelection("claudeAgent", "claude-opus-4-6"));
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft?.modelSelectionByProvider.claudeAgent).toEqual(
       modelSelection("claudeAgent", "claude-opus-4-6", { effort: "max" }),
     );
   it("creates the first sticky snapshot from provider option changes", () => {
     const store = useComposerDraftStore.getState();
-    store.setModelSelection(threadId, modelSelection("codex", "gpt-5.4"));
+    store.setModelSelection(threadRef, modelSelection("codex", "gpt-5.4"));
     store.setProviderModelOptions(
-      threadId,
+      threadRef,
       "codex",
       {
         fastMode: true,
       modelSelection("claudeAgent", "claude-opus-4-6", { effort: "max" }),
     );
     store.setModelSelection(
-      threadId,
+      threadRef,
       modelSelection("claudeAgent", "claude-opus-4-6", { effort: "max" }),
     );
     store.setProviderModelOptions(
-      threadId,
+      threadRef,
       "claudeAgent",
       {
         thinking: false,
       { persistSticky: false },
     );
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider.claudeAgent).toEqual(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.modelSelectionByProvider
-        .claudeAgent,
-    ).toEqual(
       modelSelection("claudeAgent", "claude-opus-4-6", {
         thinking: false,
       }),
 describe("composerDraftStore setModelSelection", () => {
   const threadId = ThreadId.makeUnsafe("thread-model");
+  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
   beforeEach(() => {
     resetComposerDraftStore();
   it("keeps explicit model overrides instead of coercing to null", () => {
     const store = useComposerDraftStore.getState();
-    store.setModelSelection(threadId, modelSelection("codex", "gpt-5.3-codex"));
+    store.setModelSelection(threadRef, modelSelection("codex", "gpt-5.3-codex"));
-    expect(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.modelSelectionByProvider.codex).toEqual(
-      useComposerDraftStore.getState().draftsByThreadId[threadId]?.modelSelectionByProvider.codex,
+      modelSelection("codex", "gpt-5.3-codex"),
-    ).toEqual(modelSelection("codex", "gpt-5.3-codex"));
+    );
   });
 });
   it("applies sticky activeProvider to new drafts", () => {
     const store = useComposerDraftStore.getState();
     const threadId = ThreadId.makeUnsafe("thread-sticky-active-provider");
+    const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
     store.setStickyModelSelection(modelSelection("claudeAgent", "claude-opus-4-6"));
-    store.applyStickyState(threadId);
+    store.applyStickyState(threadRef);
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toMatchObject({
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toMatchObject({
       modelSelectionByProvider: {
         claudeAgent: modelSelection("claudeAgent", "claude-opus-4-6"),
       },
 describe("composerDraftStore provider-scoped option updates", () => {
   const threadId = ThreadId.makeUnsafe("thread-provider");
+  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
   beforeEach(() => {
     resetComposerDraftStore();
   it("retains off-provider option memory without changing the active selection", () => {
     const store = useComposerDraftStore.getState();
     store.setModelSelection(
-      threadId,
+      threadRef,
       modelSelection("codex", "gpt-5.3-codex", {
         reasoningEffort: "medium",
       }),
     );
-    store.setProviderModelOptions(threadId, "claudeAgent", { effort: "max" });
+    store.setProviderModelOptions(threadRef, "claudeAgent", { effort: "max" });
-    const draft = useComposerDraftStore.getState().draftsByThreadId[threadId];
+    const draft = draftFor(threadId, TEST_ENVIRONMENT_ID);
     expect(draft?.modelSelectionByProvider.codex).toEqual(
       modelSelection("codex", "gpt-5.3-codex", { reasoningEffort: "medium" }),
     );
 describe("composerDraftStore runtime and interaction settings", () => {
   const threadId = ThreadId.makeUnsafe("thread-settings");
+  const threadRef = scopeThreadRef(TEST_ENVIRONMENT_ID, threadId);
   beforeEach(() => {
     resetComposerDraftStore();
   it("stores runtime mode overrides in the composer draft", () => {
     const store = useComposerDraftStore.getState();
-    store.setRuntimeMode(threadId, "approval-required");
+    store.setRuntimeMode(threadRef, "approval-required");
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]?.runtimeMode).toBe(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.runtimeMode).toBe("approval-required");
-      "approval-required",
-    );
   });
   it("stores interaction mode overrides in the composer draft", () => {
     const store = useComposerDraftStore.getState();
-    store.setInteractionMode(threadId, "plan");
+    store.setInteractionMode(threadRef, "plan");
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]?.interactionMode).toBe(
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)?.interactionMode).toBe("plan");
-      "plan",
-    );
   });
   it("removes empty settings-only drafts when overrides are cleared", () => {
     const store = useComposerDraftStore.getState();
-    store.setRuntimeMode(threadId, "approval-required");
+    store.setRuntimeMode(threadRef, "approval-required");
-    store.setInteractionMode(threadId, "plan");
+    store.setInteractionMode(threadRef, "plan");
-    store.setRuntimeMode(threadId, null);
+    store.setRuntimeMode(threadRef, null);
-    store.setInteractionMode(threadId, null);
+    store.setInteractionMode(threadRef, null);
-    expect(useComposerDraftStore.getState().draftsByThreadId[threadId]).toBeUndefined();
+    expect(draftFor(threadId, TEST_ENVIRONMENT_ID)).toBeUndefined();
   });
 });

apps/web/src/composerDraftStore.ts+1572−948

@@ -3,6 +3,7 @@ import { · 2 unmodified lines
3	type ClaudeCodeEffort,	3	type ClaudeCodeEffort,
4	type CodexReasoningEffort,	4	type CodexReasoningEffort,
5	DEFAULT_MODEL_BY_PROVIDER,	5	DEFAULT_MODEL_BY_PROVIDER,
		6	type EnvironmentId,
6	ModelSelection,	7	ModelSelection,
7	ProjectId,	8	ProjectId,
8	ProviderInteractionMode,	9	ProviderInteractionMode,
@@ -10,8 +11,18 @@ import { · 1 unmodified line
10	ProviderModelOptions,	11	ProviderModelOptions,
11	RuntimeMode,	12	RuntimeMode,
12	type ServerProvider,	13	type ServerProvider,
		14	type ScopedProjectRef,
		15	type ScopedThreadRef,
13	ThreadId,	16	ThreadId,
14	} from "@t3tools/contracts";	17	} from "@t3tools/contracts";
		18	import {
		19	parseScopedProjectKey,
		20	parseScopedThreadKey,
		21	scopedProjectKey,
		22	scopeProjectRef,
		23	scopedThreadKey,
		24	scopeThreadRef,
		25	} from "@t3tools/client-runtime";
15	import * as Schema from "effect/Schema";	26	import * as Schema from "effect/Schema";
16	import * as Equal from "effect/Equal";	27	import * as Equal from "effect/Equal";
17	import { DeepMutable } from "effect/Types";	28	import { DeepMutable } from "effect/Types";
@@ -32,10 +43,13 @@ import { getDefaultServerModel } from "./providerModels"; · 14 unmodified lines
32	import { UnifiedSettings } from "@t3tools/contracts/settings";	43	import { UnifiedSettings } from "@t3tools/contracts/settings";
33		44
34	export const COMPOSER_DRAFT_STORAGE_KEY = "t3code:composer-drafts:v1";	45	export const COMPOSER_DRAFT_STORAGE_KEY = "t3code:composer-drafts:v1";
35	const COMPOSER_DRAFT_STORAGE_VERSION = 3;	46	const COMPOSER_DRAFT_STORAGE_VERSION = 5;
36	const DraftThreadEnvModeSchema = Schema.Literals(["local", "worktree"]);	47	const DraftThreadEnvModeSchema = Schema.Literals(["local", "worktree"]);
37	export type DraftThreadEnvMode = typeof DraftThreadEnvModeSchema.Type;	48	export type DraftThreadEnvMode = typeof DraftThreadEnvModeSchema.Type;
38		49
		50	export const DraftId = Schema.String.pipe(Schema.brand("DraftId"));
		51	export type DraftId = typeof DraftId.Type;
		52
39	const COMPOSER_PERSIST_DEBOUNCE_MS = 300;	53	const COMPOSER_PERSIST_DEBOUNCE_MS = 300;
40		54
41	const composerDebouncedStorage = createDebouncedStorage(	55	const composerDebouncedStorage = createDebouncedStorage(
@@ -44,7 +58,7 @@ const composerDebouncedStorage = createDebouncedStorage( · 2 unmodified lines
44	);	58	);
45		59
46	// Flush pending composer draft writes before page unload to prevent data loss.	60	// Flush pending composer draft writes before page unload to prevent data loss.
47	if (typeof window !== "undefined") {	61	if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
48	window.addEventListener("beforeunload", () => {	62	window.addEventListener("beforeunload", () => {
49	composerDebouncedStorage.flush();	63	composerDebouncedStorage.flush();
50	});	64	});
@@ -122,6 +136,14 @@ type LegacyStickyModelFields = typeof LegacyStickyModelFields.Type; · 71 unmodified lines
122	type LegacyV2StoreFields = {	136	type LegacyV2StoreFields = {
123	stickyModelSelection?: ModelSelection \| null;	137	stickyModelSelection?: ModelSelection \| null;
124	stickyModelOptions?: ProviderModelOptions \| null;	138	stickyModelOptions?: ProviderModelOptions \| null;
		139	projectDraftThreadIdByProjectId?: Record<string, string> \| null;
		140	draftsByThreadId?: Record<string, PersistedComposerThreadDraftState> \| null;
		141	draftThreadsByThreadId?: Record<string, PersistedDraftThreadState> \| null;
		142	projectDraftThreadIdByProjectKey?: Record<string, string> \| null;
		143	draftsByThreadKey?: Record<string, PersistedComposerThreadDraftState> \| null;
		144	draftThreadsByThreadKey?: Record<string, PersistedDraftThreadState> \| null;
		145	projectDraftThreadKeyByProjectKey?: Record<string, string> \| null;
		146	logicalProjectDraftThreadKeyByLogicalProjectKey?: Record<string, string> \| null;
125	};	147	};
126		148
127	type LegacyPersistedComposerDraftStoreState = PersistedComposerDraftStoreState &	149	type LegacyPersistedComposerDraftStoreState = PersistedComposerDraftStoreState &
@@ -129,20 +151,31 @@ type LegacyPersistedComposerDraftStoreState = PersistedComposerDraftStoreState & · 1 unmodified line
129	LegacyV2StoreFields;	151	LegacyV2StoreFields;
130		152
131	const PersistedDraftThreadState = Schema.Struct({	153	const PersistedDraftThreadState = Schema.Struct({
		154	threadId: ThreadId,
		155	environmentId: Schema.String,
132	projectId: ProjectId,	156	projectId: ProjectId,
		157	logicalProjectKey: Schema.optionalKey(Schema.String),
133	createdAt: Schema.String,	158	createdAt: Schema.String,
134	runtimeMode: RuntimeMode,	159	runtimeMode: RuntimeMode,
135	interactionMode: ProviderInteractionMode,	160	interactionMode: ProviderInteractionMode,
136	branch: Schema.NullOr(Schema.String),	161	branch: Schema.NullOr(Schema.String),
137	worktreePath: Schema.NullOr(Schema.String),	162	worktreePath: Schema.NullOr(Schema.String),
138	envMode: DraftThreadEnvModeSchema,	163	envMode: DraftThreadEnvModeSchema,
		164	promotedTo: Schema.optionalKey(
		165	Schema.NullOr(
		166	Schema.Struct({
		167	environmentId: Schema.String,
		168	threadId: Schema.String,
		169	}),
		170	),
		171	),
139	});	172	});
140	type PersistedDraftThreadState = typeof PersistedDraftThreadState.Type;	173	type PersistedDraftThreadState = typeof PersistedDraftThreadState.Type;
141		174
142	const PersistedComposerDraftStoreState = Schema.Struct({	175	const PersistedComposerDraftStoreState = Schema.Struct({
143	draftsByThreadId: Schema.Record(ThreadId, PersistedComposerThreadDraftState),	176	draftsByThreadKey: Schema.Record(Schema.String, PersistedComposerThreadDraftState),
144	draftThreadsByThreadId: Schema.Record(ThreadId, PersistedDraftThreadState),	177	draftThreadsByThreadKey: Schema.Record(Schema.String, PersistedDraftThreadState),
145	projectDraftThreadIdByProjectId: Schema.Record(ProjectId, ThreadId),	178	logicalProjectDraftThreadKeyByLogicalProjectKey: Schema.Record(Schema.String, Schema.String),
146	stickyModelSelectionByProvider: Schema.optionalKey(	179	stickyModelSelectionByProvider: Schema.optionalKey(
147	Schema.Record(ProviderKind, Schema.optionalKey(ModelSelection)),	180	Schema.Record(ProviderKind, Schema.optionalKey(ModelSelection)),
148	),	181	),
@@ -155,6 +188,10 @@ const PersistedComposerDraftStoreStorage = Schema.Struct({ · 6 unmodified lines
155	state: PersistedComposerDraftStoreState,	188	state: PersistedComposerDraftStoreState,
156	});	189	});
157		190
		191	/**
		192	* Composer content keyed by either a draft session (`DraftId`) or a real server
		193	* thread (`ScopedThreadRef`). This is the editable payload shown in the composer.
		194	*/
158	export interface ComposerThreadDraftState {	195	export interface ComposerThreadDraftState {
159	prompt: string;	196	prompt: string;
160	images: ComposerImageAttachment[];	197	images: ComposerImageAttachment[];
@@ -167,32 +204,94 @@ export interface ComposerThreadDraftState { · 6 unmodified lines
167	interactionMode: ProviderInteractionMode \| null;	204	interactionMode: ProviderInteractionMode \| null;
168	}	205	}
169		206
170	export interface DraftThreadState {	207	/**
		208	* Mutable routing and execution context for a pre-thread draft session.
		209	*
		210	* Unlike a real server thread, a draft session can still change target
		211	* environment/worktree configuration before the first send.
		212	*/
		213	export interface DraftSessionState {
		214	threadId: ThreadId;
		215	environmentId: EnvironmentId;
171	projectId: ProjectId;	216	projectId: ProjectId;
		217	logicalProjectKey: string;
172	createdAt: string;	218	createdAt: string;
173	runtimeMode: RuntimeMode;	219	runtimeMode: RuntimeMode;
174	interactionMode: ProviderInteractionMode;	220	interactionMode: ProviderInteractionMode;
175	branch: string \| null;	221	branch: string \| null;
176	worktreePath: string \| null;	222	worktreePath: string \| null;
177	envMode: DraftThreadEnvMode;	223	envMode: DraftThreadEnvMode;
		224	promotedTo?: ScopedThreadRef \| null;
178	}	225	}
179		226
180	interface ProjectDraftThread extends DraftThreadState {	227	export type DraftThreadState = DraftSessionState;
181	threadId: ThreadId;	228
		229	/**
		230	* Draft session metadata paired with its stable draft-session identity.
		231	*/
		232	interface ProjectDraftSession extends DraftSessionState {
		233	draftId: DraftId;
182	}	234	}
183		235
		236	/**
		237	* App-facing composer identity:
		238	* - `DraftId` for pre-thread draft sessions
		239	* - `ScopedThreadRef` for server-backed threads
		240	*
		241	* Raw `ThreadId` is intentionally excluded so callers cannot drop environment
		242	* identity for real threads.
		243	*/
		244	type ComposerThreadTarget = ScopedThreadRef \| DraftId;
		245
		246	/**
		247	* Persisted store for composer content plus draft-session metadata.
		248	*
		249	* The store intentionally models two domains:
		250	* - draft sessions keyed by `DraftId`
		251	* - server thread composer state keyed by `ScopedThreadRef`
		252	*/
184	interface ComposerDraftStoreState {	253	interface ComposerDraftStoreState {
185	draftsByThreadId: Record<ThreadId, ComposerThreadDraftState>;	254	draftsByThreadKey: Record<string, ComposerThreadDraftState>;
186	draftThreadsByThreadId: Record<ThreadId, DraftThreadState>;	255	draftThreadsByThreadKey: Record<string, DraftThreadState>;
187	projectDraftThreadIdByProjectId: Record<ProjectId, ThreadId>;	256	logicalProjectDraftThreadKeyByLogicalProjectKey: Record<string, string>;
188	stickyModelSelectionByProvider: Partial<Record<ProviderKind, ModelSelection>>;	257	stickyModelSelectionByProvider: Partial<Record<ProviderKind, ModelSelection>>;
189	stickyActiveProvider: ProviderKind \| null;	258	stickyActiveProvider: ProviderKind \| null;
190	getDraftThreadByProjectId: (projectId: ProjectId) => ProjectDraftThread \| null;	259	/** Returns the editable composer content for a draft session or server thread. */
191	getDraftThread: (threadId: ThreadId) => DraftThreadState \| null;	260	getComposerDraft: (target: ComposerThreadTarget) => ComposerThreadDraftState \| null;
		261	/** Looks up the active draft session for a logical project identity. */
		262	getDraftThreadByLogicalProjectKey: (logicalProjectKey: string) => ProjectDraftSession \| null;
		263	getDraftSessionByLogicalProjectKey: (logicalProjectKey: string) => ProjectDraftSession \| null;
		264	getDraftThreadByProjectRef: (projectRef: ScopedProjectRef) => ProjectDraftSession \| null;
		265	getDraftSessionByProjectRef: (projectRef: ScopedProjectRef) => ProjectDraftSession \| null;
		266	/** Reads mutable draft-session metadata by `DraftId`. */
		267	getDraftSession: (draftId: DraftId) => DraftSessionState \| null;
		268	/** Resolves a server-thread ref back to a matching draft session when one exists. */
		269	getDraftSessionByRef: (threadRef: ScopedThreadRef) => DraftSessionState \| null;
		270	getDraftThreadByRef: (threadRef: ScopedThreadRef) => DraftThreadState \| null;
		271	getDraftThread: (threadRef: ComposerThreadTarget) => DraftThreadState \| null;
		272	listDraftThreadKeys: () => string[];
		273	hasDraftThreadsInEnvironment: (environmentId: EnvironmentId) => boolean;
		274	/** Creates or updates the draft session tracked for a logical project. */
		275	setLogicalProjectDraftThreadId: (
		276	logicalProjectKey: string,
		277	projectRef: ScopedProjectRef,
		278	draftId: DraftId,
		279	options?: {
		280	threadId?: ThreadId;
		281	branch?: string \| null;
		282	worktreePath?: string \| null;
		283	createdAt?: string;
		284	envMode?: DraftThreadEnvMode;
		285	runtimeMode?: RuntimeMode;
		286	interactionMode?: ProviderInteractionMode;
		287	},
		288	) => void;
		289	/** Creates or updates the draft session tracked for a concrete project ref. */
192	setProjectDraftThreadId: (	290	setProjectDraftThreadId: (
193	projectId: ProjectId,	291	projectRef: ScopedProjectRef,
194	threadId: ThreadId,	292	draftId: DraftId,
195	options?: {	293	options?: {
		294	threadId?: ThreadId;
196	branch?: string \| null;	295	branch?: string \| null;
197	worktreePath?: string \| null;	296	worktreePath?: string \| null;
198	createdAt?: string;	297	createdAt?: string;
@@ -201,65 +300,76 @@ interface ComposerDraftStoreState { · 2 unmodified lines
201	interactionMode?: ProviderInteractionMode;	300	interactionMode?: ProviderInteractionMode;
202	},	301	},
203	) => void;	302	) => void;
		303	/** Updates mutable draft-session metadata without touching composer content. */
204	setDraftThreadContext: (	304	setDraftThreadContext: (
205	threadId: ThreadId,	305	threadRef: ComposerThreadTarget,
206	options: {	306	options: {
207	branch?: string \| null;	307	branch?: string \| null;
208	worktreePath?: string \| null;	308	worktreePath?: string \| null;
209	projectId?: ProjectId;	309	projectRef?: ScopedProjectRef;
210	createdAt?: string;	310	createdAt?: string;
211	envMode?: DraftThreadEnvMode;	311	envMode?: DraftThreadEnvMode;
212	runtimeMode?: RuntimeMode;	312	runtimeMode?: RuntimeMode;
213	interactionMode?: ProviderInteractionMode;	313	interactionMode?: ProviderInteractionMode;
214	},	314	},
215	) => void;	315	) => void;
216	clearProjectDraftThreadId: (projectId: ProjectId) => void;	316	clearProjectDraftThreadId: (projectRef: ScopedProjectRef) => void;
217	clearProjectDraftThreadById: (projectId: ProjectId, threadId: ThreadId) => void;	317	clearProjectDraftThreadById: (
218	clearDraftThread: (threadId: ThreadId) => void;	318	projectRef: ScopedProjectRef,
		319	threadRef: ComposerThreadTarget,
		320	) => void;
		321	/** Marks a draft session as being promoted to a real server thread. */
		322	markDraftThreadPromoting: (threadRef: ComposerThreadTarget, promotedTo?: ScopedThreadRef) => void;
		323	/** Removes draft-session metadata after promotion is complete. */
		324	finalizePromotedDraftThread: (threadRef: ComposerThreadTarget) => void;
		325	clearDraftThread: (threadRef: ComposerThreadTarget) => void;
219	setStickyModelSelection: (modelSelection: ModelSelection \| null \| undefined) => void;	326	setStickyModelSelection: (modelSelection: ModelSelection \| null \| undefined) => void;
220	setPrompt: (threadId: ThreadId, prompt: string) => void;	327	setPrompt: (threadRef: ComposerThreadTarget, prompt: string) => void;
221	setTerminalContexts: (threadId: ThreadId, contexts: TerminalContextDraft[]) => void;	328	setTerminalContexts: (threadRef: ComposerThreadTarget, contexts: TerminalContextDraft[]) => void;
222	setModelSelection: (	329	setModelSelection: (
223	threadId: ThreadId,	330	threadRef: ComposerThreadTarget,
224	modelSelection: ModelSelection \| null \| undefined,	331	modelSelection: ModelSelection \| null \| undefined,
225	) => void;	332	) => void;
226	setModelOptions: (	333	setModelOptions: (
227	threadId: ThreadId,	334	threadRef: ComposerThreadTarget,
228	modelOptions: ProviderModelOptions \| null \| undefined,	335	modelOptions: ProviderModelOptions \| null \| undefined,
229	) => void;	336	) => void;
230	applyStickyState: (threadId: ThreadId) => void;	337	applyStickyState: (threadRef: ComposerThreadTarget) => void;
231	setProviderModelOptions: (	338	setProviderModelOptions: (
232	threadId: ThreadId,	339	threadRef: ComposerThreadTarget,
233	provider: ProviderKind,	340	provider: ProviderKind,
234	nextProviderOptions: ProviderModelOptions[ProviderKind] \| null \| undefined,	341	nextProviderOptions: ProviderModelOptions[ProviderKind] \| null \| undefined,
235	options?: {	342	options?: {
236	persistSticky?: boolean;	343	persistSticky?: boolean;
237	},	344	},
238	) => void;	345	) => void;
239	setRuntimeMode: (threadId: ThreadId, runtimeMode: RuntimeMode \| null \| undefined) => void;	346	setRuntimeMode: (
		347	threadRef: ComposerThreadTarget,
		348	runtimeMode: RuntimeMode \| null \| undefined,
		349	) => void;
240	setInteractionMode: (	350	setInteractionMode: (
241	threadId: ThreadId,	351	threadRef: ComposerThreadTarget,
242	interactionMode: ProviderInteractionMode \| null \| undefined,	352	interactionMode: ProviderInteractionMode \| null \| undefined,
243	) => void;	353	) => void;
244	addImage: (threadId: ThreadId, image: ComposerImageAttachment) => void;	354	addImage: (threadRef: ComposerThreadTarget, image: ComposerImageAttachment) => void;
245	addImages: (threadId: ThreadId, images: ComposerImageAttachment[]) => void;	355	addImages: (threadRef: ComposerThreadTarget, images: ComposerImageAttachment[]) => void;
246	removeImage: (threadId: ThreadId, imageId: string) => void;	356	removeImage: (threadRef: ComposerThreadTarget, imageId: string) => void;
247	insertTerminalContext: (	357	insertTerminalContext: (
248	threadId: ThreadId,	358	threadRef: ComposerThreadTarget,
249	prompt: string,	359	prompt: string,
250	context: TerminalContextDraft,	360	context: TerminalContextDraft,
251	index: number,	361	index: number,
252	) => boolean;	362	) => boolean;
253	addTerminalContext: (threadId: ThreadId, context: TerminalContextDraft) => void;	363	addTerminalContext: (threadRef: ComposerThreadTarget, context: TerminalContextDraft) => void;
254	addTerminalContexts: (threadId: ThreadId, contexts: TerminalContextDraft[]) => void;	364	addTerminalContexts: (threadRef: ComposerThreadTarget, contexts: TerminalContextDraft[]) => void;
255	removeTerminalContext: (threadId: ThreadId, contextId: string) => void;	365	removeTerminalContext: (threadRef: ComposerThreadTarget, contextId: string) => void;
256	clearTerminalContexts: (threadId: ThreadId) => void;	366	clearTerminalContexts: (threadRef: ComposerThreadTarget) => void;
257	clearPersistedAttachments: (threadId: ThreadId) => void;	367	clearPersistedAttachments: (threadRef: ComposerThreadTarget) => void;
258	syncPersistedAttachments: (	368	syncPersistedAttachments: (
259	threadId: ThreadId,	369	threadRef: ComposerThreadTarget,
260	attachments: PersistedComposerImageAttachment[],	370	attachments: PersistedComposerImageAttachment[],
261	) => void;	371	) => void;
262	clearComposerContent: (threadId: ThreadId) => void;	372	clearComposerContent: (threadRef: ComposerThreadTarget) => void;
263	}	373	}
264		374
265	export interface EffectiveComposerModelState {	375	export interface EffectiveComposerModelState {
@@ -293,9 +403,9 @@ function modelSelectionByProviderToOptions( · 27 unmodified lines
293	}	403	}
294		404
295	const EMPTY_PERSISTED_DRAFT_STORE_STATE = Object.freeze<PersistedComposerDraftStoreState>({	405	const EMPTY_PERSISTED_DRAFT_STORE_STATE = Object.freeze<PersistedComposerDraftStoreState>({
296	draftsByThreadId: {},	406	draftsByThreadKey: {},
297	draftThreadsByThreadId: {},	407	draftThreadsByThreadKey: {},
298	projectDraftThreadIdByProjectId: {},	408	logicalProjectDraftThreadKeyByLogicalProjectKey: {},
299	stickyModelSelectionByProvider: {},	409	stickyModelSelectionByProvider: {},
300	stickyActiveProvider: null,	410	stickyActiveProvider: null,
301	});	411	});
@@ -748,35 +858,323 @@ function normalizeDraftThreadEnvMode( · 446 unmodified lines
748	return fallbackWorktreePath ? "worktree" : "local";	858	return fallbackWorktreePath ? "worktree" : "local";
749	}	859	}
750		860
		861	function projectDraftKey(projectRef: ScopedProjectRef): string {
		862	return scopedProjectKey(projectRef);
		863	}
		864
		865	function logicalProjectDraftKey(logicalProjectKey: string): string {
		866	return logicalProjectKey.trim();
		867	}
		868
		869	/**
		870	* Runtime composer storage key for app-facing identities only.
		871	*
		872	* Draft sessions are keyed by `DraftId`. Real threads are keyed by
		873	* `ScopedThreadRef` so environment identity is always preserved.
		874	*/
		875	function composerTargetKey(target: ScopedThreadRef \| DraftId): string {
		876	if (typeof target === "string") {
		877	return target.trim();
		878	}
		879	return scopedThreadKey(target);
		880	}
		881
		882	/**
		883	* Legacy persisted data may still be keyed by a raw `ThreadId`. This helper is
		884	* intentionally migration-only so live code cannot accidentally accept that
		885	* incomplete identity.
		886	*/
		887	function normalizeLegacyComposerStorageKey(
		888	threadKeyOrId: string,
		889	options?: {
		890	environmentId?: EnvironmentId;
		891	},
		892	): string {
		893	const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
		894	if (parsedThreadRef) {
		895	return composerTargetKey(parsedThreadRef);
		896	}
		897	if (options?.environmentId) {
		898	return composerTargetKey(scopeThreadRef(options.environmentId, threadKeyOrId as ThreadId));
		899	}
		900	return threadKeyOrId;
		901	}
		902
		903	function composerThreadRefFromKey(threadKey: string): ScopedThreadRef \| null {
		904	return parseScopedThreadKey(threadKey);
		905	}
		906
		907	type ComposerThreadLookupState = Pick<
		908	ComposerDraftStoreState,
		909	"draftsByThreadKey" \| "draftThreadsByThreadKey"
		910	>;
		911
		912	function normalizeComposerTarget(
		913	state: ComposerThreadLookupState,
		914	target: ComposerThreadTarget,
		915	): ComposerThreadTarget \| null {
		916	if (typeof target === "string") {
		917	const draftId = target.trim();
		918	return draftId.length > 0 ? DraftId.makeUnsafe(draftId) : null;
		919	}
		920	return target;
		921	}
		922
		923	function resolveComposerDraftKey(
		924	state: ComposerThreadLookupState,
		925	target: ComposerThreadTarget,
		926	): string \| null {
		927	const normalizedTarget = normalizeComposerTarget(state, target);
		928	if (!normalizedTarget) {
		929	return null;
		930	}
		931	if (typeof normalizedTarget !== "string") {
		932	const scopedKey = composerTargetKey(normalizedTarget);
		933	if (state.draftsByThreadKey[scopedKey]) {
		934	return scopedKey;
		935	}
		936	for (const [draftId, draftSession] of Object.entries(state.draftThreadsByThreadKey)) {
		937	if (
		938	draftSession.environmentId === normalizedTarget.environmentId &&
		939	draftSession.threadId === normalizedTarget.threadId
		940	) {
		941	return draftId;
		942	}
		943	}
		944	return scopedKey;
		945	}
		946	const threadKey = composerTargetKey(normalizedTarget);
		947	return threadKey.length > 0 ? threadKey : null;
		948	}
		949
		950	function resolveComposerThreadId(
		951	state: ComposerThreadLookupState,
		952	target: ComposerThreadTarget,
		953	): ThreadId \| null {
		954	const normalizedTarget = normalizeComposerTarget(state, target);
		955	if (!normalizedTarget) {
		956	return null;
		957	}
		958	if (typeof normalizedTarget !== "string") {
		959	return normalizedTarget.threadId;
		960	}
		961	return state.draftThreadsByThreadKey[normalizedTarget]?.threadId ?? null;
		962	}
		963
		964	function getComposerDraftState(
		965	state: Pick<ComposerDraftStoreState, "draftsByThreadKey" \| "draftThreadsByThreadKey">,
		966	target: ComposerThreadTarget,
		967	): ComposerThreadDraftState \| null {
		968	const threadKey = resolveComposerDraftKey(state, target);
		969	if (!threadKey) {
		970	return null;
		971	}
		972	return state.draftsByThreadKey[threadKey] ?? null;
		973	}
		974
		975	function isComposerThreadKeyInUse(mappings: Record<string, string>, threadKey: string): boolean {
		976	return Object.values(mappings).includes(threadKey);
		977	}
		978
		979	function toProjectDraftSession(
		980	draftId: DraftId,
		981	draftSession: DraftSessionState,
		982	): ProjectDraftSession {
		983	return {
		984	draftId,
		985	...draftSession,
		986	};
		987	}
		988
		989	function createDraftThreadState(
		990	projectRef: ScopedProjectRef,
		991	threadId: ThreadId,
		992	logicalProjectKey: string,
		993	existingThread: DraftThreadState \| undefined,
		994	options?: {
		995	threadId?: ThreadId;
		996	branch?: string \| null;
		997	worktreePath?: string \| null;
		998	createdAt?: string;
		999	envMode?: DraftThreadEnvMode;
		1000	runtimeMode?: RuntimeMode;
		1001	interactionMode?: ProviderInteractionMode;
		1002	},
		1003	): DraftThreadState {
		1004	const nextWorktreePath =
		1005	options?.worktreePath === undefined
		1006	? (existingThread?.worktreePath ?? null)
		1007	: (options.worktreePath ?? null);
		1008	return {
		1009	threadId,
		1010	environmentId: projectRef.environmentId,
		1011	projectId: projectRef.projectId,
		1012	logicalProjectKey,
		1013	createdAt: options?.createdAt ?? existingThread?.createdAt ?? new Date().toISOString(),
		1014	runtimeMode: options?.runtimeMode ?? existingThread?.runtimeMode ?? DEFAULT_RUNTIME_MODE,
		1015	interactionMode:
		1016	options?.interactionMode ?? existingThread?.interactionMode ?? DEFAULT_INTERACTION_MODE,
		1017	branch:
		1018	options?.branch === undefined ? (existingThread?.branch ?? null) : (options.branch ?? null),
		1019	worktreePath: nextWorktreePath,
		1020	envMode:
		1021	options?.envMode ?? (nextWorktreePath ? "worktree" : (existingThread?.envMode ?? "local")),
		1022	promotedTo: null,
		1023	};
		1024	}
		1025
		1026	function scopedThreadRefsEqual(
		1027	left: ScopedThreadRef \| null \| undefined,
		1028	right: ScopedThreadRef \| null \| undefined,
		1029	): boolean {
		1030	if (!left \|\| !right) {
		1031	return left === right;
		1032	}
		1033	return left.environmentId === right.environmentId && left.threadId === right.threadId;
		1034	}
		1035
		1036	function isDraftThreadPromoting(draftThread: DraftThreadState \| null \| undefined): boolean {
		1037	return draftThread?.promotedTo !== null && draftThread?.promotedTo !== undefined;
		1038	}
		1039
		1040	function draftThreadsEqual(left: DraftThreadState \| undefined, right: DraftThreadState): boolean {
		1041	return (
		1042	!!left &&
		1043	left.threadId === right.threadId &&
		1044	left.environmentId === right.environmentId &&
		1045	left.projectId === right.projectId &&
		1046	left.logicalProjectKey === right.logicalProjectKey &&
		1047	left.createdAt === right.createdAt &&
		1048	left.runtimeMode === right.runtimeMode &&
		1049	left.interactionMode === right.interactionMode &&
		1050	left.branch === right.branch &&
		1051	left.worktreePath === right.worktreePath &&
		1052	left.envMode === right.envMode &&
		1053	scopedThreadRefsEqual(left.promotedTo, right.promotedTo)
		1054	);
		1055	}
		1056
		1057	function removeDraftThreadReferences(
		1058	state: Pick<
		1059	ComposerDraftStoreState,
		1060	\| "draftThreadsByThreadKey"
		1061	\| "draftsByThreadKey"
		1062	\| "logicalProjectDraftThreadKeyByLogicalProjectKey"
		1063	>,
		1064	threadKey: string,
		1065	): Pick<
		1066	ComposerDraftStoreState,
		1067	\| "draftThreadsByThreadKey"
		1068	\| "draftsByThreadKey"
		1069	\| "logicalProjectDraftThreadKeyByLogicalProjectKey"
		1070	> {
		1071	const nextLogicalMappings = Object.fromEntries(
		1072	Object.entries(state.logicalProjectDraftThreadKeyByLogicalProjectKey).filter(
		1073	([, draftThreadKey]) => draftThreadKey !== threadKey,
		1074	),
		1075	) as Record<string, string>;
		1076	const { [threadKey]: _removedDraftThread, ...restDraftThreadsByThreadKey } =
		1077	state.draftThreadsByThreadKey;
		1078	const { [threadKey]: _removedComposerDraft, ...restDraftsByThreadKey } = state.draftsByThreadKey;
		1079	return {
		1080	draftsByThreadKey: restDraftsByThreadKey,
		1081	draftThreadsByThreadKey: restDraftThreadsByThreadKey,
		1082	logicalProjectDraftThreadKeyByLogicalProjectKey: nextLogicalMappings,
		1083	};
		1084	}
		1085
751	function normalizePersistedDraftThreads(	1086	function normalizePersistedDraftThreads(
752	rawDraftThreadsByThreadId: unknown,	1087	rawDraftThreadsByThreadId: unknown,
753	rawProjectDraftThreadIdByProjectId: unknown,	1088	rawProjectDraftThreadIdByProjectKey: unknown,
754	): Pick<	1089	): Pick<
755	PersistedComposerDraftStoreState,	1090	PersistedComposerDraftStoreState,
756	"draftThreadsByThreadId" \| "projectDraftThreadIdByProjectId"	1091	"draftThreadsByThreadKey" \| "logicalProjectDraftThreadKeyByLogicalProjectKey"
757	> {	1092	> {
758	const draftThreadsByThreadId: Record<ThreadId, PersistedDraftThreadState> = {};	1093	const draftThreadsByThreadKey: Record<string, PersistedDraftThreadState> = {};
		1094	const environmentIdByThreadId = new Map<ThreadId, EnvironmentId>();
		1095	if (
		1096	rawProjectDraftThreadIdByProjectKey &&
		1097	typeof rawProjectDraftThreadIdByProjectKey === "object"
		1098	) {
		1099	for (const [projectKey, threadId] of Object.entries(
		1100	rawProjectDraftThreadIdByProjectKey as Record<string, unknown>,
		1101	)) {
		1102	if (typeof threadId !== "string" \|\| threadId.length === 0) {
		1103	continue;
		1104	}
		1105	const projectRef = parseScopedProjectKey(projectKey);
		1106	if (!projectRef) {
		1107	continue;
		1108	}
		1109	const parsedThreadRef = parseScopedThreadKey(threadId);
		1110	if (parsedThreadRef) {
		1111	environmentIdByThreadId.set(parsedThreadRef.threadId, parsedThreadRef.environmentId);
		1112	continue;
		1113	}
		1114	environmentIdByThreadId.set(threadId as ThreadId, projectRef.environmentId);
		1115	}
		1116	}
759	if (rawDraftThreadsByThreadId && typeof rawDraftThreadsByThreadId === "object") {	1117	if (rawDraftThreadsByThreadId && typeof rawDraftThreadsByThreadId === "object") {
760	for (const [threadId, rawDraftThread] of Object.entries(	1118	for (const [threadKeyOrId, rawDraftThread] of Object.entries(
761	rawDraftThreadsByThreadId as Record<string, unknown>,	1119	rawDraftThreadsByThreadId as Record<string, unknown>,
762	)) {	1120	)) {
763	if (typeof threadId !== "string" \|\| threadId.length === 0) {	1121	if (typeof threadKeyOrId !== "string" \|\| threadKeyOrId.length === 0) {
764	continue;	1122	continue;
765	}	1123	}
766	if (!rawDraftThread \|\| typeof rawDraftThread !== "object") {	1124	if (!rawDraftThread \|\| typeof rawDraftThread !== "object") {
767	continue;	1125	continue;
768	}	1126	}
769	const candidateDraftThread = rawDraftThread as Record<string, unknown>;	1127	const candidateDraftThread = rawDraftThread as Record<string, unknown>;
		1128	const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
		1129	const threadKey = normalizeLegacyComposerStorageKey(threadKeyOrId);
		1130	const threadId =
		1131	parsedThreadRef?.threadId ??
		1132	(typeof candidateDraftThread.threadId === "string" &&
		1133	candidateDraftThread.threadId.length > 0
		1134	? (candidateDraftThread.threadId as ThreadId)
		1135	: (threadKeyOrId as ThreadId));
		1136	const environmentId =
		1137	parsedThreadRef?.environmentId ??
		1138	(typeof candidateDraftThread.environmentId === "string" &&
		1139	candidateDraftThread.environmentId.length > 0
		1140	? (candidateDraftThread.environmentId as EnvironmentId)
		1141	: environmentIdByThreadId.get(threadKeyOrId as ThreadId));
770	const projectId = candidateDraftThread.projectId;	1142	const projectId = candidateDraftThread.projectId;
771	const createdAt = candidateDraftThread.createdAt;	1143	const createdAt = candidateDraftThread.createdAt;
772	const branch = candidateDraftThread.branch;	1144	const branch = candidateDraftThread.branch;
773	const worktreePath = candidateDraftThread.worktreePath;	1145	const worktreePath = candidateDraftThread.worktreePath;
774	const normalizedWorktreePath = typeof worktreePath === "string" ? worktreePath : null;	1146	const normalizedWorktreePath = typeof worktreePath === "string" ? worktreePath : null;
775	if (typeof projectId !== "string" \|\| projectId.length === 0) {	1147	const promotedToCandidate = candidateDraftThread.promotedTo;
		1148	const promotedToRecord =
		1149	promotedToCandidate && typeof promotedToCandidate === "object"
		1150	? (promotedToCandidate as Record<string, unknown>)
		1151	: null;
		1152	const promotedTo =
		1153	promotedToRecord &&
		1154	typeof promotedToRecord.environmentId === "string" &&
		1155	promotedToRecord.environmentId.length > 0 &&
		1156	typeof promotedToRecord.threadId === "string" &&
		1157	promotedToRecord.threadId.length > 0
		1158	? scopeThreadRef(
		1159	promotedToRecord.environmentId as EnvironmentId,
		1160	promotedToRecord.threadId as ThreadId,
		1161	)
		1162	: null;
		1163	if (typeof projectId !== "string" \|\| projectId.length === 0 \|\| environmentId === undefined) {
776	continue;	1164	continue;
777	}	1165	}
778	draftThreadsByThreadId[threadId as ThreadId] = {	1166	const normalizedEnvironmentId = environmentId as EnvironmentId;
		1167	draftThreadsByThreadKey[threadKey] = {
		1168	threadId,
		1169	environmentId: normalizedEnvironmentId,
779	projectId: projectId as ProjectId,	1170	projectId: projectId as ProjectId,
		1171	logicalProjectKey:
		1172	typeof candidateDraftThread.logicalProjectKey === "string" &&
		1173	candidateDraftThread.logicalProjectKey.length > 0
		1174	? candidateDraftThread.logicalProjectKey
		1175	: parsedThreadRef
		1176	? projectDraftKey(scopeProjectRef(normalizedEnvironmentId, projectId as ProjectId))
		1177	: threadKeyOrId,
780	createdAt:	1178	createdAt:
781	typeof createdAt === "string" && createdAt.length > 0	1179	typeof createdAt === "string" && createdAt.length > 0
782	? createdAt	1180	? createdAt
@@ -794,59 +1192,97 @@ function normalizePersistedDraftThreads( · 11 unmodified lines
794	branch: typeof branch === "string" ? branch : null,	1192	branch: typeof branch === "string" ? branch : null,
795	worktreePath: normalizedWorktreePath,	1193	worktreePath: normalizedWorktreePath,
796	envMode: normalizeDraftThreadEnvMode(candidateDraftThread.envMode, normalizedWorktreePath),	1194	envMode: normalizeDraftThreadEnvMode(candidateDraftThread.envMode, normalizedWorktreePath),
		1195	promotedTo,
797	};	1196	};
798	}	1197	}
799	}	1198	}
800		1199
801	const projectDraftThreadIdByProjectId: Record<ProjectId, ThreadId> = {};	1200	const logicalProjectDraftThreadKeyByLogicalProjectKey: Record<string, string> = {};
802	if (	1201	if (
803	rawProjectDraftThreadIdByProjectId &&	1202	rawProjectDraftThreadIdByProjectKey &&
804	typeof rawProjectDraftThreadIdByProjectId === "object"	1203	typeof rawProjectDraftThreadIdByProjectKey === "object"
805	) {	1204	) {
806	for (const [projectId, threadId] of Object.entries(	1205	for (const [logicalProjectKey, threadKeyOrId] of Object.entries(
807	rawProjectDraftThreadIdByProjectId as Record<string, unknown>,	1206	rawProjectDraftThreadIdByProjectKey as Record<string, unknown>,
808	)) {	1207	)) {
809	if (	1208	if (typeof threadKeyOrId !== "string" \|\| threadKeyOrId.length === 0) {
810	typeof projectId === "string" &&	1209	continue;
811	projectId.length > 0 &&	1210	}
812	typeof threadId === "string" &&	1211	const projectRef = parseScopedProjectKey(logicalProjectKey);
813	threadId.length > 0	1212	const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
814	) {	1213	const threadKey = normalizeLegacyComposerStorageKey(threadKeyOrId);
815	projectDraftThreadIdByProjectId[projectId as ProjectId] = threadId as ThreadId;	1214	logicalProjectDraftThreadKeyByLogicalProjectKey[logicalProjectKey] = threadKey;
816	if (!draftThreadsByThreadId[threadId as ThreadId]) {	1215	if (parsedThreadRef) {
817	draftThreadsByThreadId[threadId as ThreadId] = {	1216	environmentIdByThreadId.set(parsedThreadRef.threadId, parsedThreadRef.environmentId);
818	projectId: projectId as ProjectId,	1217	}
819	createdAt: new Date().toISOString(),	1218	if (!projectRef) {
820	runtimeMode: DEFAULT_RUNTIME_MODE,	1219	const existingDraftThread = draftThreadsByThreadKey[threadKey];
821	interactionMode: DEFAULT_INTERACTION_MODE,	1220	if (existingDraftThread && !existingDraftThread.logicalProjectKey) {
822	branch: null,	1221	draftThreadsByThreadKey[threadKey] = {
823	worktreePath: null,	1222	...existingDraftThread,
824	envMode: "local",	1223	logicalProjectKey,
825	};
826	} else if (draftThreadsByThreadId[threadId as ThreadId]?.projectId !== projectId) {
827	draftThreadsByThreadId[threadId as ThreadId] = {
828	...draftThreadsByThreadId[threadId as ThreadId]!,
829	projectId: projectId as ProjectId,
830	};	1224	};
831	}	1225	}
		1226	continue;
		1227	}
		1228	if (!draftThreadsByThreadKey[threadKey]) {
		1229	draftThreadsByThreadKey[threadKey] = {
		1230	threadId: parsedThreadRef?.threadId ?? (threadKey as ThreadId),
		1231	environmentId: projectRef.environmentId,
		1232	projectId: projectRef.projectId,
		1233	logicalProjectKey,
		1234	createdAt: new Date().toISOString(),
		1235	runtimeMode: DEFAULT_RUNTIME_MODE,
		1236	interactionMode: DEFAULT_INTERACTION_MODE,
		1237	branch: null,
		1238	worktreePath: null,
		1239	envMode: "local",
		1240	promotedTo: null,
		1241	};
		1242	} else if (
		1243	draftThreadsByThreadKey[threadKey]?.projectId !== projectRef.projectId \|\|
		1244	draftThreadsByThreadKey[threadKey]?.environmentId !== projectRef.environmentId
		1245	) {
		1246	draftThreadsByThreadKey[threadKey] = {
		1247	...draftThreadsByThreadKey[threadKey]!,
		1248	threadId: draftThreadsByThreadKey[threadKey]!.threadId,
		1249	environmentId: projectRef.environmentId,
		1250	projectId: projectRef.projectId,
		1251	logicalProjectKey,
		1252	};
832	}	1253	}
833	}	1254	}
834	}	1255	}
835		1256
836	return { draftThreadsByThreadId, projectDraftThreadIdByProjectId };	1257	return { draftThreadsByThreadKey, logicalProjectDraftThreadKeyByLogicalProjectKey };
837	}	1258	}
838		1259
839	function normalizePersistedDraftsByThreadId(	1260	function normalizePersistedDraftsByThreadId(
840	rawDraftMap: unknown,	1261	rawDraftMap: unknown,
841	): PersistedComposerDraftStoreState["draftsByThreadId"] {	1262	draftThreadsByThreadKey: PersistedComposerDraftStoreState["draftThreadsByThreadKey"],
		1263	): PersistedComposerDraftStoreState["draftsByThreadKey"] {
842	if (!rawDraftMap \|\| typeof rawDraftMap !== "object") {	1264	if (!rawDraftMap \|\| typeof rawDraftMap !== "object") {
843	return {};	1265	return {};
844	}	1266	}
845		1267
846	const nextDraftsByThreadId: DeepMutable<PersistedComposerDraftStoreState["draftsByThreadId"]> =	1268	const environmentIdByThreadId = new Map<ThreadId, EnvironmentId>();
		1269	for (const [threadKey, draftThread] of Object.entries(draftThreadsByThreadKey)) {
		1270	const parsedThreadRef = composerThreadRefFromKey(threadKey);
		1271	if (!parsedThreadRef) {
		1272	continue;
		1273	}
		1274	environmentIdByThreadId.set(
		1275	parsedThreadRef.threadId,
		1276	draftThread.environmentId as EnvironmentId,
		1277	);
		1278	}
		1279
		1280	const nextDraftsByThreadKey: DeepMutable<PersistedComposerDraftStoreState["draftsByThreadKey"]> =
847	{};	1281	{};
848	for (const [threadId, draftValue] of Object.entries(rawDraftMap as Record<string, unknown>)) {	1282	for (const [threadKeyOrId, draftValue] of Object.entries(
849	if (typeof threadId !== "string" \|\| threadId.length === 0) {	1283	rawDraftMap as Record<string, unknown>,
		1284	)) {
		1285	if (typeof threadKeyOrId !== "string" \|\| threadKeyOrId.length === 0) {
850	continue;	1286	continue;
851	}	1287	}
852	if (!draftValue \|\| typeof draftValue !== "object") {	1288	if (!draftValue \|\| typeof draftValue !== "object") {
@@ -937,7 +1373,19 @@ function normalizePersistedDraftsByThreadId( · 84 unmodified lines
937	) {	1373	) {
938	continue;	1374	continue;
939	}	1375	}
940	nextDraftsByThreadId[threadId as ThreadId] = {	1376	const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
		1377	const normalizedThreadKey =
		1378	parsedThreadRef !== null
		1379	? normalizeLegacyComposerStorageKey(threadKeyOrId)
		1380	: draftThreadsByThreadKey[threadKeyOrId] !== undefined
		1381	? threadKeyOrId
		1382	: (() => {
		1383	const environmentId = environmentIdByThreadId.get(threadKeyOrId as ThreadId);
		1384	return environmentId
		1385	? normalizeLegacyComposerStorageKey(threadKeyOrId, { environmentId })
		1386	: threadKeyOrId;
		1387	})();
		1388	nextDraftsByThreadKey[normalizedThreadKey] = {
941	prompt,	1389	prompt,
942	attachments,	1390	attachments,
943	...(terminalContexts.length > 0 ? { terminalContexts } : {}),	1391	...(terminalContexts.length > 0 ? { terminalContexts } : {}),
@@ -947,7 +1395,7 @@ function normalizePersistedDraftsByThreadId( · 3 unmodified lines
947	};	1395	};
948	}	1396	}
949		1397
950	return nextDraftsByThreadId;	1398	return nextDraftsByThreadKey;
951	}	1399	}
952		1400
953	function migratePersistedComposerDraftStoreState(	1401	function migratePersistedComposerDraftStoreState(
@@ -957,9 +1405,14 @@ function migratePersistedComposerDraftStoreState( · 3 unmodified lines
957	return EMPTY_PERSISTED_DRAFT_STORE_STATE;	1405	return EMPTY_PERSISTED_DRAFT_STORE_STATE;
958	}	1406	}
959	const candidate = persistedState as LegacyPersistedComposerDraftStoreState;	1407	const candidate = persistedState as LegacyPersistedComposerDraftStoreState;
960	const rawDraftMap = candidate.draftsByThreadId;	1408	const rawDraftMap = candidate.draftsByThreadKey ?? candidate.draftsByThreadId;
961	const rawDraftThreadsByThreadId = candidate.draftThreadsByThreadId;	1409	const rawDraftThreadsByThreadId =
962	const rawProjectDraftThreadIdByProjectId = candidate.projectDraftThreadIdByProjectId;	1410	candidate.draftThreadsByThreadKey ?? candidate.draftThreadsByThreadId;
		1411	const rawProjectDraftThreadIdByProjectKey =
		1412	candidate.logicalProjectDraftThreadKeyByLogicalProjectKey ??
		1413	candidate.projectDraftThreadKeyByProjectKey ??
		1414	candidate.projectDraftThreadIdByProjectKey ??
		1415	candidate.projectDraftThreadIdByProjectId;
963		1416
964	// Migrate sticky state from v2 (dual) to v3 (consolidated)	1417	// Migrate sticky state from v2 (dual) to v3 (consolidated)
965	const stickyModelOptions = normalizeProviderModelOptions(candidate.stickyModelOptions) ?? {};	1418	const stickyModelOptions = normalizeProviderModelOptions(candidate.stickyModelOptions) ?? {};
@@ -982,13 +1435,16 @@ function migratePersistedComposerDraftStoreState( · 16 unmodified lines
982	);	1435	);
983	const stickyActiveProvider = normalizeProviderKind(candidate.stickyProvider) ?? null;	1436	const stickyActiveProvider = normalizeProviderKind(candidate.stickyProvider) ?? null;
984		1437
985	const { draftThreadsByThreadId, projectDraftThreadIdByProjectId } =	1438	const { draftThreadsByThreadKey, logicalProjectDraftThreadKeyByLogicalProjectKey } =
986	normalizePersistedDraftThreads(rawDraftThreadsByThreadId, rawProjectDraftThreadIdByProjectId);	1439	normalizePersistedDraftThreads(rawDraftThreadsByThreadId, rawProjectDraftThreadIdByProjectKey);
987	const draftsByThreadId = normalizePersistedDraftsByThreadId(rawDraftMap);	1440	const draftsByThreadKey = normalizePersistedDraftsByThreadId(
		1441	rawDraftMap,
		1442	draftThreadsByThreadKey,
		1443	);
988	return {	1444	return {
989	draftsByThreadId,	1445	draftsByThreadKey,
990	draftThreadsByThreadId,	1446	draftThreadsByThreadKey,
991	projectDraftThreadIdByProjectId,	1447	logicalProjectDraftThreadKeyByLogicalProjectKey,
992	stickyModelSelectionByProvider,	1448	stickyModelSelectionByProvider,
993	stickyActiveProvider,	1449	stickyActiveProvider,
994	};	1450	};
@@ -997,11 +1453,11 @@ function migratePersistedComposerDraftStoreState( · 2 unmodified lines
997	function partializeComposerDraftStoreState(	1453	function partializeComposerDraftStoreState(
998	state: ComposerDraftStoreState,	1454	state: ComposerDraftStoreState,
999	): PersistedComposerDraftStoreState {	1455	): PersistedComposerDraftStoreState {
1000	const persistedDraftsByThreadId: DeepMutable<	1456	const persistedDraftsByThreadKey: DeepMutable<
1001	PersistedComposerDraftStoreState["draftsByThreadId"]	1457	PersistedComposerDraftStoreState["draftsByThreadKey"]
1002	> = {};	1458	> = {};
1003	for (const [threadId, draft] of Object.entries(state.draftsByThreadId)) {	1459	for (const [threadKey, draft] of Object.entries(state.draftsByThreadKey)) {
1004	if (typeof threadId !== "string" \|\| threadId.length === 0) {	1460	if (typeof threadKey !== "string" \|\| threadKey.length === 0) {
1005	continue;	1461	continue;
1006	}	1462	}
1007	const hasModelData =	1463	const hasModelData =
@@ -1041,12 +1497,13 @@ function partializeComposerDraftStoreState( · 33 unmodified lines
1041	...(draft.runtimeMode ? { runtimeMode: draft.runtimeMode } : {}),	1497	...(draft.runtimeMode ? { runtimeMode: draft.runtimeMode } : {}),
1042	...(draft.interactionMode ? { interactionMode: draft.interactionMode } : {}),	1498	...(draft.interactionMode ? { interactionMode: draft.interactionMode } : {}),
1043	};	1499	};
1044	persistedDraftsByThreadId[threadId as ThreadId] = persistedDraft;	1500	persistedDraftsByThreadKey[threadKey] = persistedDraft;
1045	}	1501	}
1046	return {	1502	return {
1047	draftsByThreadId: persistedDraftsByThreadId,	1503	draftsByThreadKey: persistedDraftsByThreadKey,
1048	draftThreadsByThreadId: state.draftThreadsByThreadId,	1504	draftThreadsByThreadKey: state.draftThreadsByThreadKey,
1049	projectDraftThreadIdByProjectId: state.projectDraftThreadIdByProjectId,	1505	logicalProjectDraftThreadKeyByLogicalProjectKey:
		1506	state.logicalProjectDraftThreadKeyByLogicalProjectKey,
1050	stickyModelSelectionByProvider: state.stickyModelSelectionByProvider,	1507	stickyModelSelectionByProvider: state.stickyModelSelectionByProvider,
1051	stickyActiveProvider: state.stickyActiveProvider,	1508	stickyActiveProvider: state.stickyActiveProvider,
1052	};	1509	};
@@ -1059,10 +1516,14 @@ function normalizeCurrentPersistedComposerDraftStoreState( · 6 unmodified lines
1059	return EMPTY_PERSISTED_DRAFT_STORE_STATE;	1516	return EMPTY_PERSISTED_DRAFT_STORE_STATE;
1060	}	1517	}
1061	const normalizedPersistedState = persistedState as LegacyPersistedComposerDraftStoreState;	1518	const normalizedPersistedState = persistedState as LegacyPersistedComposerDraftStoreState;
1062	const { draftThreadsByThreadId, projectDraftThreadIdByProjectId } =	1519	const { draftThreadsByThreadKey, logicalProjectDraftThreadKeyByLogicalProjectKey } =
1063	normalizePersistedDraftThreads(	1520	normalizePersistedDraftThreads(
1064	normalizedPersistedState.draftThreadsByThreadId,	1521	normalizedPersistedState.draftThreadsByThreadKey ??
1065	normalizedPersistedState.projectDraftThreadIdByProjectId,	1522	normalizedPersistedState.draftThreadsByThreadId,
		1523	normalizedPersistedState.logicalProjectDraftThreadKeyByLogicalProjectKey ??
		1524	normalizedPersistedState.projectDraftThreadKeyByProjectKey ??
		1525	normalizedPersistedState.projectDraftThreadIdByProjectKey ??
		1526	normalizedPersistedState.projectDraftThreadIdByProjectId,
1066	);	1527	);
1067		1528
1068	// Handle both v3 (modelSelectionByProvider) and v2/legacy formats	1529	// Handle both v3 (modelSelectionByProvider) and v2/legacy formats
@@ -1105,16 +1566,19 @@ function normalizeCurrentPersistedComposerDraftStoreState( · 36 unmodified lines
1105	}	1566	}
1106		1567
1107	return {	1568	return {
1108	draftsByThreadId: normalizePersistedDraftsByThreadId(normalizedPersistedState.draftsByThreadId),	1569	draftsByThreadKey: normalizePersistedDraftsByThreadId(
1109	draftThreadsByThreadId,	1570	normalizedPersistedState.draftsByThreadKey ?? normalizedPersistedState.draftsByThreadId,
1110	projectDraftThreadIdByProjectId,	1571	draftThreadsByThreadKey,
		1572	),
		1573	draftThreadsByThreadKey,
		1574	logicalProjectDraftThreadKeyByLogicalProjectKey,
1111	stickyModelSelectionByProvider,	1575	stickyModelSelectionByProvider,
1112	stickyActiveProvider,	1576	stickyActiveProvider,
1113	};	1577	};
1114	}	1578	}
1115		1579
1116	function readPersistedAttachmentIdsFromStorage(threadId: ThreadId): string[] {	1580	function readPersistedAttachmentIdsFromStorage(threadKey: string): string[] {
1117	if (threadId.length === 0) {	1581	if (threadKey.length === 0) {
1118	return [];	1582	return [];
1119	}	1583	}
1120	try {	1584	try {
@@ -1125,7 +1589,7 @@ function readPersistedAttachmentIdsFromStorage(threadId: ThreadId): string[] { · 4 unmodified lines
1125	if (!persisted \|\| persisted.version !== COMPOSER_DRAFT_STORAGE_VERSION) {	1589	if (!persisted \|\| persisted.version !== COMPOSER_DRAFT_STORAGE_VERSION) {
1126	return [];	1590	return [];
1127	}	1591	}
1128	return (persisted.state.draftsByThreadId[threadId]?.attachments ?? []).map(	1592	return (persisted.state.draftsByThreadKey[threadKey]?.attachments ?? []).map(
1129	(attachment) => attachment.id,	1593	(attachment) => attachment.id,
1130	);	1594	);
1131	} catch {	1595	} catch {
@@ -1134,7 +1598,7 @@ function readPersistedAttachmentIdsFromStorage(threadId: ThreadId): string[] { · 2 unmodified lines
1134	}	1598	}
1135		1599
1136	function verifyPersistedAttachments(	1600	function verifyPersistedAttachments(
1137	threadId: ThreadId,	1601	threadKey: string,
1138	attachments: PersistedComposerImageAttachment[],	1602	attachments: PersistedComposerImageAttachment[],
1139	set: (	1603	set: (
1140	partial:	1604	partial:
@@ -1149,12 +1613,12 @@ function verifyPersistedAttachments( · 8 unmodified lines
1149	let persistedIdSet = new Set<string>();	1613	let persistedIdSet = new Set<string>();
1150	try {	1614	try {
1151	composerDebouncedStorage.flush();	1615	composerDebouncedStorage.flush();
1152	persistedIdSet = new Set(readPersistedAttachmentIdsFromStorage(threadId));	1616	persistedIdSet = new Set(readPersistedAttachmentIdsFromStorage(threadKey));
1153	} catch {	1617	} catch {
1154	persistedIdSet = new Set();	1618	persistedIdSet = new Set();
1155	}	1619	}
1156	set((state) => {	1620	set((state) => {
1157	const current = state.draftsByThreadId[threadId];	1621	const current = state.draftsByThreadKey[threadKey];
1158	if (!current) {	1622	if (!current) {
1159	return state;	1623	return state;
1160	}	1624	}
@@ -1170,13 +1634,13 @@ function verifyPersistedAttachments( · 9 unmodified lines
1170	persistedAttachments,	1634	persistedAttachments,
1171	nonPersistedImageIds,	1635	nonPersistedImageIds,
1172	};	1636	};
1173	const nextDraftsByThreadId = { ...state.draftsByThreadId };	1637	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
1174	if (shouldRemoveDraft(nextDraft)) {	1638	if (shouldRemoveDraft(nextDraft)) {
1175	delete nextDraftsByThreadId[threadId];	1639	delete nextDraftsByThreadKey[threadKey];
1176	} else {	1640	} else {
1177	nextDraftsByThreadId[threadId] = nextDraft;	1641	nextDraftsByThreadKey[threadKey] = nextDraft;
1178	}	1642	}
1179	return { draftsByThreadId: nextDraftsByThreadId };	1643	return { draftsByThreadKey: nextDraftsByThreadKey };
1180	});	1644	});
1181	}	1645	}
1182		1646
@@ -1258,879 +1722,980 @@ function toHydratedThreadDraft( · 75 unmodified lines
1258	};	1722	};
1259	}	1723	}
1260		1724
1261	export const useComposerDraftStore = create<ComposerDraftStoreState>()(	1725	function toHydratedDraftThreadState(
		1726	persistedDraftThread: PersistedDraftThreadState,
		1727	): DraftThreadState {
		1728	return {
		1729	threadId: persistedDraftThread.threadId,
		1730	environmentId: persistedDraftThread.environmentId as EnvironmentId,
		1731	projectId: persistedDraftThread.projectId,
		1732	logicalProjectKey:
		1733	persistedDraftThread.logicalProjectKey ??
		1734	projectDraftKey(
		1735	scopeProjectRef(
		1736	persistedDraftThread.environmentId as EnvironmentId,
		1737	persistedDraftThread.projectId,
		1738	),
		1739	),
		1740	createdAt: persistedDraftThread.createdAt,
		1741	runtimeMode: persistedDraftThread.runtimeMode,
		1742	interactionMode: persistedDraftThread.interactionMode,
		1743	branch: persistedDraftThread.branch,
		1744	worktreePath: persistedDraftThread.worktreePath,
		1745	envMode: persistedDraftThread.envMode,
		1746	promotedTo: persistedDraftThread.promotedTo
		1747	? scopeThreadRef(
		1748	persistedDraftThread.promotedTo.environmentId as EnvironmentId,
		1749	persistedDraftThread.promotedTo.threadId as ThreadId,
		1750	)
		1751	: null,
		1752	};
		1753	}
		1754
		1755	const composerDraftStore = create<ComposerDraftStoreState>()(
1262	persist(	1756	persist(
1263	(set, get) => ({	1757	(setBase, get) => {
1264	draftsByThreadId: {},	1758	const set = setBase;
1265	draftThreadsByThreadId: {},	1759
1266	projectDraftThreadIdByProjectId: {},	1760	return {
1267	stickyModelSelectionByProvider: {},	1761	draftsByThreadKey: {},
1268	stickyActiveProvider: null,	1762	draftThreadsByThreadKey: {},
1269	getDraftThreadByProjectId: (projectId) => {	1763	logicalProjectDraftThreadKeyByLogicalProjectKey: {},
1270	if (projectId.length === 0) {	1764	stickyModelSelectionByProvider: {},
1271	return null;	1765	stickyActiveProvider: null,
1272	}	1766	getComposerDraft: (target) => getComposerDraftState(get(), target),
1273	const threadId = get().projectDraftThreadIdByProjectId[projectId];	1767	getDraftThreadByLogicalProjectKey: (logicalProjectKey) => {
1274	if (!threadId) {	1768	return get().getDraftSessionByLogicalProjectKey(logicalProjectKey);
1275	return null;	1769	},
1276	}	1770	getDraftSessionByLogicalProjectKey: (logicalProjectKey) => {
1277	const draftThread = get().draftThreadsByThreadId[threadId];	1771	const normalizedLogicalProjectKey = logicalProjectDraftKey(logicalProjectKey);
1278	if (!draftThread \|\| draftThread.projectId !== projectId) {	1772	if (normalizedLogicalProjectKey.length === 0) {
1279	return null;	1773	return null;
1280	}
1281	return {
1282	threadId,
1283	...draftThread,
1284	};
1285	},
1286	getDraftThread: (threadId) => {
1287	if (threadId.length === 0) {
1288	return null;
1289	}
1290	return get().draftThreadsByThreadId[threadId] ?? null;
1291	},
1292	setProjectDraftThreadId: (projectId, threadId, options) => {
1293	if (projectId.length === 0 \|\| threadId.length === 0) {
1294	return;
1295	}
1296	set((state) => {
1297	const existingThread = state.draftThreadsByThreadId[threadId];
1298	const previousThreadIdForProject = state.projectDraftThreadIdByProjectId[projectId];
1299	const nextWorktreePath =
1300	options?.worktreePath === undefined
1301	? (existingThread?.worktreePath ?? null)
1302	: (options.worktreePath ?? null);
1303	const nextDraftThread: DraftThreadState = {
1304	projectId,
1305	createdAt: options?.createdAt ?? existingThread?.createdAt ?? new Date().toISOString(),
1306	runtimeMode:
1307	options?.runtimeMode ?? existingThread?.runtimeMode ?? DEFAULT_RUNTIME_MODE,
1308	interactionMode:
1309	options?.interactionMode ??
1310	existingThread?.interactionMode ??
1311	DEFAULT_INTERACTION_MODE,
1312	branch:
1313	options?.branch === undefined
1314	? (existingThread?.branch ?? null)
1315	: (options.branch ?? null),
1316	worktreePath: nextWorktreePath,
1317	envMode:
1318	options?.envMode ??
1319	(nextWorktreePath ? "worktree" : (existingThread?.envMode ?? "local")),
1320	};
1321	const hasSameProjectMapping = previousThreadIdForProject === threadId;
1322	const hasSameDraftThread =
1323	existingThread &&
1324	existingThread.projectId === nextDraftThread.projectId &&
1325	existingThread.createdAt === nextDraftThread.createdAt &&
1326	existingThread.runtimeMode === nextDraftThread.runtimeMode &&
1327	existingThread.interactionMode === nextDraftThread.interactionMode &&
1328	existingThread.branch === nextDraftThread.branch &&
1329	existingThread.worktreePath === nextDraftThread.worktreePath &&
1330	existingThread.envMode === nextDraftThread.envMode;
1331	if (hasSameProjectMapping && hasSameDraftThread) {
1332	return state;
1333	}
1334	const nextProjectDraftThreadIdByProjectId: Record<ProjectId, ThreadId> = {
1335	...state.projectDraftThreadIdByProjectId,
1336	[projectId]: threadId,
1337	};
1338	const nextDraftThreadsByThreadId: Record<ThreadId, DraftThreadState> = {
1339	...state.draftThreadsByThreadId,
1340	[threadId]: nextDraftThread,
1341	};
1342	let nextDraftsByThreadId = state.draftsByThreadId;
1343	if (
1344	previousThreadIdForProject &&
1345	previousThreadIdForProject !== threadId &&
1346	!Object.values(nextProjectDraftThreadIdByProjectId).includes(previousThreadIdForProject)
1347	) {
1348	delete nextDraftThreadsByThreadId[previousThreadIdForProject];
1349	if (state.draftsByThreadId[previousThreadIdForProject] !== undefined) {
1350	nextDraftsByThreadId = { ...state.draftsByThreadId };
1351	delete nextDraftsByThreadId[previousThreadIdForProject];
1352	}
1353	}
1354	return {
1355	draftsByThreadId: nextDraftsByThreadId,
1356	draftThreadsByThreadId: nextDraftThreadsByThreadId,
1357	projectDraftThreadIdByProjectId: nextProjectDraftThreadIdByProjectId,
1358	};
1359	});
1360	},
1361	setDraftThreadContext: (threadId, options) => {
1362	if (threadId.length === 0) {
1363	return;
1364	}
1365	set((state) => {
1366	const existing = state.draftThreadsByThreadId[threadId];
1367	if (!existing) {
1368	return state;
1369	}	1774	}
1370	const nextProjectId = options.projectId ?? existing.projectId;	1775	const draftId =
1371	if (nextProjectId.length === 0) {	1776	get().logicalProjectDraftThreadKeyByLogicalProjectKey[normalizedLogicalProjectKey];
1372	return state;	1777	if (!draftId) {
		1778	return null;
1373	}	1779	}
1374	const nextWorktreePath =	1780	const draftThread = get().draftThreadsByThreadKey[draftId];
1375	options.worktreePath === undefined	1781	if (!draftThread \|\| isDraftThreadPromoting(draftThread)) {
1376	? existing.worktreePath	1782	return null;
1377	: (options.worktreePath ?? null);
1378	const nextDraftThread: DraftThreadState = {
1379	projectId: nextProjectId,
1380	createdAt:
1381	options.createdAt === undefined
1382	? existing.createdAt
1383	: options.createdAt \|\| existing.createdAt,
1384	runtimeMode: options.runtimeMode ?? existing.runtimeMode,
1385	interactionMode: options.interactionMode ?? existing.interactionMode,
1386	branch: options.branch === undefined ? existing.branch : (options.branch ?? null),
1387	worktreePath: nextWorktreePath,
1388	envMode:
1389	options.envMode ?? (nextWorktreePath ? "worktree" : (existing.envMode ?? "local")),
1390	};
1391	const isUnchanged =
1392	nextDraftThread.projectId === existing.projectId &&
1393	nextDraftThread.createdAt === existing.createdAt &&
1394	nextDraftThread.runtimeMode === existing.runtimeMode &&
1395	nextDraftThread.interactionMode === existing.interactionMode &&
1396	nextDraftThread.branch === existing.branch &&
1397	nextDraftThread.worktreePath === existing.worktreePath &&
1398	nextDraftThread.envMode === existing.envMode;
1399	if (isUnchanged) {
1400	return state;
1401	}	1783	}
1402	const nextProjectDraftThreadIdByProjectId: Record<ProjectId, ThreadId> = {	1784	return toProjectDraftSession(DraftId.makeUnsafe(draftId), draftThread);
1403	...state.projectDraftThreadIdByProjectId,	1785	},
1404	[nextProjectId]: threadId,	1786	getDraftThreadByProjectRef: (projectRef) => {
1405	};	1787	return get().getDraftSessionByProjectRef(projectRef);
1406	if (existing.projectId !== nextProjectId) {	1788	},
1407	if (nextProjectDraftThreadIdByProjectId[existing.projectId] === threadId) {	1789	getDraftSessionByProjectRef: (projectRef) => {
1408	delete nextProjectDraftThreadIdByProjectId[existing.projectId];	1790	for (const [draftId, draftThread] of Object.entries(get().draftThreadsByThreadKey)) {
		1791	if (isDraftThreadPromoting(draftThread)) {
		1792	continue;
1409	}	1793	}
1410	}	1794	if (
1411	return {	1795	draftThread.projectId === projectRef.projectId &&
1412	draftThreadsByThreadId: {	1796	draftThread.environmentId === projectRef.environmentId
1413	...state.draftThreadsByThreadId,	1797	) {
1414	[threadId]: nextDraftThread,	1798	return toProjectDraftSession(DraftId.makeUnsafe(draftId), draftThread);
1415	},
1416	projectDraftThreadIdByProjectId: nextProjectDraftThreadIdByProjectId,
1417	};
1418	});
1419	},
1420	clearProjectDraftThreadId: (projectId) => {
1421	if (projectId.length === 0) {
1422	return;
1423	}
1424	set((state) => {
1425	const threadId = state.projectDraftThreadIdByProjectId[projectId];
1426	if (threadId === undefined) {
1427	return state;
1428	}
1429	const { [projectId]: _removed, ...restProjectMappingsRaw } =
1430	state.projectDraftThreadIdByProjectId;
1431	const restProjectMappings = restProjectMappingsRaw as Record<ProjectId, ThreadId>;
1432	const nextDraftThreadsByThreadId: Record<ThreadId, DraftThreadState> = {
1433	...state.draftThreadsByThreadId,
1434	};
1435	let nextDraftsByThreadId = state.draftsByThreadId;
1436	if (!Object.values(restProjectMappings).includes(threadId)) {
1437	delete nextDraftThreadsByThreadId[threadId];
1438	if (state.draftsByThreadId[threadId] !== undefined) {
1439	nextDraftsByThreadId = { ...state.draftsByThreadId };
1440	delete nextDraftsByThreadId[threadId];
1441	}	1799	}
1442	}	1800	}
1443	return {	1801	return null;
1444	draftsByThreadId: nextDraftsByThreadId,	1802	},
1445	draftThreadsByThreadId: nextDraftThreadsByThreadId,	1803	getDraftSession: (draftId) => get().draftThreadsByThreadKey[draftId] ?? null,
1446	projectDraftThreadIdByProjectId: restProjectMappings,	1804	getDraftSessionByRef: (threadRef) => {
1447	};	1805	for (const draftSession of Object.values(get().draftThreadsByThreadKey)) {
1448	});	1806	if (
1449	},	1807	draftSession.environmentId === threadRef.environmentId &&
1450	clearProjectDraftThreadById: (projectId, threadId) => {	1808	draftSession.threadId === threadRef.threadId
1451	if (projectId.length === 0 \|\| threadId.length === 0) {	1809	) {
1452	return;	1810	return draftSession;
1453	}
1454	set((state) => {
1455	if (state.projectDraftThreadIdByProjectId[projectId] !== threadId) {
1456	return state;
1457	}
1458	const { [projectId]: _removed, ...restProjectMappingsRaw } =
1459	state.projectDraftThreadIdByProjectId;
1460	const restProjectMappings = restProjectMappingsRaw as Record<ProjectId, ThreadId>;
1461	const nextDraftThreadsByThreadId: Record<ThreadId, DraftThreadState> = {
1462	...state.draftThreadsByThreadId,
1463	};
1464	let nextDraftsByThreadId = state.draftsByThreadId;
1465	if (!Object.values(restProjectMappings).includes(threadId)) {
1466	delete nextDraftThreadsByThreadId[threadId];
1467	if (state.draftsByThreadId[threadId] !== undefined) {
1468	nextDraftsByThreadId = { ...state.draftsByThreadId };
1469	delete nextDraftsByThreadId[threadId];
1470	}	1811	}
1471	}	1812	}
1472	return {	1813	return null;
1473	draftsByThreadId: nextDraftsByThreadId,	1814	},
1474	draftThreadsByThreadId: nextDraftThreadsByThreadId,	1815	getDraftThread: (threadRef) => {
1475	projectDraftThreadIdByProjectId: restProjectMappings,	1816	if (typeof threadRef === "string") {
1476	};	1817	return get().getDraftSession(DraftId.makeUnsafe(threadRef));
1477	});
1478	},
1479	clearDraftThread: (threadId) => {
1480	if (threadId.length === 0) {
1481	return;
1482	}
1483	const existing = get().draftsByThreadId[threadId];
1484	if (existing) {
1485	for (const image of existing.images) {
1486	revokeObjectPreviewUrl(image.previewUrl);
1487	}
1488	}
1489	set((state) => {
1490	const hasDraftThread = state.draftThreadsByThreadId[threadId] !== undefined;
1491	const hasProjectMapping = Object.values(state.projectDraftThreadIdByProjectId).includes(
1492	threadId,
1493	);
1494	const hasComposerDraft = state.draftsByThreadId[threadId] !== undefined;
1495	if (!hasDraftThread && !hasProjectMapping && !hasComposerDraft) {
1496	return state;
1497	}
1498	const nextProjectDraftThreadIdByProjectId = Object.fromEntries(
1499	Object.entries(state.projectDraftThreadIdByProjectId).filter(
1500	([, draftThreadId]) => draftThreadId !== threadId,
1501	),
1502	) as Record<ProjectId, ThreadId>;
1503	const { [threadId]: _removedDraftThread, ...restDraftThreadsByThreadId } =
1504	state.draftThreadsByThreadId;
1505	const { [threadId]: _removedComposerDraft, ...restDraftsByThreadId } =
1506	state.draftsByThreadId;
1507	return {
1508	draftsByThreadId: restDraftsByThreadId,
1509	draftThreadsByThreadId: restDraftThreadsByThreadId,
1510	projectDraftThreadIdByProjectId: nextProjectDraftThreadIdByProjectId,
1511	};
1512	});
1513	},
1514	setStickyModelSelection: (modelSelection) => {
1515	const normalized = normalizeModelSelection(modelSelection);
1516	set((state) => {
1517	if (!normalized) {
1518	return state;
1519	}	1818	}
1520	const nextMap: Partial<Record<ProviderKind, ModelSelection>> = {	1819	return get().getDraftSessionByRef(threadRef);
1521	...state.stickyModelSelectionByProvider,	1820	},
1522	[normalized.provider]: normalized,	1821	getDraftThreadByRef: (threadRef) => {
1523	};	1822	return get().getDraftSessionByRef(threadRef);
1524	if (Equal.equals(state.stickyModelSelectionByProvider, nextMap)) {	1823	},
1525	return state.stickyActiveProvider === normalized.provider	1824	listDraftThreadKeys: () =>
1526	? state	1825	Object.values(get().draftThreadsByThreadKey).map((draftThread) =>
1527	: { stickyActiveProvider: normalized.provider };	1826	scopedThreadKey(scopeThreadRef(draftThread.environmentId, draftThread.threadId)),
		1827	),
		1828	hasDraftThreadsInEnvironment: (environmentId) =>
		1829	Object.values(get().draftThreadsByThreadKey).some(
		1830	(draftThread) => draftThread.environmentId === environmentId,
		1831	),
		1832	setLogicalProjectDraftThreadId: (logicalProjectKey, projectRef, draftId, options) => {
		1833	const normalizedLogicalProjectKey = logicalProjectDraftKey(logicalProjectKey);
		1834	if (normalizedLogicalProjectKey.length === 0 \|\| draftId.length === 0) {
		1835	return;
1528	}	1836	}
1529	return {	1837	set((state) => {
1530	stickyModelSelectionByProvider: nextMap,	1838	const existingThread = state.draftThreadsByThreadKey[draftId];
1531	stickyActiveProvider: normalized.provider,	1839	const previousThreadKeyForLogicalProject =
1532	};	1840	state.logicalProjectDraftThreadKeyByLogicalProjectKey[normalizedLogicalProjectKey];
1533	});	1841	const nextDraftThread = createDraftThreadState(
1534	},	1842	projectRef,
1535	applyStickyState: (threadId) => {	1843	options?.threadId ?? existingThread?.threadId ?? ThreadId.makeUnsafe(draftId),
1536	if (threadId.length === 0) {	1844	normalizedLogicalProjectKey,
1537	return;	1845	existingThread,
1538	}	1846	options,
1539	set((state) => {	1847	);
1540	const stickyMap = state.stickyModelSelectionByProvider;	1848	const hasSameLogicalMapping = previousThreadKeyForLogicalProject === draftId;
1541	const stickyActiveProvider = state.stickyActiveProvider;	1849	if (hasSameLogicalMapping && draftThreadsEqual(existingThread, nextDraftThread)) {
1542	if (Object.keys(stickyMap).length === 0 && stickyActiveProvider === null) {	1850	return state;
1543	return state;	1851	}
		1852	const nextLogicalProjectDraftThreadKeyByLogicalProjectKey: Record<string, string> = {
		1853	...state.logicalProjectDraftThreadKeyByLogicalProjectKey,
		1854	[normalizedLogicalProjectKey]: draftId,
		1855	};
		1856	const nextDraftThreadsByThreadKey: Record<string, DraftThreadState> = {
		1857	...state.draftThreadsByThreadKey,
		1858	[draftId]: nextDraftThread,
		1859	};
		1860	let nextDraftsByThreadKey = state.draftsByThreadKey;
		1861	if (
		1862	previousThreadKeyForLogicalProject &&
		1863	previousThreadKeyForLogicalProject !== draftId &&
		1864	!isComposerThreadKeyInUse(
		1865	nextLogicalProjectDraftThreadKeyByLogicalProjectKey,
		1866	previousThreadKeyForLogicalProject,
		1867	)
		1868	) {
		1869	delete nextDraftThreadsByThreadKey[previousThreadKeyForLogicalProject];
		1870	if (state.draftsByThreadKey[previousThreadKeyForLogicalProject] !== undefined) {
		1871	nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		1872	delete nextDraftsByThreadKey[previousThreadKeyForLogicalProject];
		1873	}
		1874	}
		1875	return {
		1876	draftsByThreadKey: nextDraftsByThreadKey,
		1877	draftThreadsByThreadKey: nextDraftThreadsByThreadKey,
		1878	logicalProjectDraftThreadKeyByLogicalProjectKey:
		1879	nextLogicalProjectDraftThreadKeyByLogicalProjectKey,
		1880	};
		1881	});
		1882	},
		1883	setProjectDraftThreadId: (projectRef, draftId, options) => {
		1884	get().setLogicalProjectDraftThreadId(
		1885	projectDraftKey(projectRef),
		1886	projectRef,
		1887	draftId,
		1888	options,
		1889	);
		1890	},
		1891	setDraftThreadContext: (threadRef, options) => {
		1892	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		1893	if (threadKey.length === 0) {
		1894	return;
1544	}	1895	}
1545	const existing = state.draftsByThreadId[threadId];	1896	set((state) => {
1546	const base = existing ?? createEmptyThreadDraft();	1897	const existing = state.draftThreadsByThreadKey[threadKey];
1547	const nextMap = { ...base.modelSelectionByProvider };	1898	if (!existing) {
1548	for (const [provider, selection] of Object.entries(stickyMap)) {	1899	return state;
1549	if (selection) {
1550	const current = nextMap[provider as ProviderKind];
1551	nextMap[provider as ProviderKind] = {
1552	...selection,
1553	model: current?.model ?? selection.model,
1554	};
1555	}	1900	}
		1901	const nextProjectRef = options.projectRef ?? {
		1902	environmentId: existing.environmentId,
		1903	projectId: existing.projectId,
		1904	};
		1905	if (
		1906	nextProjectRef.projectId.length === 0 \|\|
		1907	nextProjectRef.environmentId.length === 0
		1908	) {
		1909	return state;
		1910	}
		1911	const nextWorktreePath =
		1912	options.worktreePath === undefined
		1913	? existing.worktreePath
		1914	: (options.worktreePath ?? null);
		1915	const nextDraftThread: DraftThreadState = {
		1916	threadId: existing.threadId,
		1917	environmentId: nextProjectRef.environmentId,
		1918	projectId: nextProjectRef.projectId,
		1919	logicalProjectKey: existing.logicalProjectKey,
		1920	createdAt:
		1921	options.createdAt === undefined
		1922	? existing.createdAt
		1923	: options.createdAt \|\| existing.createdAt,
		1924	runtimeMode: options.runtimeMode ?? existing.runtimeMode,
		1925	interactionMode: options.interactionMode ?? existing.interactionMode,
		1926	branch: options.branch === undefined ? existing.branch : (options.branch ?? null),
		1927	worktreePath: nextWorktreePath,
		1928	envMode:
		1929	options.envMode ?? (nextWorktreePath ? "worktree" : (existing.envMode ?? "local")),
		1930	promotedTo: existing.promotedTo ?? null,
		1931	};
		1932	const isUnchanged =
		1933	nextDraftThread.environmentId === existing.environmentId &&
		1934	nextDraftThread.projectId === existing.projectId &&
		1935	nextDraftThread.logicalProjectKey === existing.logicalProjectKey &&
		1936	nextDraftThread.createdAt === existing.createdAt &&
		1937	nextDraftThread.runtimeMode === existing.runtimeMode &&
		1938	nextDraftThread.interactionMode === existing.interactionMode &&
		1939	nextDraftThread.branch === existing.branch &&
		1940	nextDraftThread.worktreePath === existing.worktreePath &&
		1941	nextDraftThread.envMode === existing.envMode &&
		1942	scopedThreadRefsEqual(nextDraftThread.promotedTo, existing.promotedTo);
		1943	if (isUnchanged) {
		1944	return state;
		1945	}
		1946	return {
		1947	draftThreadsByThreadKey: {
		1948	...state.draftThreadsByThreadKey,
		1949	[threadKey]: nextDraftThread,
		1950	},
		1951	};
		1952	});
		1953	},
		1954	clearProjectDraftThreadId: (projectRef) => {
		1955	set((state) => {
		1956	const matchingThreadEntry = Object.entries(state.draftThreadsByThreadKey).find(
		1957	([, draftThread]) =>
		1958	draftThread.projectId === projectRef.projectId &&
		1959	draftThread.environmentId === projectRef.environmentId,
		1960	);
		1961	if (!matchingThreadEntry) {
		1962	return state;
		1963	}
		1964	return removeDraftThreadReferences(state, matchingThreadEntry[0]);
		1965	});
		1966	},
		1967	clearProjectDraftThreadById: (projectRef, threadRef) => {
		1968	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		1969	if (threadKey.length === 0) {
		1970	return;
1556	}	1971	}
1557	if (	1972	set((state) => {
1558	Equal.equals(base.modelSelectionByProvider, nextMap) &&	1973	const draftThread = state.draftThreadsByThreadKey[threadKey];
1559	base.activeProvider === stickyActiveProvider	1974	if (
1560	) {	1975	!draftThread \|\|
1561	return state;	1976	draftThread.projectId !== projectRef.projectId \|\|
		1977	draftThread.environmentId !== projectRef.environmentId
		1978	) {
		1979	return state;
		1980	}
		1981	return removeDraftThreadReferences(state, threadKey);
		1982	});
		1983	},
		1984	markDraftThreadPromoting: (threadRef, promotedTo) => {
		1985	const threadKey = resolveComposerDraftKey(get(), threadRef);
		1986	if (!threadKey) {
		1987	return;
1562	}	1988	}
1563	const nextDraft: ComposerThreadDraftState = {	1989	set((state) => {
1564	...base,	1990	const existing = state.draftThreadsByThreadKey[threadKey];
1565	modelSelectionByProvider: nextMap,	1991	if (!existing) {
1566	activeProvider: stickyActiveProvider,	1992	return state;
1567	};	1993	}
1568	const nextDraftsByThreadId = { ...state.draftsByThreadId };	1994	const nextPromotedTo =
1569	if (shouldRemoveDraft(nextDraft)) {	1995	promotedTo ?? scopeThreadRef(existing.environmentId, existing.threadId);
1570	delete nextDraftsByThreadId[threadId];	1996	if (scopedThreadRefsEqual(existing.promotedTo, nextPromotedTo)) {
1571	} else {	1997	return state;
1572	nextDraftsByThreadId[threadId] = nextDraft;	1998	}
		1999	return {
		2000	draftThreadsByThreadKey: {
		2001	...state.draftThreadsByThreadKey,
		2002	[threadKey]: {
		2003	...existing,
		2004	promotedTo: nextPromotedTo,
		2005	},
		2006	},
		2007	};
		2008	});
		2009	},
		2010	finalizePromotedDraftThread: (threadRef) => {
		2011	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2012	if (threadKey.length === 0) {
		2013	return;
1573	}	2014	}
1574	return { draftsByThreadId: nextDraftsByThreadId };	2015	set((state) => {
1575	});	2016	const existing = state.draftThreadsByThreadKey[threadKey];
1576	},	2017	if (!isDraftThreadPromoting(existing)) {
1577	setPrompt: (threadId, prompt) => {	2018	return state;
1578	if (threadId.length === 0) {	2019	}
1579	return;	2020	return removeDraftThreadReferences(state, threadKey);
1580	}	2021	});
1581	set((state) => {	2022	},
1582	const existing = state.draftsByThreadId[threadId] ?? createEmptyThreadDraft();	2023	clearDraftThread: (threadRef) => {
1583	const nextDraft: ComposerThreadDraftState = {	2024	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
1584	...existing,	2025	if (threadKey.length === 0) {
1585	prompt,	2026	return;
1586	};
1587	const nextDraftsByThreadId = { ...state.draftsByThreadId };
1588	if (shouldRemoveDraft(nextDraft)) {
1589	delete nextDraftsByThreadId[threadId];
1590	} else {
1591	nextDraftsByThreadId[threadId] = nextDraft;
1592	}	2027	}
1593	return { draftsByThreadId: nextDraftsByThreadId };	2028	const existing = get().draftsByThreadKey[threadKey];
1594	});	2029	if (existing) {
1595	},	2030	for (const image of existing.images) {
1596	setTerminalContexts: (threadId, contexts) => {	2031	revokeObjectPreviewUrl(image.previewUrl);
1597	if (threadId.length === 0) {	2032	}
1598	return;
1599	}
1600	const normalizedContexts = normalizeTerminalContextsForThread(threadId, contexts);
1601	set((state) => {
1602	const existing = state.draftsByThreadId[threadId] ?? createEmptyThreadDraft();
1603	const nextDraft: ComposerThreadDraftState = {
1604	...existing,
1605	prompt: ensureInlineTerminalContextPlaceholders(
1606	existing.prompt,
1607	normalizedContexts.length,
1608	),
1609	terminalContexts: normalizedContexts,
1610	};
1611	const nextDraftsByThreadId = { ...state.draftsByThreadId };
1612	if (shouldRemoveDraft(nextDraft)) {
1613	delete nextDraftsByThreadId[threadId];
1614	} else {
1615	nextDraftsByThreadId[threadId] = nextDraft;
1616	}	2033	}
1617	return { draftsByThreadId: nextDraftsByThreadId };	2034	set((state) => {
1618	});	2035	const hasDraftThread = state.draftThreadsByThreadKey[threadKey] !== undefined;
1619	},	2036	const hasLogicalProjectMapping = Object.values(
1620	setModelSelection: (threadId, modelSelection) => {	2037	state.logicalProjectDraftThreadKeyByLogicalProjectKey,
1621	if (threadId.length === 0) {	2038	).includes(threadKey);
1622	return;	2039	const hasComposerDraft = state.draftsByThreadKey[threadKey] !== undefined;
1623	}	2040	if (!hasDraftThread && !hasLogicalProjectMapping && !hasComposerDraft) {
1624	const normalized = normalizeModelSelection(modelSelection);	2041	return state;
1625	set((state) => {	2042	}
1626	const existing = state.draftsByThreadId[threadId];	2043	return removeDraftThreadReferences(state, threadKey);
1627	if (!existing && normalized === null) {	2044	});
1628	return state;	2045	},
		2046	setStickyModelSelection: (modelSelection) => {
		2047	const normalized = normalizeModelSelection(modelSelection);
		2048	set((state) => {
		2049	if (!normalized) {
		2050	return state;
		2051	}
		2052	const nextMap: Partial<Record<ProviderKind, ModelSelection>> = {
		2053	...state.stickyModelSelectionByProvider,
		2054	[normalized.provider]: normalized,
		2055	};
		2056	if (Equal.equals(state.stickyModelSelectionByProvider, nextMap)) {
		2057	return state.stickyActiveProvider === normalized.provider
		2058	? state
		2059	: { stickyActiveProvider: normalized.provider };
		2060	}
		2061	return {
		2062	stickyModelSelectionByProvider: nextMap,
		2063	stickyActiveProvider: normalized.provider,
		2064	};
		2065	});
		2066	},
		2067	applyStickyState: (threadRef) => {
		2068	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2069	if (threadKey.length === 0) {
		2070	return;
1629	}	2071	}
1630	const base = existing ?? createEmptyThreadDraft();	2072	set((state) => {
1631	const nextMap = { ...base.modelSelectionByProvider };	2073	const stickyMap = state.stickyModelSelectionByProvider;
1632	if (normalized) {	2074	const stickyActiveProvider = state.stickyActiveProvider;
1633	const current = nextMap[normalized.provider];	2075	if (Object.keys(stickyMap).length === 0 && stickyActiveProvider === null) {
1634	if (normalized.options !== undefined) {	2076	return state;
1635	// Explicit options provided → use them	2077	}
1636	nextMap[normalized.provider] = normalized;	2078	const existing = state.draftsByThreadKey[threadKey];
		2079	const base = existing ?? createEmptyThreadDraft();
		2080	const nextMap = { ...base.modelSelectionByProvider };
		2081	for (const [provider, selection] of Object.entries(stickyMap)) {
		2082	if (selection) {
		2083	const current = nextMap[provider as ProviderKind];
		2084	nextMap[provider as ProviderKind] = {
		2085	...selection,
		2086	model: current?.model ?? selection.model,
		2087	};
		2088	}
		2089	}
		2090	if (
		2091	Equal.equals(base.modelSelectionByProvider, nextMap) &&
		2092	base.activeProvider === stickyActiveProvider
		2093	) {
		2094	return state;
		2095	}
		2096	const nextDraft: ComposerThreadDraftState = {
		2097	...base,
		2098	modelSelectionByProvider: nextMap,
		2099	activeProvider: stickyActiveProvider,
		2100	};
		2101	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		2102	if (shouldRemoveDraft(nextDraft)) {
		2103	delete nextDraftsByThreadKey[threadKey];
1637	} else {	2104	} else {
1638	// No options in selection → preserve existing options, update provider+model	2105	nextDraftsByThreadKey[threadKey] = nextDraft;
1639	nextMap[normalized.provider] = {
1640	provider: normalized.provider,
1641	model: normalized.model,
1642	...(current?.options ? { options: current.options } : {}),
1643	};
1644	}	2106	}
		2107	return { draftsByThreadKey: nextDraftsByThreadKey };
		2108	});
		2109	},
		2110	setPrompt: (threadRef, prompt) => {
		2111	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2112	if (threadKey.length === 0) {
		2113	return;
1645	}	2114	}
1646	const nextActiveProvider = normalized?.provider ?? base.activeProvider;	2115	set((state) => {
1647	if (	2116	const existing = state.draftsByThreadKey[threadKey] ?? createEmptyThreadDraft();
1648	Equal.equals(base.modelSelectionByProvider, nextMap) &&	2117	const nextDraft: ComposerThreadDraftState = {
1649	base.activeProvider === nextActiveProvider	2118	...existing,
1650	) {	2119	prompt,
1651	return state;	2120	};
1652	}	2121	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
1653	const nextDraft: ComposerThreadDraftState = {	2122	if (shouldRemoveDraft(nextDraft)) {
1654	...base,	2123	delete nextDraftsByThreadKey[threadKey];
1655	modelSelectionByProvider: nextMap,	2124	} else {
1656	activeProvider: nextActiveProvider,	2125	nextDraftsByThreadKey[threadKey] = nextDraft;
1657	};
1658	const nextDraftsByThreadId = { ...state.draftsByThreadId };
1659	if (shouldRemoveDraft(nextDraft)) {
1660	delete nextDraftsByThreadId[threadId];
1661	} else {
1662	nextDraftsByThreadId[threadId] = nextDraft;
1663	}
1664	return { draftsByThreadId: nextDraftsByThreadId };
1665	});
1666	},
1667	setModelOptions: (threadId, modelOptions) => {
1668	if (threadId.length === 0) {
1669	return;
1670	}
1671	const normalizedOpts = normalizeProviderModelOptions(modelOptions);
1672	set((state) => {
1673	const existing = state.draftsByThreadId[threadId];
1674	if (!existing && normalizedOpts === null) {
1675	return state;
1676	}
1677	const base = existing ?? createEmptyThreadDraft();
1678	const nextMap = { ...base.modelSelectionByProvider };
1679	for (const provider of ["codex", "claudeAgent"] as const) {
1680	// Only touch providers explicitly present in the input
1681	if (!normalizedOpts \|\| !(provider in normalizedOpts)) continue;
1682	const opts = normalizedOpts[provider];
1683	const current = nextMap[provider];
1684	if (opts) {
1685	nextMap[provider] = {
1686	provider,
1687	model: current?.model ?? DEFAULT_MODEL_BY_PROVIDER[provider],
1688	options: opts,
1689	};
1690	} else if (current?.options) {
1691	// Remove options but keep the selection
1692	const { options: _, ...rest } = current;
1693	nextMap[provider] = rest as ModelSelection;
1694	}	2126	}
		2127	return { draftsByThreadKey: nextDraftsByThreadKey };
		2128	});
		2129	},
		2130	setTerminalContexts: (threadRef, contexts) => {
		2131	const threadKey = resolveComposerDraftKey(get(), threadRef);
		2132	const threadId = resolveComposerThreadId(get(), threadRef);
		2133	if (!threadKey \|\| !threadId) {
		2134	return;
1695	}	2135	}
1696	if (Equal.equals(base.modelSelectionByProvider, nextMap)) {	2136	const normalizedContexts = normalizeTerminalContextsForThread(threadId, contexts);
1697	return state;	2137	set((state) => {
		2138	const existing = state.draftsByThreadKey[threadKey] ?? createEmptyThreadDraft();
		2139	const nextDraft: ComposerThreadDraftState = {
		2140	...existing,
		2141	prompt: ensureInlineTerminalContextPlaceholders(
		2142	existing.prompt,
		2143	normalizedContexts.length,
		2144	),
		2145	terminalContexts: normalizedContexts,
		2146	};
		2147	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		2148	if (shouldRemoveDraft(nextDraft)) {
		2149	delete nextDraftsByThreadKey[threadKey];
		2150	} else {
		2151	nextDraftsByThreadKey[threadKey] = nextDraft;
		2152	}
		2153	return { draftsByThreadKey: nextDraftsByThreadKey };
		2154	});
		2155	},
		2156	setModelSelection: (threadRef, modelSelection) => {
		2157	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2158	if (threadKey.length === 0) {
		2159	return;
1698	}	2160	}
1699	const nextDraft: ComposerThreadDraftState = {	2161	const normalized = normalizeModelSelection(modelSelection);
1700	...base,	2162	set((state) => {
1701	modelSelectionByProvider: nextMap,	2163	const existing = state.draftsByThreadKey[threadKey];
1702	};	2164	if (!existing && normalized === null) {
1703	const nextDraftsByThreadId = { ...state.draftsByThreadId };	2165	return state;
1704	if (shouldRemoveDraft(nextDraft)) {	2166	}
1705	delete nextDraftsByThreadId[threadId];	2167	const base = existing ?? createEmptyThreadDraft();
1706	} else {	2168	const nextMap = { ...base.modelSelectionByProvider };
1707	nextDraftsByThreadId[threadId] = nextDraft;	2169	if (normalized) {
		2170	const current = nextMap[normalized.provider];
		2171	if (normalized.options !== undefined) {
		2172	// Explicit options provided → use them
		2173	nextMap[normalized.provider] = normalized;
		2174	} else {
		2175	// No options in selection → preserve existing options, update provider+model
		2176	nextMap[normalized.provider] = {
		2177	provider: normalized.provider,
		2178	model: normalized.model,
		2179	...(current?.options ? { options: current.options } : {}),
		2180	};
		2181	}
		2182	}
		2183	const nextActiveProvider = normalized?.provider ?? base.activeProvider;
		2184	if (
		2185	Equal.equals(base.modelSelectionByProvider, nextMap) &&
		2186	base.activeProvider === nextActiveProvider
		2187	) {
		2188	return state;
		2189	}
		2190	const nextDraft: ComposerThreadDraftState = {
		2191	...base,
		2192	modelSelectionByProvider: nextMap,
		2193	activeProvider: nextActiveProvider,
		2194	};
		2195	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		2196	if (shouldRemoveDraft(nextDraft)) {
		2197	delete nextDraftsByThreadKey[threadKey];
		2198	} else {
		2199	nextDraftsByThreadKey[threadKey] = nextDraft;
		2200	}
		2201	return { draftsByThreadKey: nextDraftsByThreadKey };
		2202	});
		2203	},
		2204	setModelOptions: (threadRef, modelOptions) => {
		2205	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2206	if (threadKey.length === 0) {
		2207	return;
1708	}	2208	}
1709	return { draftsByThreadId: nextDraftsByThreadId };	2209	const normalizedOpts = normalizeProviderModelOptions(modelOptions);
1710	});	2210	set((state) => {
1711	},	2211	const existing = state.draftsByThreadKey[threadKey];
1712	setProviderModelOptions: (threadId, provider, nextProviderOptions, options) => {	2212	if (!existing && normalizedOpts === null) {
1713	if (threadId.length === 0) {	2213	return state;
1714	return;	2214	}
1715	}	2215	const base = existing ?? createEmptyThreadDraft();
1716	const normalizedProvider = normalizeProviderKind(provider);	2216	const nextMap = { ...base.modelSelectionByProvider };
1717	if (normalizedProvider === null) {	2217	for (const provider of ["codex", "claudeAgent"] as const) {
1718	return;	2218	// Only touch providers explicitly present in the input
1719	}	2219	if (!normalizedOpts \|\| !(provider in normalizedOpts)) continue;
1720	// Normalize just this provider's options	2220	const opts = normalizedOpts[provider];
1721	const normalizedOpts = normalizeProviderModelOptions(	2221	const current = nextMap[provider];
1722	{ [normalizedProvider]: nextProviderOptions },	2222	if (opts) {
1723	normalizedProvider,	2223	nextMap[provider] = {
1724	);	2224	provider,
1725	const providerOpts = normalizedOpts?.[normalizedProvider];	2225	model: current?.model ?? DEFAULT_MODEL_BY_PROVIDER[provider],
1726		2226	options: opts,
1727	set((state) => {	2227	};
1728	const existing = state.draftsByThreadId[threadId];	2228	} else if (current?.options) {
1729	const base = existing ?? createEmptyThreadDraft();	2229	// Remove options but keep the selection
1730		2230	const { options: _, ...rest } = current;
1731	// Update the map entry for this provider	2231	nextMap[provider] = rest as ModelSelection;
1732	const nextMap = { ...base.modelSelectionByProvider };	2232	}
1733	const currentForProvider = nextMap[normalizedProvider];	2233	}
1734	if (providerOpts) {	2234	if (Equal.equals(base.modelSelectionByProvider, nextMap)) {
1735	nextMap[normalizedProvider] = {	2235	return state;
1736	provider: normalizedProvider,	2236	}
1737	model: currentForProvider?.model ?? DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],	2237	const nextDraft: ComposerThreadDraftState = {
1738	options: providerOpts,	2238	...base,
		2239	modelSelectionByProvider: nextMap,
1739	};	2240	};
1740	} else if (currentForProvider?.options) {	2241	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
1741	const { options: _, ...rest } = currentForProvider;	2242	if (shouldRemoveDraft(nextDraft)) {
1742	nextMap[normalizedProvider] = rest as ModelSelection;	2243	delete nextDraftsByThreadKey[threadKey];
		2244	} else {
		2245	nextDraftsByThreadKey[threadKey] = nextDraft;
		2246	}
		2247	return { draftsByThreadKey: nextDraftsByThreadKey };
		2248	});
		2249	},
		2250	setProviderModelOptions: (threadRef, provider, nextProviderOptions, options) => {
		2251	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2252	if (threadKey.length === 0) {
		2253	return;
1743	}	2254	}
		2255	const normalizedProvider = normalizeProviderKind(provider);
		2256	if (normalizedProvider === null) {
		2257	return;
		2258	}
		2259	// Normalize just this provider's options
		2260	const normalizedOpts = normalizeProviderModelOptions(
		2261	{ [normalizedProvider]: nextProviderOptions },
		2262	normalizedProvider,
		2263	);
		2264	const providerOpts = normalizedOpts?.[normalizedProvider];
1744		2265
1745	// Handle sticky persistence	2266	set((state) => {
1746	let nextStickyMap = state.stickyModelSelectionByProvider;	2267	const existing = state.draftsByThreadKey[threadKey];
1747	let nextStickyActiveProvider = state.stickyActiveProvider;	2268	const base = existing ?? createEmptyThreadDraft();
1748	if (options?.persistSticky === true) {	2269
1749	nextStickyMap = { ...state.stickyModelSelectionByProvider };	2270	// Update the map entry for this provider
1750	const stickyBase =	2271	const nextMap = { ...base.modelSelectionByProvider };
1751	nextStickyMap[normalizedProvider] ??	2272	const currentForProvider = nextMap[normalizedProvider];
1752	base.modelSelectionByProvider[normalizedProvider] ??
1753	({
1754	provider: normalizedProvider,
1755	model: DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
1756	} as ModelSelection);
1757	if (providerOpts) {	2273	if (providerOpts) {
1758	nextStickyMap[normalizedProvider] = {	2274	nextMap[normalizedProvider] = {
1759	...stickyBase,
1760	provider: normalizedProvider,	2275	provider: normalizedProvider,
		2276	model: currentForProvider?.model ?? DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
1761	options: providerOpts,	2277	options: providerOpts,
1762	};	2278	};
1763	} else if (stickyBase.options) {	2279	} else if (currentForProvider?.options) {
1764	const { options: _, ...rest } = stickyBase;	2280	const { options: _, ...rest } = currentForProvider;
1765	nextStickyMap[normalizedProvider] = rest as ModelSelection;	2281	nextMap[normalizedProvider] = rest as ModelSelection;
1766	}	2282	}
1767	nextStickyActiveProvider = base.activeProvider ?? normalizedProvider;
1768	}
1769		2283
1770	if (	2284	// Handle sticky persistence
1771	Equal.equals(base.modelSelectionByProvider, nextMap) &&	2285	let nextStickyMap = state.stickyModelSelectionByProvider;
1772	Equal.equals(state.stickyModelSelectionByProvider, nextStickyMap) &&	2286	let nextStickyActiveProvider = state.stickyActiveProvider;
1773	state.stickyActiveProvider === nextStickyActiveProvider	2287	if (options?.persistSticky === true) {
1774	) {	2288	nextStickyMap = { ...state.stickyModelSelectionByProvider };
1775	return state;	2289	const stickyBase =
1776	}	2290	nextStickyMap[normalizedProvider] ??
		2291	base.modelSelectionByProvider[normalizedProvider] ??
		2292	({
		2293	provider: normalizedProvider,
		2294	model: DEFAULT_MODEL_BY_PROVIDER[normalizedProvider],
		2295	} as ModelSelection);
		2296	if (providerOpts) {
		2297	nextStickyMap[normalizedProvider] = {
		2298	...stickyBase,
		2299	provider: normalizedProvider,
		2300	options: providerOpts,
		2301	};
		2302	} else if (stickyBase.options) {
		2303	const { options: _, ...rest } = stickyBase;
		2304	nextStickyMap[normalizedProvider] = rest as ModelSelection;
		2305	}
		2306	nextStickyActiveProvider = base.activeProvider ?? normalizedProvider;
		2307	}
1777		2308
1778	const nextDraft: ComposerThreadDraftState = {	2309	if (
1779	...base,	2310	Equal.equals(base.modelSelectionByProvider, nextMap) &&
1780	modelSelectionByProvider: nextMap,	2311	Equal.equals(state.stickyModelSelectionByProvider, nextStickyMap) &&
1781	};	2312	state.stickyActiveProvider === nextStickyActiveProvider
1782	const nextDraftsByThreadId = { ...state.draftsByThreadId };	2313	) {
1783	if (shouldRemoveDraft(nextDraft)) {	2314	return state;
1784	delete nextDraftsByThreadId[threadId];	2315	}
1785	} else {
1786	nextDraftsByThreadId[threadId] = nextDraft;
1787	}
1788		2316
1789	return {	2317	const nextDraft: ComposerThreadDraftState = {
1790	draftsByThreadId: nextDraftsByThreadId,	2318	...base,
1791	...(options?.persistSticky === true	2319	modelSelectionByProvider: nextMap,
1792	? {	2320	};
1793	stickyModelSelectionByProvider: nextStickyMap,	2321	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
1794	stickyActiveProvider: nextStickyActiveProvider,	2322	if (shouldRemoveDraft(nextDraft)) {
1795	}	2323	delete nextDraftsByThreadKey[threadKey];
1796	: {}),	2324	} else {
1797	};	2325	nextDraftsByThreadKey[threadKey] = nextDraft;
1798	});	2326	}
1799	},	2327
1800	setRuntimeMode: (threadId, runtimeMode) => {	2328	return {
1801	if (threadId.length === 0) {	2329	draftsByThreadKey: nextDraftsByThreadKey,
1802	return;	2330	...(options?.persistSticky === true
1803	}	2331	? {
1804	const nextRuntimeMode =	2332	stickyModelSelectionByProvider: nextStickyMap,
1805	runtimeMode === "approval-required" \|\| runtimeMode === "full-access" ? runtimeMode : null;	2333	stickyActiveProvider: nextStickyActiveProvider,
1806	set((state) => {	2334	}
1807	const existing = state.draftsByThreadId[threadId];	2335	: {}),
1808	if (!existing && nextRuntimeMode === null) {	2336	};
1809	return state;	2337	});
1810	}	2338	},
1811	const base = existing ?? createEmptyThreadDraft();	2339	setRuntimeMode: (threadRef, runtimeMode) => {
1812	if (base.runtimeMode === nextRuntimeMode) {	2340	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
1813	return state;	2341	if (threadKey.length === 0) {
1814	}	2342	return;
1815	const nextDraft: ComposerThreadDraftState = {
1816	...base,
1817	runtimeMode: nextRuntimeMode,
1818	};
1819	const nextDraftsByThreadId = { ...state.draftsByThreadId };
1820	if (shouldRemoveDraft(nextDraft)) {
1821	delete nextDraftsByThreadId[threadId];
1822	} else {
1823	nextDraftsByThreadId[threadId] = nextDraft;
1824	}
1825	return { draftsByThreadId: nextDraftsByThreadId };
1826	});
1827	},
1828	setInteractionMode: (threadId, interactionMode) => {
1829	if (threadId.length === 0) {
1830	return;
1831	}
1832	const nextInteractionMode =
1833	interactionMode === "plan" \|\| interactionMode === "default" ? interactionMode : null;
1834	set((state) => {
1835	const existing = state.draftsByThreadId[threadId];
1836	if (!existing && nextInteractionMode === null) {
1837	return state;
1838	}	2343	}
1839	const base = existing ?? createEmptyThreadDraft();	2344	const nextRuntimeMode =
1840	if (base.interactionMode === nextInteractionMode) {	2345	runtimeMode === "approval-required" \|\| runtimeMode === "full-access"
1841	return state;	2346	? runtimeMode
		2347	: null;
		2348	set((state) => {
		2349	const existing = state.draftsByThreadKey[threadKey];
		2350	if (!existing && nextRuntimeMode === null) {
		2351	return state;
		2352	}
		2353	const base = existing ?? createEmptyThreadDraft();
		2354	if (base.runtimeMode === nextRuntimeMode) {
		2355	return state;
		2356	}
		2357	const nextDraft: ComposerThreadDraftState = {
		2358	...base,
		2359	runtimeMode: nextRuntimeMode,
		2360	};
		2361	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		2362	if (shouldRemoveDraft(nextDraft)) {
		2363	delete nextDraftsByThreadKey[threadKey];
		2364	} else {
		2365	nextDraftsByThreadKey[threadKey] = nextDraft;
		2366	}
		2367	return { draftsByThreadKey: nextDraftsByThreadKey };
		2368	});
		2369	},
		2370	setInteractionMode: (threadRef, interactionMode) => {
		2371	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2372	if (threadKey.length === 0) {
		2373	return;
1842	}	2374	}
1843	const nextDraft: ComposerThreadDraftState = {	2375	const nextInteractionMode =
1844	...base,	2376	interactionMode === "plan" \|\| interactionMode === "default" ? interactionMode : null;
1845	interactionMode: nextInteractionMode,	2377	set((state) => {
1846	};	2378	const existing = state.draftsByThreadKey[threadKey];
1847	const nextDraftsByThreadId = { ...state.draftsByThreadId };	2379	if (!existing && nextInteractionMode === null) {
1848	if (shouldRemoveDraft(nextDraft)) {	2380	return state;
1849	delete nextDraftsByThreadId[threadId];	2381	}
1850	} else {	2382	const base = existing ?? createEmptyThreadDraft();
1851	nextDraftsByThreadId[threadId] = nextDraft;	2383	if (base.interactionMode === nextInteractionMode) {
		2384	return state;
		2385	}
		2386	const nextDraft: ComposerThreadDraftState = {
		2387	...base,
		2388	interactionMode: nextInteractionMode,
		2389	};
		2390	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		2391	if (shouldRemoveDraft(nextDraft)) {
		2392	delete nextDraftsByThreadKey[threadKey];
		2393	} else {
		2394	nextDraftsByThreadKey[threadKey] = nextDraft;
		2395	}
		2396	return { draftsByThreadKey: nextDraftsByThreadKey };
		2397	});
		2398	},
		2399	addImage: (threadRef, image) => {
		2400	const threadKey = resolveComposerDraftKey(get(), threadRef);
		2401	const threadId = resolveComposerThreadId(get(), threadRef);
		2402	if (!threadKey \|\| !threadId) {
		2403	return;
1852	}	2404	}
1853	return { draftsByThreadId: nextDraftsByThreadId };	2405	get().addImages(
1854	});	2406	typeof threadRef === "string" ? DraftId.makeUnsafe(threadKey) : threadRef,
1855	},	2407	[image],
1856	addImage: (threadId, image) => {
1857	if (threadId.length === 0) {
1858	return;
1859	}
1860	get().addImages(threadId, [image]);
1861	},
1862	addImages: (threadId, images) => {
1863	if (threadId.length === 0 \|\| images.length === 0) {
1864	return;
1865	}
1866	set((state) => {
1867	const existing = state.draftsByThreadId[threadId] ?? createEmptyThreadDraft();
1868	const existingIds = new Set(existing.images.map((image) => image.id));
1869	const existingDedupKeys = new Set(
1870	existing.images.map((image) => composerImageDedupKey(image)),
1871	);	2408	);
1872	const acceptedPreviewUrls = new Set(existing.images.map((image) => image.previewUrl));	2409	},
1873	const dedupedIncoming: ComposerImageAttachment[] = [];	2410	addImages: (threadRef, images) => {
1874	for (const image of images) {	2411	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
1875	const dedupKey = composerImageDedupKey(image);	2412	if (threadKey.length === 0 \|\| images.length === 0) {
1876	if (existingIds.has(image.id) \|\| existingDedupKeys.has(dedupKey)) {	2413	return;
1877	// Avoid revoking a blob URL that's still referenced by an accepted image.	2414	}
1878	if (!acceptedPreviewUrls.has(image.previewUrl)) {	2415	set((state) => {
1879	revokeObjectPreviewUrl(image.previewUrl);	2416	const existing = state.draftsByThreadKey[threadKey] ?? createEmptyThreadDraft();
		2417	const existingIds = new Set(existing.images.map((image) => image.id));
		2418	const existingDedupKeys = new Set(
		2419	existing.images.map((image) => composerImageDedupKey(image)),
		2420	);
		2421	const acceptedPreviewUrls = new Set(existing.images.map((image) => image.previewUrl));
		2422	const dedupedIncoming: ComposerImageAttachment[] = [];
		2423	for (const image of images) {
		2424	const dedupKey = composerImageDedupKey(image);
		2425	if (existingIds.has(image.id) \|\| existingDedupKeys.has(dedupKey)) {
		2426	// Avoid revoking a blob URL that's still referenced by an accepted image.
		2427	if (!acceptedPreviewUrls.has(image.previewUrl)) {
		2428	revokeObjectPreviewUrl(image.previewUrl);
		2429	}
		2430	continue;
1880	}	2431	}
1881	continue;	2432	dedupedIncoming.push(image);
		2433	existingIds.add(image.id);
		2434	existingDedupKeys.add(dedupKey);
		2435	acceptedPreviewUrls.add(image.previewUrl);
1882	}	2436	}
1883	dedupedIncoming.push(image);	2437	if (dedupedIncoming.length === 0) {
1884	existingIds.add(image.id);	2438	return state;
1885	existingDedupKeys.add(dedupKey);	2439	}
1886	acceptedPreviewUrls.add(image.previewUrl);	2440	return {
1887	}	2441	draftsByThreadKey: {
1888	if (dedupedIncoming.length === 0) {	2442	...state.draftsByThreadKey,
1889	return state;	2443	[threadKey]: {
1890	}	2444	...existing,
1891	return {	2445	images: [...existing.images, ...dedupedIncoming],
1892	draftsByThreadId: {	2446	},
1893	...state.draftsByThreadId,
1894	[threadId]: {
1895	...existing,
1896	images: [...existing.images, ...dedupedIncoming],
1897	},	2447	},
1898	},	2448	};
1899	};	2449	});
1900	});	2450	},
1901	},	2451	removeImage: (threadRef, imageId) => {
1902	removeImage: (threadId, imageId) => {	2452	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
1903	if (threadId.length === 0) {	2453	if (threadKey.length === 0) {
1904	return;	2454	return;
1905	}
1906	const existing = get().draftsByThreadId[threadId];
1907	if (!existing) {
1908	return;
1909	}
1910	const removedImage = existing.images.find((image) => image.id === imageId);
1911	if (removedImage) {
1912	revokeObjectPreviewUrl(removedImage.previewUrl);
1913	}
1914	set((state) => {
1915	const current = state.draftsByThreadId[threadId];
1916	if (!current) {
1917	return state;
1918	}
1919	const nextDraft: ComposerThreadDraftState = {
1920	...current,
1921	images: current.images.filter((image) => image.id !== imageId),
1922	nonPersistedImageIds: current.nonPersistedImageIds.filter((id) => id !== imageId),
1923	persistedAttachments: current.persistedAttachments.filter(
1924	(attachment) => attachment.id !== imageId,
1925	),
1926	};
1927	const nextDraftsByThreadId = { ...state.draftsByThreadId };
1928	if (shouldRemoveDraft(nextDraft)) {
1929	delete nextDraftsByThreadId[threadId];
1930	} else {
1931	nextDraftsByThreadId[threadId] = nextDraft;
1932	}	2455	}
1933	return { draftsByThreadId: nextDraftsByThreadId };	2456	const existing = get().draftsByThreadKey[threadKey];
1934	});	2457	if (!existing) {
1935	},	2458	return;
1936	insertTerminalContext: (threadId, prompt, context, index) => {
1937	if (threadId.length === 0) {
1938	return false;
1939	}
1940	let inserted = false;
1941	set((state) => {
1942	const existing = state.draftsByThreadId[threadId] ?? createEmptyThreadDraft();
1943	const normalizedContext = normalizeTerminalContextForThread(threadId, context);
1944	if (!normalizedContext) {
1945	return state;
1946	}	2459	}
1947	const dedupKey = terminalContextDedupKey(normalizedContext);	2460	const removedImage = existing.images.find((image) => image.id === imageId);
1948	if (	2461	if (removedImage) {
1949	existing.terminalContexts.some((entry) => entry.id === normalizedContext.id) \|\|	2462	revokeObjectPreviewUrl(removedImage.previewUrl);
1950	existing.terminalContexts.some((entry) => terminalContextDedupKey(entry) === dedupKey)
1951	) {
1952	return state;
1953	}	2463	}
1954	inserted = true;	2464	set((state) => {
1955	const boundedIndex = Math.max(0, Math.min(existing.terminalContexts.length, index));	2465	const current = state.draftsByThreadKey[threadKey];
1956	const nextDraft: ComposerThreadDraftState = {	2466	if (!current) {
1957	...existing,	2467	return state;
1958	prompt,	2468	}
1959	terminalContexts: [	2469	const nextDraft: ComposerThreadDraftState = {
1960	...existing.terminalContexts.slice(0, boundedIndex),	2470	...current,
1961	normalizedContext,	2471	images: current.images.filter((image) => image.id !== imageId),
1962	...existing.terminalContexts.slice(boundedIndex),	2472	nonPersistedImageIds: current.nonPersistedImageIds.filter((id) => id !== imageId),
1963	],	2473	persistedAttachments: current.persistedAttachments.filter(
1964	};	2474	(attachment) => attachment.id !== imageId,
1965	return {	2475	),
1966	draftsByThreadId: {	2476	};
1967	...state.draftsByThreadId,	2477	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
1968	[threadId]: nextDraft,	2478	if (shouldRemoveDraft(nextDraft)) {
1969	},	2479	delete nextDraftsByThreadKey[threadKey];
1970	};	2480	} else {
1971	});	2481	nextDraftsByThreadKey[threadKey] = nextDraft;
1972	return inserted;	2482	}
1973	},	2483	return { draftsByThreadKey: nextDraftsByThreadKey };
1974	addTerminalContext: (threadId, context) => {	2484	});
1975	if (threadId.length === 0) {	2485	},
1976	return;	2486	insertTerminalContext: (threadRef, prompt, context, index) => {
1977	}	2487	const threadKey = resolveComposerDraftKey(get(), threadRef);
1978	get().addTerminalContexts(threadId, [context]);	2488	const threadId = resolveComposerThreadId(get(), threadRef);
1979	},	2489	if (!threadKey \|\| !threadId) {
1980	addTerminalContexts: (threadId, contexts) => {	2490	return false;
1981	if (threadId.length === 0 \|\| contexts.length === 0) {
1982	return;
1983	}
1984	set((state) => {
1985	const existing = state.draftsByThreadId[threadId] ?? createEmptyThreadDraft();
1986	const acceptedContexts = normalizeTerminalContextsForThread(threadId, [
1987	...existing.terminalContexts,
1988	...contexts,
1989	]).slice(existing.terminalContexts.length);
1990	if (acceptedContexts.length === 0) {
1991	return state;
1992	}	2491	}
1993	return {	2492	let inserted = false;
1994	draftsByThreadId: {	2493	set((state) => {
1995	...state.draftsByThreadId,	2494	const existing = state.draftsByThreadKey[threadKey] ?? createEmptyThreadDraft();
1996	[threadId]: {	2495	const normalizedContext = normalizeTerminalContextForThread(threadId, context);
1997	...existing,	2496	if (!normalizedContext) {
1998	prompt: ensureInlineTerminalContextPlaceholders(	2497	return state;
1999	existing.prompt,	2498	}
2000	existing.terminalContexts.length + acceptedContexts.length,	2499	const dedupKey = terminalContextDedupKey(normalizedContext);
2001	),	2500	if (
2002	terminalContexts: [...existing.terminalContexts, ...acceptedContexts],	2501	existing.terminalContexts.some((entry) => entry.id === normalizedContext.id) \|\|
		2502	existing.terminalContexts.some((entry) => terminalContextDedupKey(entry) === dedupKey)
		2503	) {
		2504	return state;
		2505	}
		2506	inserted = true;
		2507	const boundedIndex = Math.max(0, Math.min(existing.terminalContexts.length, index));
		2508	const nextDraft: ComposerThreadDraftState = {
		2509	...existing,
		2510	prompt,
		2511	terminalContexts: [
		2512	...existing.terminalContexts.slice(0, boundedIndex),
		2513	normalizedContext,
		2514	...existing.terminalContexts.slice(boundedIndex),
		2515	],
		2516	};
		2517	return {
		2518	draftsByThreadKey: {
		2519	...state.draftsByThreadKey,
		2520	[threadKey]: nextDraft,
2003	},	2521	},
2004	},	2522	};
2005	};	2523	});
2006	});	2524	return inserted;
2007	},	2525	},
2008	removeTerminalContext: (threadId, contextId) => {	2526	addTerminalContext: (threadRef, context) => {
2009	if (threadId.length === 0 \|\| contextId.length === 0) {	2527	const threadKey = resolveComposerDraftKey(get(), threadRef);
2010	return;	2528	const threadId = resolveComposerThreadId(get(), threadRef);
2011	}	2529	if (!threadKey \|\| !threadId) {
2012	set((state) => {	2530	return;
2013	const current = state.draftsByThreadId[threadId];
2014	if (!current) {
2015	return state;
2016	}
2017	const nextDraft: ComposerThreadDraftState = {
2018	...current,
2019	terminalContexts: current.terminalContexts.filter(
2020	(context) => context.id !== contextId,
2021	),
2022	};
2023	const nextDraftsByThreadId = { ...state.draftsByThreadId };
2024	if (shouldRemoveDraft(nextDraft)) {
2025	delete nextDraftsByThreadId[threadId];
2026	} else {
2027	nextDraftsByThreadId[threadId] = nextDraft;
2028	}
2029	return { draftsByThreadId: nextDraftsByThreadId };
2030	});
2031	},
2032	clearTerminalContexts: (threadId) => {
2033	if (threadId.length === 0) {
2034	return;
2035	}
2036	set((state) => {
2037	const current = state.draftsByThreadId[threadId];
2038	if (!current \|\| current.terminalContexts.length === 0) {
2039	return state;
2040	}
2041	const nextDraft: ComposerThreadDraftState = {
2042	...current,
2043	terminalContexts: [],
2044	};
2045	const nextDraftsByThreadId = { ...state.draftsByThreadId };
2046	if (shouldRemoveDraft(nextDraft)) {
2047	delete nextDraftsByThreadId[threadId];
2048	} else {
2049	nextDraftsByThreadId[threadId] = nextDraft;
2050	}	2531	}
2051	return { draftsByThreadId: nextDraftsByThreadId };	2532	get().addTerminalContexts(
2052	});	2533	typeof threadRef === "string" ? DraftId.makeUnsafe(threadKey) : threadRef,
2053	},	2534	[context],
2054	clearPersistedAttachments: (threadId) => {	2535	);
2055	if (threadId.length === 0) {	2536	},
2056	return;	2537	addTerminalContexts: (threadRef, contexts) => {
2057	}	2538	const threadKey = resolveComposerDraftKey(get(), threadRef);
2058	set((state) => {	2539	const threadId = resolveComposerThreadId(get(), threadRef);
2059	const current = state.draftsByThreadId[threadId];	2540	if (!threadKey \|\| !threadId \|\| contexts.length === 0) {
2060	if (!current) {	2541	return;
2061	return state;
2062	}	2542	}
2063	const nextDraft: ComposerThreadDraftState = {	2543	set((state) => {
2064	...current,	2544	const existing = state.draftsByThreadKey[threadKey] ?? createEmptyThreadDraft();
2065	persistedAttachments: [],	2545	const acceptedContexts = normalizeTerminalContextsForThread(threadId, [
2066	nonPersistedImageIds: [],	2546	...existing.terminalContexts,
2067	};	2547	...contexts,
2068	const nextDraftsByThreadId = { ...state.draftsByThreadId };	2548	]).slice(existing.terminalContexts.length);
2069	if (shouldRemoveDraft(nextDraft)) {	2549	if (acceptedContexts.length === 0) {
2070	delete nextDraftsByThreadId[threadId];	2550	return state;
2071	} else {	2551	}
2072	nextDraftsByThreadId[threadId] = nextDraft;	2552	return {
		2553	draftsByThreadKey: {
		2554	...state.draftsByThreadKey,
		2555	[threadKey]: {
		2556	...existing,
		2557	prompt: ensureInlineTerminalContextPlaceholders(
		2558	existing.prompt,
		2559	existing.terminalContexts.length + acceptedContexts.length,
		2560	),
		2561	terminalContexts: [...existing.terminalContexts, ...acceptedContexts],
		2562	},
		2563	},
		2564	};
		2565	});
		2566	},
		2567	removeTerminalContext: (threadRef, contextId) => {
		2568	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2569	if (threadKey.length === 0 \|\| contextId.length === 0) {
		2570	return;
2073	}	2571	}
2074	return { draftsByThreadId: nextDraftsByThreadId };	2572	set((state) => {
2075	});	2573	const current = state.draftsByThreadKey[threadKey];
2076	},	2574	if (!current) {
2077	syncPersistedAttachments: (threadId, attachments) => {	2575	return state;
2078	if (threadId.length === 0) {	2576	}
2079	return;	2577	const nextDraft: ComposerThreadDraftState = {
2080	}	2578	...current,
2081	const attachmentIdSet = new Set(attachments.map((attachment) => attachment.id));	2579	terminalContexts: current.terminalContexts.filter(
2082	set((state) => {	2580	(context) => context.id !== contextId,
2083	const current = state.draftsByThreadId[threadId];	2581	),
2084	if (!current) {	2582	};
2085	return state;	2583	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		2584	if (shouldRemoveDraft(nextDraft)) {
		2585	delete nextDraftsByThreadKey[threadKey];
		2586	} else {
		2587	nextDraftsByThreadKey[threadKey] = nextDraft;
		2588	}
		2589	return { draftsByThreadKey: nextDraftsByThreadKey };
		2590	});
		2591	},
		2592	clearTerminalContexts: (threadRef) => {
		2593	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2594	if (threadKey.length === 0) {
		2595	return;
2086	}	2596	}
2087	const nextDraft: ComposerThreadDraftState = {	2597	set((state) => {
2088	...current,	2598	const current = state.draftsByThreadKey[threadKey];
2089	// Stage attempted attachments so persist middleware can try writing them.	2599	if (!current \|\| current.terminalContexts.length === 0) {
2090	persistedAttachments: attachments,	2600	return state;
2091	nonPersistedImageIds: current.nonPersistedImageIds.filter(	2601	}
2092	(id) => !attachmentIdSet.has(id),	2602	const nextDraft: ComposerThreadDraftState = {
2093	),	2603	...current,
2094	};	2604	terminalContexts: [],
2095	const nextDraftsByThreadId = { ...state.draftsByThreadId };	2605	};
2096	if (shouldRemoveDraft(nextDraft)) {	2606	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
2097	delete nextDraftsByThreadId[threadId];	2607	if (shouldRemoveDraft(nextDraft)) {
2098	} else {	2608	delete nextDraftsByThreadKey[threadKey];
2099	nextDraftsByThreadId[threadId] = nextDraft;	2609	} else {
		2610	nextDraftsByThreadKey[threadKey] = nextDraft;
		2611	}
		2612	return { draftsByThreadKey: nextDraftsByThreadKey };
		2613	});
		2614	},
		2615	clearPersistedAttachments: (threadRef) => {
		2616	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2617	if (threadKey.length === 0) {
		2618	return;
2100	}	2619	}
2101	return { draftsByThreadId: nextDraftsByThreadId };	2620	set((state) => {
2102	});	2621	const current = state.draftsByThreadKey[threadKey];
2103	Promise.resolve().then(() => {	2622	if (!current) {
2104	verifyPersistedAttachments(threadId, attachments, set);	2623	return state;
2105	});	2624	}
2106	},	2625	const nextDraft: ComposerThreadDraftState = {
2107	clearComposerContent: (threadId) => {	2626	...current,
2108	if (threadId.length === 0) {	2627	persistedAttachments: [],
2109	return;	2628	nonPersistedImageIds: [],
2110	}	2629	};
2111	set((state) => {	2630	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
2112	const current = state.draftsByThreadId[threadId];	2631	if (shouldRemoveDraft(nextDraft)) {
2113	if (!current) {	2632	delete nextDraftsByThreadKey[threadKey];
2114	return state;	2633	} else {
		2634	nextDraftsByThreadKey[threadKey] = nextDraft;
		2635	}
		2636	return { draftsByThreadKey: nextDraftsByThreadKey };
		2637	});
		2638	},
		2639	syncPersistedAttachments: (threadRef, attachments) => {
		2640	const threadKey = resolveComposerDraftKey(get(), threadRef);
		2641	if (!threadKey) {
		2642	return;
2115	}	2643	}
2116	const nextDraft: ComposerThreadDraftState = {	2644	const attachmentIdSet = new Set(attachments.map((attachment) => attachment.id));
2117	...current,	2645	set((state) => {
2118	prompt: "",	2646	const current = state.draftsByThreadKey[threadKey];
2119	images: [],	2647	if (!current) {
2120	nonPersistedImageIds: [],	2648	return state;
2121	persistedAttachments: [],	2649	}
2122	terminalContexts: [],	2650	const nextDraft: ComposerThreadDraftState = {
2123	};	2651	...current,
2124	const nextDraftsByThreadId = { ...state.draftsByThreadId };	2652	// Stage attempted attachments so persist middleware can try writing them.
2125	if (shouldRemoveDraft(nextDraft)) {	2653	persistedAttachments: attachments,
2126	delete nextDraftsByThreadId[threadId];	2654	nonPersistedImageIds: current.nonPersistedImageIds.filter(
2127	} else {	2655	(id) => !attachmentIdSet.has(id),
2128	nextDraftsByThreadId[threadId] = nextDraft;	2656	),
		2657	};
		2658	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		2659	if (shouldRemoveDraft(nextDraft)) {
		2660	delete nextDraftsByThreadKey[threadKey];
		2661	} else {
		2662	nextDraftsByThreadKey[threadKey] = nextDraft;
		2663	}
		2664	return { draftsByThreadKey: nextDraftsByThreadKey };
		2665	});
		2666	Promise.resolve().then(() => {
		2667	verifyPersistedAttachments(threadKey, attachments, set);
		2668	});
		2669	},
		2670	clearComposerContent: (threadRef) => {
		2671	const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";
		2672	if (threadKey.length === 0) {
		2673	return;
2129	}	2674	}
2130	return { draftsByThreadId: nextDraftsByThreadId };	2675	set((state) => {
2131	});	2676	const current = state.draftsByThreadKey[threadKey];
2132	},	2677	if (!current) {
2133	}),	2678	return state;
		2679	}
		2680	const nextDraft: ComposerThreadDraftState = {
		2681	...current,
		2682	prompt: "",
		2683	images: [],
		2684	nonPersistedImageIds: [],
		2685	persistedAttachments: [],
		2686	terminalContexts: [],
		2687	};
		2688	const nextDraftsByThreadKey = { ...state.draftsByThreadKey };
		2689	if (shouldRemoveDraft(nextDraft)) {
		2690	delete nextDraftsByThreadKey[threadKey];
		2691	} else {
		2692	nextDraftsByThreadKey[threadKey] = nextDraft;
		2693	}
		2694	return { draftsByThreadKey: nextDraftsByThreadKey };
		2695	});
		2696	},
		2697	};
		2698	},
2134	{	2699	{
2135	name: COMPOSER_DRAFT_STORAGE_KEY,	2700	name: COMPOSER_DRAFT_STORAGE_KEY,
2136	version: COMPOSER_DRAFT_STORAGE_VERSION,	2701	version: COMPOSER_DRAFT_STORAGE_VERSION,
@@ -2140,17 +2705,23 @@ export const useComposerDraftStore = create<ComposerDraftStoreState>()( · 3 unmodified lines
2140	merge: (persistedState, currentState) => {	2705	merge: (persistedState, currentState) => {
2141	const normalizedPersisted =	2706	const normalizedPersisted =
2142	normalizeCurrentPersistedComposerDraftStoreState(persistedState);	2707	normalizeCurrentPersistedComposerDraftStoreState(persistedState);
2143	const draftsByThreadId = Object.fromEntries(	2708	const draftsByThreadKey = Object.fromEntries(
2144	Object.entries(normalizedPersisted.draftsByThreadId).map(([threadId, draft]) => [	2709	Object.entries(normalizedPersisted.draftsByThreadKey).map(([threadKey, draft]) => [
2145	threadId,	2710	threadKey,
2146	toHydratedThreadDraft(draft),	2711	toHydratedThreadDraft(draft),
2147	]),	2712	]),
2148	);	2713	);
		2714	const draftThreadsByThreadKey = Object.fromEntries(
		2715	Object.entries(normalizedPersisted.draftThreadsByThreadKey).map(
		2716	([threadKey, draftThread]) => [threadKey, toHydratedDraftThreadState(draftThread)],
		2717	),
		2718	) as Record<string, DraftThreadState>;
2149	return {	2719	return {
2150	...currentState,	2720	...currentState,
2151	draftsByThreadId,	2721	draftsByThreadKey,
2152	draftThreadsByThreadId: normalizedPersisted.draftThreadsByThreadId,	2722	draftThreadsByThreadKey,
2153	projectDraftThreadIdByProjectId: normalizedPersisted.projectDraftThreadIdByProjectId,	2723	logicalProjectDraftThreadKeyByLogicalProjectKey:
		2724	normalizedPersisted.logicalProjectDraftThreadKeyByLogicalProjectKey,
2154	stickyModelSelectionByProvider: normalizedPersisted.stickyModelSelectionByProvider ?? {},	2725	stickyModelSelectionByProvider: normalizedPersisted.stickyModelSelectionByProvider ?? {},
2155	stickyActiveProvider: normalizedPersisted.stickyActiveProvider ?? null,	2726	stickyActiveProvider: normalizedPersisted.stickyActiveProvider ?? null,
2156	};	2727	};
@@ -2159,19 +2730,24 @@ export const useComposerDraftStore = create<ComposerDraftStoreState>()( · 2 unmodified lines
2159	),	2730	),
2160	);	2731	);
2161		2732
2162	export function useComposerThreadDraft(threadId: ThreadId): ComposerThreadDraftState {	2733	export const useComposerDraftStore = composerDraftStore;
2163	return useComposerDraftStore((state) => state.draftsByThreadId[threadId] ?? EMPTY_THREAD_DRAFT);	2734
		2735	export function useComposerThreadDraft(threadRef: ComposerThreadTarget): ComposerThreadDraftState {
		2736	return useComposerDraftStore((state) => {
		2737	return getComposerDraftState(state, threadRef) ?? EMPTY_THREAD_DRAFT;
		2738	});
2164	}	2739	}
2165		2740
2166	export function useEffectiveComposerModelState(input: {	2741	export function useEffectiveComposerModelState(input: {
2167	threadId: ThreadId;	2742	threadRef?: ComposerThreadTarget;
		2743	draftId?: DraftId;
2168	providers: ReadonlyArray<ServerProvider>;	2744	providers: ReadonlyArray<ServerProvider>;
2169	selectedProvider: ProviderKind;	2745	selectedProvider: ProviderKind;
2170	threadModelSelection: ModelSelection \| null \| undefined;	2746	threadModelSelection: ModelSelection \| null \| undefined;
2171	projectModelSelection: ModelSelection \| null \| undefined;	2747	projectModelSelection: ModelSelection \| null \| undefined;
2172	settings: UnifiedSettings;	2748	settings: UnifiedSettings;
2173	}): EffectiveComposerModelState {	2749	}): EffectiveComposerModelState {
2174	const draft = useComposerThreadDraft(input.threadId);	2750	const draft = useComposerThreadDraft(input.threadRef ?? input.draftId ?? DraftId.makeUnsafe(""));
2175		2751
2176	return useMemo(	2752	return useMemo(
2177	() =>	2753	() =>
@@ -2195,21 +2771,69 @@ export function useEffectiveComposerModelState(input: { · 17 unmodified lines
2195	}	2771	}
2196		2772
2197	/**	2773	/**
2198	* Clear a draft thread once the server has materialized the same thread id.	2774	* Mark a draft thread as promoting once the server has materialized the same thread id.
2199	*	2775	*
2200	* Use the single-thread helper for live `thread.created` events and the	2776	* Use the single-thread helper for live `thread.created` events and the
2201	* iterable helper for bootstrap/recovery paths that discover multiple server	2777	* iterable helper for bootstrap/recovery paths that discover multiple server
2202	* threads at once.	2778	* threads at once.
2203	*/	2779	*/
2204	export function clearPromotedDraftThread(threadId: ThreadId): void {	2780	export function markPromotedDraftThread(threadId: ThreadId): void {
2205	if (!useComposerDraftStore.getState().getDraftThread(threadId)) {	2781	const store = useComposerDraftStore.getState();
		2782	const draftThreadTargets: ComposerThreadTarget[] = [];
		2783	for (const [draftId, draftThread] of Object.entries(store.draftThreadsByThreadKey)) {
		2784	if (draftThread.threadId === threadId) {
		2785	draftThreadTargets.push(DraftId.makeUnsafe(draftId));
		2786	}
		2787	}
		2788	if (draftThreadTargets.length === 0) {
2206	return;	2789	return;
2207	}	2790	}
2208	useComposerDraftStore.getState().clearDraftThread(threadId);	2791	for (const draftThreadTarget of draftThreadTargets) {
		2792	store.markDraftThreadPromoting(draftThreadTarget);
		2793	}
		2794	}
		2795
		2796	export function markPromotedDraftThreadByRef(threadRef: ScopedThreadRef): void {
		2797	const draftStore = useComposerDraftStore.getState();
		2798	for (const [draftId, draftThread] of Object.entries(draftStore.draftThreadsByThreadKey)) {
		2799	if (
		2800	draftThread.environmentId === threadRef.environmentId &&
		2801	draftThread.threadId === threadRef.threadId
		2802	) {
		2803	draftStore.markDraftThreadPromoting(DraftId.makeUnsafe(draftId), threadRef);
		2804	}
		2805	}
2209	}	2806	}
2210		2807
2211	export function clearPromotedDraftThreads(serverThreadIds: Iterable<ThreadId>): void {	2808	export function markPromotedDraftThreads(serverThreadIds: Iterable<ThreadId>): void {
2212	for (const threadId of serverThreadIds) {	2809	for (const threadId of serverThreadIds) {
2213	clearPromotedDraftThread(threadId);	2810	markPromotedDraftThread(threadId);
		2811	}
		2812	}
		2813
		2814	export function markPromotedDraftThreadsByRef(serverThreadRefs: Iterable<ScopedThreadRef>): void {
		2815	for (const threadRef of serverThreadRefs) {
		2816	markPromotedDraftThreadByRef(threadRef);
		2817	}
		2818	}
		2819
		2820	export function finalizePromotedDraftThreadByRef(threadRef: ScopedThreadRef): void {
		2821	const draftStore = useComposerDraftStore.getState();
		2822	for (const [draftId, draftThread] of Object.entries(draftStore.draftThreadsByThreadKey)) {
		2823	if (
		2824	draftThread.promotedTo &&
		2825	draftThread.promotedTo.environmentId === threadRef.environmentId &&
		2826	draftThread.promotedTo.threadId === threadRef.threadId
		2827	) {
		2828	draftStore.finalizePromotedDraftThread(DraftId.makeUnsafe(draftId));
		2829	}
		2830	}
		2831	}
		2832
		2833	export function finalizePromotedDraftThreadsByRef(
		2834	serverThreadRefs: Iterable<ScopedThreadRef>,
		2835	): void {
		2836	for (const threadRef of serverThreadRefs) {
		2837	finalizePromotedDraftThreadByRef(threadRef);
2214	}	2838	}
2215	}	2839	}

apps/web/src/editorPreferences.ts+2−2

@@ -1,4 +1,4 @@
1	import { EDITORS, EditorId, NativeApi } from "@t3tools/contracts";	1	import { EDITORS, EditorId, LocalApi } from "@t3tools/contracts";
2	import { getLocalStorageItem, setLocalStorageItem, useLocalStorage } from "./hooks/useLocalStorage";	2	import { getLocalStorageItem, setLocalStorageItem, useLocalStorage } from "./hooks/useLocalStorage";
3	import { useMemo } from "react";	3	import { useMemo } from "react";
4		4
@@ -26,7 +26,7 @@ export function resolveAndPersistPreferredEditor( · 21 unmodified lines
26	return editor ?? null;	26	return editor ?? null;
27	}	27	}
28		28
29	export async function openInPreferredEditor(api: NativeApi, targetPath: string): Promise<EditorId> {	29	export async function openInPreferredEditor(api: LocalApi, targetPath: string): Promise<EditorId> {
30	const { availableEditors } = await api.server.getConfig();	30	const { availableEditors } = await api.server.getConfig();
31	const editor = resolveAndPersistPreferredEditor(availableEditors);	31	const editor = resolveAndPersistPreferredEditor(availableEditors);
32	if (!editor) throw new Error("No available editors found.");	32	if (!editor) throw new Error("No available editors found.");

apps/web/src/environmentApi.ts+67−0

@@ -0,0 +1,67 @@
	1	import type { EnvironmentId, EnvironmentApi } from "@t3tools/contracts";
	2
	3	import { readWsRpcClientEntryForEnvironment, WsRpcClient } from "./wsRpcClient";
	4
	5	export function createEnvironmentApi(rpcClient: WsRpcClient): EnvironmentApi {
	6	return {
	7	terminal: {
	8	open: (input) => rpcClient.terminal.open(input as never),
	9	write: (input) => rpcClient.terminal.write(input as never),
	10	resize: (input) => rpcClient.terminal.resize(input as never),
	11	clear: (input) => rpcClient.terminal.clear(input as never),
	12	restart: (input) => rpcClient.terminal.restart(input as never),
	13	close: (input) => rpcClient.terminal.close(input as never),
	14	onEvent: (callback) => rpcClient.terminal.onEvent(callback),
	15	},
	16	projects: {
	17	searchEntries: rpcClient.projects.searchEntries,
	18	writeFile: rpcClient.projects.writeFile,
	19	},
	20	git: {
	21	pull: rpcClient.git.pull,
	22	refreshStatus: rpcClient.git.refreshStatus,
	23	onStatus: (input, callback, options) => rpcClient.git.onStatus(input, callback, options),
	24	listBranches: rpcClient.git.listBranches,
	25	createWorktree: rpcClient.git.createWorktree,
	26	removeWorktree: rpcClient.git.removeWorktree,
	27	createBranch: rpcClient.git.createBranch,
	28	checkout: rpcClient.git.checkout,
	29	init: rpcClient.git.init,
	30	resolvePullRequest: rpcClient.git.resolvePullRequest,
	31	preparePullRequestThread: rpcClient.git.preparePullRequestThread,
	32	},
	33	orchestration: {
	34	getSnapshot: rpcClient.orchestration.getSnapshot,
	35	dispatchCommand: rpcClient.orchestration.dispatchCommand,
	36	getTurnDiff: rpcClient.orchestration.getTurnDiff,
	37	getFullThreadDiff: rpcClient.orchestration.getFullThreadDiff,
	38	replayEvents: (fromSequenceExclusive) =>
	39	rpcClient.orchestration
	40	.replayEvents({ fromSequenceExclusive })
	41	.then((events) => [...events]),
	42	onDomainEvent: (callback, options) =>
	43	rpcClient.orchestration.onDomainEvent(callback, options),
	44	},
	45	};
	46	}
	47
	48	export function readEnvironmentApi(environmentId: EnvironmentId): EnvironmentApi \| undefined {
	49	if (typeof window === "undefined") {
	50	return undefined;
	51	}
	52
	53	if (!environmentId) {
	54	return undefined;
	55	}
	56
	57	const entry = readWsRpcClientEntryForEnvironment(environmentId);
	58	return entry ? createEnvironmentApi(entry.client) : undefined;
	59	}
	60
	61	export function ensureEnvironmentApi(environmentId: EnvironmentId): EnvironmentApi {
	62	const api = readEnvironmentApi(environmentId);
	63	if (!api) {
	64	throw new Error(`Environment API not found for environment ${environmentId}`);
	65	}
	66	return api;
	67	}

apps/web/src/environmentBootstrap.ts+65−0

@@ -0,0 +1,65 @@
	1	import {
	2	createKnownEnvironmentFromWsUrl,
	3	getKnownEnvironmentBaseUrl,
	4	type KnownEnvironment,
	5	} from "@t3tools/client-runtime";
	6	import type { DesktopEnvironmentBootstrap } from "@t3tools/contracts";
	7
	8	function createKnownEnvironmentFromDesktopBootstrap(
	9	bootstrap: DesktopEnvironmentBootstrap \| null \| undefined,
	10	): KnownEnvironment \| null {
	11	if (!bootstrap?.wsUrl) {
	12	return null;
	13	}
	14
	15	return createKnownEnvironmentFromWsUrl({
	16	id: `desktop:${bootstrap.label}`,
	17	label: bootstrap.label,
	18	source: "desktop-managed",
	19	wsUrl: bootstrap.wsUrl,
	20	});
	21	}
	22
	23	export function getPrimaryKnownEnvironment(): KnownEnvironment \| null {
	24	const desktopEnvironment = createKnownEnvironmentFromDesktopBootstrap(
	25	window.desktopBridge?.getLocalEnvironmentBootstrap(),
	26	);
	27	if (desktopEnvironment) {
	28	return desktopEnvironment;
	29	}
	30
	31	const legacyDesktopWsUrl = window.desktopBridge?.getWsUrl();
	32	if (typeof legacyDesktopWsUrl === "string" && legacyDesktopWsUrl.length > 0) {
	33	return createKnownEnvironmentFromWsUrl({
	34	id: "desktop-legacy",
	35	label: "Local environment",
	36	source: "desktop-managed",
	37	wsUrl: legacyDesktopWsUrl,
	38	});
	39	}
	40
	41	const configuredWsUrl = import.meta.env.VITE_WS_URL;
	42	if (typeof configuredWsUrl === "string" && configuredWsUrl.length > 0) {
	43	return createKnownEnvironmentFromWsUrl({
	44	id: "configured-primary",
	45	label: "Primary environment",
	46	source: "configured",
	47	wsUrl: configuredWsUrl,
	48	});
	49	}
	50
	51	return createKnownEnvironmentFromWsUrl({
	52	id: "window-origin",
	53	label: "Primary environment",
	54	source: "window-origin",
	55	wsUrl: window.location.origin,
	56	});
	57	}
	58
	59	export function resolvePrimaryEnvironmentBootstrapUrl(): string {
	60	const baseUrl = getKnownEnvironmentBaseUrl(getPrimaryKnownEnvironment());
	61	if (!baseUrl) {
	62	throw new Error("Unable to resolve a known environment bootstrap URL.");
	63	}
	64	return baseUrl;
	65	}

apps/web/src/hooks/useHandleNewThread.ts+81−42

-import { DEFAULT_RUNTIME_MODE, type ProjectId, ThreadId } from "@t3tools/contracts";
+import { scopedProjectKey, scopeProjectRef } from "@t3tools/client-runtime";
-import { useNavigate, useParams } from "@tanstack/react-router";
+import { DEFAULT_RUNTIME_MODE, type ScopedProjectRef } from "@t3tools/contracts";
+import { useParams, useRouter } from "@tanstack/react-router";
 import { useCallback, useMemo } from "react";
 import { useShallow } from "zustand/react/shallow";
 import {
   type DraftThreadState,
   useComposerDraftStore,
 } from "../composerDraftStore";
-import { newThreadId } from "../lib/utils";
+import { newDraftId, newThreadId } from "../lib/utils";
 import { orderItemsByPreferredIds } from "../components/Sidebar.logic";
-import { useStore } from "../store";
+import { deriveLogicalProjectKey } from "../logicalProject";
-import { createThreadSelector } from "../storeSelectors";
+import { selectProjectsAcrossEnvironments, useStore } from "../store";
+import { createThreadSelectorByRef } from "../storeSelectors";
+import { resolveThreadRouteTarget } from "../threadRoutes";
 import { useUiStateStore } from "../uiStateStore";
 export function useHandleNewThread() {
-  const projectIds = useStore(useShallow((store) => store.projectIds));
+  const projects = useStore(useShallow((store) => selectProjectsAcrossEnvironments(store)));
   const projectOrder = useUiStateStore((store) => store.projectOrder);
-  const navigate = useNavigate();
+  const router = useRouter();
-  const routeThreadId = useParams({
+  const routeTarget = useParams({
     strict: false,
-    select: (params) => (params.threadId ? ThreadId.makeUnsafe(params.threadId) : null),
+    select: (params) => resolveThreadRouteTarget(params),
   });
+  const routeThreadRef = routeTarget?.kind === "server" ? routeTarget.threadRef : null;
   const activeThread = useStore(
-    useMemo(() => createThreadSelector(routeThreadId), [routeThreadId]),
+    useMemo(() => createThreadSelectorByRef(routeThreadRef), [routeThreadRef]),
   );
-  const activeDraftThread = useComposerDraftStore((store) =>
+  const getDraftThread = useComposerDraftStore((store) => store.getDraftThread);
-    routeThreadId ? (store.draftThreadsByThreadId[routeThreadId] ?? null) : null,
+  const activeDraftThread = useComposerDraftStore(() =>
+    routeTarget
+      ? routeTarget.kind === "server"
+        ? getDraftThread(routeTarget.threadRef)
+        : useComposerDraftStore.getState().getDraftSession(routeTarget.draftId)
+      : null,
   );
   const orderedProjects = useMemo(() => {
     return orderItemsByPreferredIds({
-      items: projectIds,
+      items: projects,
       preferredIds: projectOrder,
-      getId: (projectId) => projectId,
+      getId: (project) => scopedProjectKey(scopeProjectRef(project.environmentId, project.id)),
     });
-  }, [projectIds, projectOrder]);
+  }, [projectOrder, projects]);
+  const getCurrentRouteTarget = useCallback(() => {
+    const currentRouteParams = router.state.matches[router.state.matches.length - 1]?.params ?? {};
+    return resolveThreadRouteTarget(currentRouteParams);
+  }, [router]);
   const handleNewThread = useCallback(
     (
-      projectId: ProjectId,
+      projectRef: ScopedProjectRef,
       options?: {
         branch?: string | null;
         worktreePath?: string | null;
       },
     ): Promise<void> => {
       const {
-        clearProjectDraftThreadId,
+        getDraftSessionByLogicalProjectKey,
+        getDraftSession,
         getDraftThread,
-        getDraftThreadByProjectId,
         applyStickyState,
         setDraftThreadContext,
-        setProjectDraftThreadId,
+        setLogicalProjectDraftThreadId,
       } = useComposerDraftStore.getState();
+      const currentRouteTarget = getCurrentRouteTarget();
+      const project = projects.find(
+        (candidate) =>
+          candidate.id === projectRef.projectId &&
+          candidate.environmentId === projectRef.environmentId,
+      );
+      const logicalProjectKey = project
+        ? deriveLogicalProjectKey(project)
+        : scopedProjectKey(projectRef);
       const hasBranchOption = options?.branch !== undefined;
       const hasWorktreePathOption = options?.worktreePath !== undefined;
       const hasEnvModeOption = options?.envMode !== undefined;
-      const storedDraftThread = getDraftThreadByProjectId(projectId);
+      const storedDraftThread = getDraftSessionByLogicalProjectKey(logicalProjectKey);
-      const latestActiveDraftThread: DraftThreadState | null = routeThreadId
+      const latestActiveDraftThread: DraftThreadState | null = currentRouteTarget
-        ? getDraftThread(routeThreadId)
+        ? currentRouteTarget.kind === "server"
+          ? getDraftThread(currentRouteTarget.threadRef)
+          : getDraftSession(currentRouteTarget.draftId)
         : null;
       if (storedDraftThread) {
         return (async () => {
           if (hasBranchOption || hasWorktreePathOption || hasEnvModeOption) {
-            setDraftThreadContext(storedDraftThread.threadId, {
+            setDraftThreadContext(storedDraftThread.draftId, {
               ...(hasBranchOption ? { branch: options?.branch ?? null } : {}),
               ...(hasWorktreePathOption ? { worktreePath: options?.worktreePath ?? null } : {}),
               ...(hasEnvModeOption ? { envMode: options?.envMode } : {}),
             });
           }
-          setProjectDraftThreadId(projectId, storedDraftThread.threadId);
+          setLogicalProjectDraftThreadId(logicalProjectKey, projectRef, storedDraftThread.draftId, {
-          if (routeThreadId === storedDraftThread.threadId) {
+            threadId: storedDraftThread.threadId,
+          });
+          if (
+            currentRouteTarget?.kind === "draft" &&
+            currentRouteTarget.draftId === storedDraftThread.draftId
+          ) {
             return;
           }
-          await navigate({
+          await router.navigate({
-            to: "/$threadId",
+            to: "/draft/$draftId",
-            params: { threadId: storedDraftThread.threadId },
+            params: { draftId: storedDraftThread.draftId },
           });
         })();
       }
-      clearProjectDraftThreadId(projectId);
       if (
         latestActiveDraftThread &&
-        routeThreadId &&
+        currentRouteTarget?.kind === "draft" &&
-        latestActiveDraftThread.projectId === projectId
+        latestActiveDraftThread.logicalProjectKey === logicalProjectKey
       ) {
         if (hasBranchOption || hasWorktreePathOption || hasEnvModeOption) {
-          setDraftThreadContext(routeThreadId, {
+          setDraftThreadContext(currentRouteTarget.draftId, {
             ...(hasBranchOption ? { branch: options?.branch ?? null } : {}),
             ...(hasWorktreePathOption ? { worktreePath: options?.worktreePath ?? null } : {}),
             ...(hasEnvModeOption ? { envMode: options?.envMode } : {}),
           });
         }
-        setProjectDraftThreadId(projectId, routeThreadId);
+        setLogicalProjectDraftThreadId(logicalProjectKey, projectRef, currentRouteTarget.draftId, {
+          threadId: latestActiveDraftThread.threadId,
+          createdAt: latestActiveDraftThread.createdAt,
+          runtimeMode: latestActiveDraftThread.runtimeMode,
+          interactionMode: latestActiveDraftThread.interactionMode,
+          ...(hasBranchOption ? { branch: options?.branch ?? null } : {}),
+          ...(hasWorktreePathOption ? { worktreePath: options?.worktreePath ?? null } : {}),
+          ...(hasEnvModeOption ? { envMode: options?.envMode } : {}),
+        });
         return Promise.resolve();
       }
+      const draftId = newDraftId();
       const threadId = newThreadId();
       const createdAt = new Date().toISOString();
       return (async () => {
-        setProjectDraftThreadId(projectId, threadId, {
+        setLogicalProjectDraftThreadId(logicalProjectKey, projectRef, draftId, {
+          threadId,
           createdAt,
           branch: options?.branch ?? null,
           worktreePath: options?.worktreePath ?? null,
           envMode: options?.envMode ?? "local",
           runtimeMode: DEFAULT_RUNTIME_MODE,
         });
-        applyStickyState(threadId);
+        applyStickyState(draftId);
-        await navigate({
+        await router.navigate({
-          to: "/$threadId",
+          to: "/draft/$draftId",
-          params: { threadId },
+          params: { draftId },
         });
       })();
     },
-    [navigate, routeThreadId],
+    [getCurrentRouteTarget, router, projects],
   );
   return {
     activeDraftThread,
     activeThread,
-    defaultProjectId: orderedProjects[0] ?? null,
+    defaultProjectRef: orderedProjects[0]
+      ? scopeProjectRef(orderedProjects[0].environmentId, orderedProjects[0].id)
+      : null,
     handleNewThread,
-    routeThreadId,
+    routeThreadRef,
   };
 }

apps/web/src/hooks/useSettings.ts+4−6

   TimestampFormat,
   UnifiedSettings,
 } from "@t3tools/contracts/settings";
-import { ensureNativeApi } from "~/nativeApi";
+import { ensureLocalApi } from "~/localApi";
 import { useLocalStorage } from "./useLocalStorage";
 import { normalizeCustomModelSlugs } from "~/modelSelection";
 import { Predicate, Schema, Struct } from "effect";
  * only re-render when the slice they care about changes.
  */
-export function useSettings<T extends UnifiedSettings = UnifiedSettings>(
+export function useSettings<T = UnifiedSettings>(selector?: (s: UnifiedSettings) => T): T {
-  selector?: (s: UnifiedSettings) => T,
-): T {
   const serverSettings = useServerSettings();
   const [clientSettings] = useLocalStorage(
     CLIENT_SETTINGS_STORAGE_KEY,
           applySettingsUpdated(deepMerge(currentServerConfig.settings, serverPatch));
         }
         // Fire-and-forget RPC — push will reconcile on success
-        void ensureNativeApi().server.updateSettings(serverPatch);
+        void ensureLocalApi().server.updateSettings(serverPatch);
       }
       if (Object.keys(clientPatch).length > 0) {
     // Migrate server-relevant keys via RPC
     const serverPatch = buildLegacyServerSettingsMigrationPatch(old);
     if (Object.keys(serverPatch).length > 0) {
-      const api = ensureNativeApi();
+      const api = ensureLocalApi();
       void api.server.updateSettings(serverPatch);
     }

apps/web/src/hooks/useThreadActions.ts+128−64

@@ -1,42 +1,63 @@
1	import { ThreadId } from "@t3tools/contracts";	1	import { parseScopedThreadKey, scopeProjectRef, scopeThreadRef } from "@t3tools/client-runtime";
2	import { useMutation, useQueryClient } from "@tanstack/react-query";	2	import { type ScopedThreadRef, ThreadId } from "@t3tools/contracts";
3	import { useNavigate, useParams } from "@tanstack/react-router";	3	import { useQueryClient } from "@tanstack/react-query";
		4	import { useRouter } from "@tanstack/react-router";
4	import { useCallback } from "react";	5	import { useCallback } from "react";
5		6
6	import { getFallbackThreadIdAfterDelete } from "../components/Sidebar.logic";	7	import { getFallbackThreadIdAfterDelete } from "../components/Sidebar.logic";
7	import { useComposerDraftStore } from "../composerDraftStore";	8	import { useComposerDraftStore } from "../composerDraftStore";
8	import { useHandleNewThread } from "./useHandleNewThread";	9	import { useHandleNewThread } from "./useHandleNewThread";
9	import { gitRemoveWorktreeMutationOptions } from "../lib/gitReactQuery";	10	import { ensureEnvironmentApi, readEnvironmentApi } from "../environmentApi";
		11	import { invalidateGitQueries } from "../lib/gitReactQuery";
10	import { newCommandId } from "../lib/utils";	12	import { newCommandId } from "../lib/utils";
11	import { readNativeApi } from "../nativeApi";	13	import { readLocalApi } from "../localApi";
12	import { selectProjectById, selectThreadById, selectThreads, useStore } from "../store";	14	import {
		15	selectProjectByRef,
		16	selectThreadByRef,
		17	selectThreadsForEnvironment,
		18	useStore,
		19	} from "../store";
13	import { useTerminalStateStore } from "../terminalStateStore";	20	import { useTerminalStateStore } from "../terminalStateStore";
		21	import { buildThreadRouteParams, resolveThreadRouteRef } from "../threadRoutes";
14	import { formatWorktreePathForDisplay, getOrphanedWorktreePathForThread } from "../worktreeCleanup";	22	import { formatWorktreePathForDisplay, getOrphanedWorktreePathForThread } from "../worktreeCleanup";
15	import { toastManager } from "../components/ui/toast";	23	import { toastManager } from "../components/ui/toast";
16	import { useSettings } from "./useSettings";	24	import { useSettings } from "./useSettings";
17		25
18	export function useThreadActions() {	26	export function useThreadActions() {
19	const appSettings = useSettings();	27	const sidebarThreadSortOrder = useSettings((settings) => settings.sidebarThreadSortOrder);
		28	const confirmThreadDelete = useSettings((settings) => settings.confirmThreadDelete);
20	const clearComposerDraftForThread = useComposerDraftStore((store) => store.clearDraftThread);	29	const clearComposerDraftForThread = useComposerDraftStore((store) => store.clearDraftThread);
21	const clearProjectDraftThreadById = useComposerDraftStore(	30	const clearProjectDraftThreadById = useComposerDraftStore(
22	(store) => store.clearProjectDraftThreadById,	31	(store) => store.clearProjectDraftThreadById,
23	);	32	);
24	const clearTerminalState = useTerminalStateStore((state) => state.clearTerminalState);	33	const clearTerminalState = useTerminalStateStore((state) => state.clearTerminalState);
25	const routeThreadId = useParams({	34	const router = useRouter();
26	strict: false,
27	select: (params) => (params.threadId ? ThreadId.makeUnsafe(params.threadId) : null),
28	});
29	const navigate = useNavigate();
30	const { handleNewThread } = useHandleNewThread();	35	const { handleNewThread } = useHandleNewThread();
31	const queryClient = useQueryClient();	36	const queryClient = useQueryClient();
32	const removeWorktreeMutation = useMutation(gitRemoveWorktreeMutationOptions({ queryClient }));	37
		38	const resolveThreadTarget = useCallback((target: ScopedThreadRef) => {
		39	const state = useStore.getState();
		40	const thread = selectThreadByRef(state, target);
		41	if (!thread) {
		42	return null;
		43	}
		44	return {
		45	thread,
		46	threadRef: target,
		47	};
		48	}, []);
		49	const getCurrentRouteThreadRef = useCallback(() => {
		50	const currentRouteParams = router.state.matches[router.state.matches.length - 1]?.params ?? {};
		51	return resolveThreadRouteRef(currentRouteParams);
		52	}, [router]);
33		53
34	const archiveThread = useCallback(	54	const archiveThread = useCallback(
35	async (threadId: ThreadId) => {	55	async (target: ScopedThreadRef) => {
36	const api = readNativeApi();	56	const api = readEnvironmentApi(target.environmentId);
37	if (!api) return;	57	if (!api) return;
38	const thread = selectThreadById(threadId)(useStore.getState());	58	const resolved = resolveThreadTarget(target);
39	if (!thread) return;	59	if (!resolved) return;
		60	const { thread, threadRef } = resolved;
40	if (thread.session?.status === "running" && thread.session.activeTurnId != null) {	61	if (thread.session?.status === "running" && thread.session.activeTurnId != null) {
41	throw new Error("Cannot archive a running thread.");	62	throw new Error("Cannot archive a running thread.");
42	}	63	}
@@ -44,48 +65,69 @@ export function useThreadActions() { · 1 unmodified line
44	await api.orchestration.dispatchCommand({	65	await api.orchestration.dispatchCommand({
45	type: "thread.archive",	66	type: "thread.archive",
46	commandId: newCommandId(),	67	commandId: newCommandId(),
47	threadId,	68	threadId: threadRef.threadId,
48	});	69	});
		70	const currentRouteThreadRef = getCurrentRouteThreadRef();
49		71
50	if (routeThreadId === threadId) {	72	if (
51	await handleNewThread(thread.projectId);	73	currentRouteThreadRef?.threadId === threadRef.threadId &&
		74	currentRouteThreadRef.environmentId === threadRef.environmentId
		75	) {
		76	await handleNewThread(scopeProjectRef(thread.environmentId, thread.projectId));
52	}	77	}
53	},	78	},
54	[handleNewThread, routeThreadId],	79	[getCurrentRouteThreadRef, handleNewThread, resolveThreadTarget],
55	);	80	);
56		81
57	const unarchiveThread = useCallback(async (threadId: ThreadId) => {	82	const unarchiveThread = useCallback(async (target: ScopedThreadRef) => {
58	const api = readNativeApi();	83	const api = readEnvironmentApi(target.environmentId);
59	if (!api) return;	84	if (!api) return;
60	await api.orchestration.dispatchCommand({	85	await api.orchestration.dispatchCommand({
61	type: "thread.unarchive",	86	type: "thread.unarchive",
62	commandId: newCommandId(),	87	commandId: newCommandId(),
63	threadId,	88	threadId: target.threadId,
64	});	89	});
65	}, []);	90	}, []);
66		91
67	const deleteThread = useCallback(	92	const deleteThread = useCallback(
68	async (threadId: ThreadId, opts: { deletedThreadIds?: ReadonlySet<ThreadId> } = {}) => {	93	async (target: ScopedThreadRef, opts: { deletedThreadKeys?: ReadonlySet<string> } = {}) => {
69	const api = readNativeApi();	94	const api = readEnvironmentApi(target.environmentId);
70	if (!api) return;	95	if (!api) return;
		96	const resolved = resolveThreadTarget(target);
		97	if (!resolved) return;
		98	const { thread, threadRef } = resolved;
71	const state = useStore.getState();	99	const state = useStore.getState();
72	const threads = selectThreads(state);	100	const threads = selectThreadsForEnvironment(state, threadRef.environmentId);
73	const thread = selectThreadById(threadId)(state);	101	const threadProject = selectProjectByRef(state, {
74	if (!thread) return;	102	environmentId: threadRef.environmentId,
75	const threadProject = selectProjectById(thread.projectId)(state);	103	projectId: thread.projectId,
76	const deletedIds = opts.deletedThreadIds;	104	});
		105	const deletedIds =
		106	opts.deletedThreadKeys && opts.deletedThreadKeys.size > 0
		107	? new Set<ThreadId>(
		108	[...opts.deletedThreadKeys].flatMap((threadKey) => {
		109	const ref = parseScopedThreadKey(threadKey);
		110	return ref && ref.environmentId === threadRef.environmentId ? [ref.threadId] : [];
		111	}),
		112	)
		113	: undefined;
77	const survivingThreads =	114	const survivingThreads =
78	deletedIds && deletedIds.size > 0	115	deletedIds && deletedIds.size > 0
79	? threads.filter((entry) => entry.id === threadId \|\| !deletedIds.has(entry.id))	116	? threads.filter((entry) => entry.id === threadRef.threadId \|\| !deletedIds.has(entry.id))
80	: threads;	117	: threads;
81	const orphanedWorktreePath = getOrphanedWorktreePathForThread(survivingThreads, threadId);	118	const orphanedWorktreePath = getOrphanedWorktreePathForThread(
		119	survivingThreads,
		120	threadRef.threadId,
		121	);
82	const displayWorktreePath = orphanedWorktreePath	122	const displayWorktreePath = orphanedWorktreePath
83	? formatWorktreePathForDisplay(orphanedWorktreePath)	123	? formatWorktreePathForDisplay(orphanedWorktreePath)
84	: null;	124	: null;
85	const canDeleteWorktree = orphanedWorktreePath !== null && threadProject !== undefined;	125	const canDeleteWorktree = orphanedWorktreePath !== null && threadProject !== undefined;
		126	const localApi = readLocalApi();
86	const shouldDeleteWorktree =	127	const shouldDeleteWorktree =
87	canDeleteWorktree &&	128	canDeleteWorktree &&
88	(await api.dialogs.confirm(	129	localApi &&
		130	(await localApi.dialogs.confirm(
89	[	131	[
90	"This thread is the only one linked to this worktree:",	132	"This thread is the only one linked to this worktree:",
91	displayWorktreePath ?? orphanedWorktreePath,	133	displayWorktreePath ?? orphanedWorktreePath,
@@ -99,44 +141,60 @@ export function useThreadActions() { · 7 unmodified lines
99	.dispatchCommand({	141	.dispatchCommand({
100	type: "thread.session.stop",	142	type: "thread.session.stop",
101	commandId: newCommandId(),	143	commandId: newCommandId(),
102	threadId,	144	threadId: threadRef.threadId,
103	createdAt: new Date().toISOString(),	145	createdAt: new Date().toISOString(),
104	})	146	})
105	.catch(() => undefined);	147	.catch(() => undefined);
106	}	148	}
107		149
108	try {	150	try {
109	await api.terminal.close({ threadId, deleteHistory: true });	151	await api.terminal.close({ threadId: threadRef.threadId, deleteHistory: true });
110	} catch {	152	} catch {
111	// Terminal may already be closed.	153	// Terminal may already be closed.
112	}	154	}
113		155
114	const deletedThreadIds = opts.deletedThreadIds ?? new Set<ThreadId>();	156	const deletedThreadIds = deletedIds ?? new Set<ThreadId>();
115	const shouldNavigateToFallback = routeThreadId === threadId;	157	const currentRouteThreadRef = getCurrentRouteThreadRef();
		158	const shouldNavigateToFallback =
		159	currentRouteThreadRef?.threadId === threadRef.threadId &&
		160	currentRouteThreadRef.environmentId === threadRef.environmentId;
116	const fallbackThreadId = getFallbackThreadIdAfterDelete({	161	const fallbackThreadId = getFallbackThreadIdAfterDelete({
117	threads,	162	threads,
118	deletedThreadId: threadId,	163	deletedThreadId: threadRef.threadId,
119	deletedThreadIds,	164	deletedThreadIds,
120	sortOrder: appSettings.sidebarThreadSortOrder,	165	sortOrder: sidebarThreadSortOrder,
121	});	166	});
122	await api.orchestration.dispatchCommand({	167	await api.orchestration.dispatchCommand({
123	type: "thread.delete",	168	type: "thread.delete",
124	commandId: newCommandId(),	169	commandId: newCommandId(),
125	threadId,	170	threadId: threadRef.threadId,
126	});	171	});
127	clearComposerDraftForThread(threadId);	172	clearComposerDraftForThread(threadRef);
128	clearProjectDraftThreadById(thread.projectId, thread.id);	173	clearProjectDraftThreadById(
129	clearTerminalState(threadId);	174	scopeProjectRef(threadRef.environmentId, thread.projectId),
		175	threadRef,
		176	);
		177	clearTerminalState(threadRef);
130		178
131	if (shouldNavigateToFallback) {	179	if (shouldNavigateToFallback) {
132	if (fallbackThreadId) {	180	if (fallbackThreadId) {
133	await navigate({	181	const fallbackThread = selectThreadByRef(
134	to: "/$threadId",	182	useStore.getState(),
135	params: { threadId: fallbackThreadId },	183	scopeThreadRef(threadRef.environmentId, fallbackThreadId),
136	replace: true,	184	);
137	});	185	if (fallbackThread) {
		186	await router.navigate({
		187	to: "/$environmentId/$threadId",
		188	params: buildThreadRouteParams(
		189	scopeThreadRef(fallbackThread.environmentId, fallbackThread.id),
		190	),
		191	replace: true,
		192	});
		193	} else {
		194	await router.navigate({ to: "/", replace: true });
		195	}
138	} else {	196	} else {
139	await navigate({ to: "/", replace: true });	197	await router.navigate({ to: "/", replace: true });
140	}	198	}
141	}	199	}
142		200
@@ -145,15 +203,18 @@ export function useThreadActions() { · 2 unmodified lines
145	}	203	}
146		204
147	try {	205	try {
148	await removeWorktreeMutation.mutateAsync({	206	await ensureEnvironmentApi(threadRef.environmentId).git.removeWorktree({
149	cwd: threadProject.cwd,	207	cwd: threadProject.cwd,
150	path: orphanedWorktreePath,	208	path: orphanedWorktreePath,
151	force: true,	209	force: true,
152	});	210	});
		211	await invalidateGitQueries(queryClient, {
		212	environmentId: threadRef.environmentId,
		213	});
153	} catch (error) {	214	} catch (error) {
154	const message = error instanceof Error ? error.message : "Unknown error removing worktree.";	215	const message = error instanceof Error ? error.message : "Unknown error removing worktree.";
155	console.error("Failed to remove orphaned worktree after thread deletion", {	216	console.error("Failed to remove orphaned worktree after thread deletion", {
156	threadId,	217	threadId: threadRef.threadId,
157	projectCwd: threadProject.cwd,	218	projectCwd: threadProject.cwd,
158	worktreePath: orphanedWorktreePath,	219	worktreePath: orphanedWorktreePath,
159	error,	220	error,
@@ -169,22 +230,25 @@ export function useThreadActions() { · 9 unmodified lines
169	clearComposerDraftForThread,	230	clearComposerDraftForThread,
170	clearProjectDraftThreadById,	231	clearProjectDraftThreadById,
171	clearTerminalState,	232	clearTerminalState,
172	appSettings.sidebarThreadSortOrder,	233	getCurrentRouteThreadRef,
173	navigate,	234	router,
174	removeWorktreeMutation,	235	queryClient,
175	routeThreadId,	236	resolveThreadTarget,
		237	sidebarThreadSortOrder,
176	],	238	],
177	);	239	);
178		240
179	const confirmAndDeleteThread = useCallback(	241	const confirmAndDeleteThread = useCallback(
180	async (threadId: ThreadId) => {	242	async (target: ScopedThreadRef) => {
181	const api = readNativeApi();	243	const api = readEnvironmentApi(target.environmentId);
182	if (!api) return;	244	if (!api) return;
183	const thread = selectThreadById(threadId)(useStore.getState());	245	const localApi = readLocalApi();
184	if (!thread) return;	246	const resolved = resolveThreadTarget(target);
		247	if (!resolved) return;
		248	const { thread } = resolved;
185		249
186	if (appSettings.confirmThreadDelete) {	250	if (confirmThreadDelete && localApi) {
187	const confirmed = await api.dialogs.confirm(	251	const confirmed = await localApi.dialogs.confirm(
188	[	252	[
189	`Delete thread "${thread.title}"?`,	253	`Delete thread "${thread.title}"?`,
190	"This permanently clears conversation history for this thread.",	254	"This permanently clears conversation history for this thread.",
@@ -195,9 +259,9 @@ export function useThreadActions() { · 4 unmodified lines
195	}	259	}
196	}	260	}
197		261
198	await deleteThread(threadId);	262	await deleteThread(target);
199	},	263	},
200	[appSettings.confirmThreadDelete, deleteThread],	264	[confirmThreadDelete, deleteThread, resolveThreadTarget],
201	);	265	);
202		266
203	return {	267	return {

apps/web/src/lib/gitReactQuery.test.ts+30−13

 import { QueryClient } from "@tanstack/react-query";
 import { describe, expect, it, vi } from "vitest";
-vi.mock("../nativeApi", () => ({
+vi.mock("../environmentApi", () => ({
-  ensureNativeApi: vi.fn(),
+  ensureEnvironmentApi: vi.fn(),
 }));
 vi.mock("../wsRpcClient", () => ({
   getWsRpcClient: vi.fn(),
+  getWsRpcClientForEnvironment: vi.fn(),
 }));
 import type { InfiniteData } from "@tanstack/react-query";
-import type { GitListBranchesResult } from "@t3tools/contracts";
+import { EnvironmentId, type GitListBranchesResult } from "@t3tools/contracts";
 import {
   gitBranchSearchInfiniteQueryOptions,
   pages: [BRANCH_QUERY_RESULT],
   pageParams: [0],
 };
+const ENVIRONMENT_A = EnvironmentId.makeUnsafe("environment-a");
+const ENVIRONMENT_B = EnvironmentId.makeUnsafe("environment-b");
 describe("gitMutationKeys", () => {
   it("scopes stacked action keys by cwd", () => {
-    expect(gitMutationKeys.runStackedAction("/repo/a")).not.toEqual(
+    expect(gitMutationKeys.runStackedAction(ENVIRONMENT_A, "/repo/a")).not.toEqual(
-      gitMutationKeys.runStackedAction("/repo/b"),
+      gitMutationKeys.runStackedAction(ENVIRONMENT_A, "/repo/b"),
     );
   });
   it("scopes pull keys by cwd", () => {
-    expect(gitMutationKeys.pull("/repo/a")).not.toEqual(gitMutationKeys.pull("/repo/b"));
+    expect(gitMutationKeys.pull(ENVIRONMENT_A, "/repo/a")).not.toEqual(
+      gitMutationKeys.pull(ENVIRONMENT_A, "/repo/b"),
+    );
   });
   it("scopes pull request thread preparation keys by cwd", () => {
-    expect(gitMutationKeys.preparePullRequestThread("/repo/a")).not.toEqual(
+    expect(gitMutationKeys.preparePullRequestThread(ENVIRONMENT_A, "/repo/a")).not.toEqual(
-      gitMutationKeys.preparePullRequestThread("/repo/b"),
+      gitMutationKeys.preparePullRequestThread(ENVIRONMENT_A, "/repo/b"),
     );
   });
 });
   it("attaches cwd-scoped mutation key for runStackedAction", () => {
     const options = gitRunStackedActionMutationOptions({
+      environmentId: ENVIRONMENT_A,
       cwd: "/repo/a",
       queryClient,
     });
-    expect(options.mutationKey).toEqual(gitMutationKeys.runStackedAction("/repo/a"));
+    expect(options.mutationKey).toEqual(gitMutationKeys.runStackedAction(ENVIRONMENT_A, "/repo/a"));
   });
   it("attaches cwd-scoped mutation key for pull", () => {
-    const options = gitPullMutationOptions({ cwd: "/repo/a", queryClient });
+    const options = gitPullMutationOptions({
-    expect(options.mutationKey).toEqual(gitMutationKeys.pull("/repo/a"));
+      environmentId: ENVIRONMENT_A,
+      cwd: "/repo/a",
+      queryClient,
+    });
+    expect(options.mutationKey).toEqual(gitMutationKeys.pull(ENVIRONMENT_A, "/repo/a"));
   });
   it("attaches cwd-scoped mutation key for preparePullRequestThread", () => {
     const options = gitPreparePullRequestThreadMutationOptions({
+      environmentId: ENVIRONMENT_A,
       cwd: "/repo/a",
       queryClient,
     });
-    expect(options.mutationKey).toEqual(gitMutationKeys.preparePullRequestThread("/repo/a"));
+    expect(options.mutationKey).toEqual(
+      gitMutationKeys.preparePullRequestThread(ENVIRONMENT_A, "/repo/a"),
+    );
   });
 });
     queryClient.setQueryData(
       gitBranchSearchInfiniteQueryOptions({
+        environmentId: ENVIRONMENT_A,
         cwd: "/repo/a",
         query: "feature",
       }).queryKey,
     );
     queryClient.setQueryData(
       gitBranchSearchInfiniteQueryOptions({
+        environmentId: ENVIRONMENT_B,
         cwd: "/repo/b",
         query: "feature",
       }).queryKey,
       BRANCH_SEARCH_RESULT,
     );
-    await invalidateGitQueries(queryClient, { cwd: "/repo/a" });
+    await invalidateGitQueries(queryClient, { environmentId: ENVIRONMENT_A, cwd: "/repo/a" });
     expect(
       queryClient.getQueryState(
         gitBranchSearchInfiniteQueryOptions({
+          environmentId: ENVIRONMENT_A,
           cwd: "/repo/a",
           query: "feature",
         }).queryKey,
     expect(
       queryClient.getQueryState(
         gitBranchSearchInfiniteQueryOptions({
+          environmentId: ENVIRONMENT_B,
           cwd: "/repo/b",
           query: "feature",
         }).queryKey,

apps/web/src/lib/gitReactQuery.ts+105−53

 import {
+  type EnvironmentId,
   type GitActionProgressEvent,
   type GitStackedAction,
   type ThreadId,
   queryOptions,
   type QueryClient,
 } from "@tanstack/react-query";
-import { ensureNativeApi } from "../nativeApi";
+import { ensureEnvironmentApi } from "../environmentApi";
-import { getWsRpcClient } from "../wsRpcClient";
+import { getWsRpcClientForEnvironment } from "../wsRpcClient";
 const GIT_BRANCHES_STALE_TIME_MS = 15_000;
 const GIT_BRANCHES_REFETCH_INTERVAL_MS = 60_000;
 export const gitQueryKeys = {
   all: ["git"] as const,
-  branches: (cwd: string | null) => ["git", "branches", cwd] as const,
+  branches: (environmentId: EnvironmentId | null, cwd: string | null) =>
-  branchSearch: (cwd: string | null, query: string) =>
+    ["git", "branches", environmentId ?? null, cwd] as const,
-    ["git", "branches", cwd, "search", query] as const,
+  branchSearch: (environmentId: EnvironmentId | null, cwd: string | null, query: string) =>
+    ["git", "branches", environmentId ?? null, cwd, "search", query] as const,
 };
 export const gitMutationKeys = {
-  init: (cwd: string | null) => ["git", "mutation", "init", cwd] as const,
+  init: (environmentId: EnvironmentId | null, cwd: string | null) =>
-  checkout: (cwd: string | null) => ["git", "mutation", "checkout", cwd] as const,
+    ["git", "mutation", "init", environmentId ?? null, cwd] as const,
-  runStackedAction: (cwd: string | null) => ["git", "mutation", "run-stacked-action", cwd] as const,
+  checkout: (environmentId: EnvironmentId | null, cwd: string | null) =>
-  pull: (cwd: string | null) => ["git", "mutation", "pull", cwd] as const,
+    ["git", "mutation", "checkout", environmentId ?? null, cwd] as const,
-  preparePullRequestThread: (cwd: string | null) =>
+  runStackedAction: (environmentId: EnvironmentId | null, cwd: string | null) =>
-    ["git", "mutation", "prepare-pull-request-thread", cwd] as const,
+    ["git", "mutation", "run-stacked-action", environmentId ?? null, cwd] as const,
+  pull: (environmentId: EnvironmentId | null, cwd: string | null) =>
+    ["git", "mutation", "pull", environmentId ?? null, cwd] as const,
+  preparePullRequestThread: (environmentId: EnvironmentId | null, cwd: string | null) =>
+    ["git", "mutation", "prepare-pull-request-thread", environmentId ?? null, cwd] as const,
 };
-export function invalidateGitQueries(queryClient: QueryClient, input?: { cwd?: string | null }) {
+export function invalidateGitQueries(
+  queryClient: QueryClient,
+  input?: { environmentId?: EnvironmentId | null; cwd?: string | null },
+) {
+  const environmentId = input?.environmentId ?? null;
   const cwd = input?.cwd ?? null;
   if (cwd !== null) {
-    return queryClient.invalidateQueries({ queryKey: gitQueryKeys.branches(cwd) });
+    return queryClient.invalidateQueries({ queryKey: gitQueryKeys.branches(environmentId, cwd) });
   }
   return queryClient.invalidateQueries({ queryKey: gitQueryKeys.all });
 }
-function invalidateGitBranchQueries(queryClient: QueryClient, cwd: string | null) {
+function invalidateGitBranchQueries(
+  queryClient: QueryClient,
+  environmentId: EnvironmentId | null,
+  cwd: string | null,
+) {
   if (cwd === null) {
     return Promise.resolve();
   }
-  return queryClient.invalidateQueries({ queryKey: gitQueryKeys.branches(cwd) });
+  return queryClient.invalidateQueries({ queryKey: gitQueryKeys.branches(environmentId, cwd) });
 }
 export function gitBranchSearchInfiniteQueryOptions(input: {
+  environmentId: EnvironmentId | null;
   cwd: string | null;
   query: string;
   enabled?: boolean;
   const normalizedQuery = input.query.trim();
   return infiniteQueryOptions({
-    queryKey: gitQueryKeys.branchSearch(input.cwd, normalizedQuery),
+    queryKey: gitQueryKeys.branchSearch(input.environmentId, input.cwd, normalizedQuery),
     initialPageParam: 0,
     queryFn: async ({ pageParam }) => {
-      const api = ensureNativeApi();
       if (!input.cwd) throw new Error("Git branches are unavailable.");
+      if (!input.environmentId) throw new Error("Git branches are unavailable.");
+      const api = ensureEnvironmentApi(input.environmentId);
       return api.git.listBranches({
         cwd: input.cwd,
         ...(normalizedQuery.length > 0 ? { query: normalizedQuery } : {}),
 }
 export function gitResolvePullRequestQueryOptions(input: {
+  environmentId: EnvironmentId | null;
   cwd: string | null;
   reference: string | null;
 }) {
   return queryOptions({
-    queryKey: ["git", "pull-request", input.cwd, input.reference] as const,
+    queryKey: [
+      "git",
+      "pull-request",
+      input.environmentId ?? null,
+      input.cwd,
+      input.reference,
+    ] as const,
     queryFn: async () => {
-      const api = ensureNativeApi();
+      if (!input.cwd || !input.reference || !input.environmentId) {
-      if (!input.cwd || !input.reference) {
         throw new Error("Pull request lookup is unavailable.");
       }
+      const api = ensureEnvironmentApi(input.environmentId);
       return api.git.resolvePullRequest({ cwd: input.cwd, reference: input.reference });
     },
-    enabled: input.cwd !== null && input.reference !== null,
+    enabled: input.environmentId !== null && input.cwd !== null && input.reference !== null,
     staleTime: 30_000,
     refetchOnWindowFocus: false,
     refetchOnReconnect: false,
   });
 }
-export function gitInitMutationOptions(input: { cwd: string | null; queryClient: QueryClient }) {
+export function gitInitMutationOptions(input: {
+  environmentId: EnvironmentId | null;
+  cwd: string | null;
+  queryClient: QueryClient;
+}) {
   return mutationOptions({
-    mutationKey: gitMutationKeys.init(input.cwd),
+    mutationKey: gitMutationKeys.init(input.environmentId, input.cwd),
     mutationFn: async () => {
-      const api = ensureNativeApi();
+      if (!input.cwd || !input.environmentId) throw new Error("Git init is unavailable.");
-      if (!input.cwd) throw new Error("Git init is unavailable.");
+      const api = ensureEnvironmentApi(input.environmentId);
       return api.git.init({ cwd: input.cwd });
     },
     onSettled: async () => {
-      await invalidateGitBranchQueries(input.queryClient, input.cwd);
+      await invalidateGitBranchQueries(input.queryClient, input.environmentId, input.cwd);
     },
   });
 }
 export function gitCheckoutMutationOptions(input: {
+  environmentId: EnvironmentId | null;
   cwd: string | null;
   queryClient: QueryClient;
 }) {
   return mutationOptions({
-    mutationKey: gitMutationKeys.checkout(input.cwd),
+    mutationKey: gitMutationKeys.checkout(input.environmentId, input.cwd),
     mutationFn: async (branch: string) => {
-      const api = ensureNativeApi();
+      if (!input.cwd || !input.environmentId) throw new Error("Git checkout is unavailable.");
-      if (!input.cwd) throw new Error("Git checkout is unavailable.");
+      const api = ensureEnvironmentApi(input.environmentId);
       return api.git.checkout({ cwd: input.cwd, branch });
     },
     onSettled: async () => {
-      await invalidateGitBranchQueries(input.queryClient, input.cwd);
+      await invalidateGitBranchQueries(input.queryClient, input.environmentId, input.cwd);
     },
   });
 }
 export function gitRunStackedActionMutationOptions(input: {
+  environmentId: EnvironmentId | null;
   cwd: string | null;
   queryClient: QueryClient;
 }) {
   return mutationOptions({
-    mutationKey: gitMutationKeys.runStackedAction(input.cwd),
+    mutationKey: gitMutationKeys.runStackedAction(input.environmentId, input.cwd),
     mutationFn: async ({
       actionId,
       action,
       filePaths?: string[];
       onProgress?: (event: GitActionProgressEvent) => void;
     }) => {
-      if (!input.cwd) throw new Error("Git action is unavailable.");
+      if (!input.cwd || !input.environmentId) throw new Error("Git action is unavailable.");
-      return getWsRpcClient().git.runStackedAction(
+      return getWsRpcClientForEnvironment(input.environmentId).git.runStackedAction(
         {
           action,
           actionId,
       );
     },
     onSuccess: async () => {
-      await invalidateGitBranchQueries(input.queryClient, input.cwd);
+      await invalidateGitBranchQueries(input.queryClient, input.environmentId, input.cwd);
     },
   });
 }
-export function gitPullMutationOptions(input: { cwd: string | null; queryClient: QueryClient }) {
+export function gitPullMutationOptions(input: {
+  environmentId: EnvironmentId | null;
+  cwd: string | null;
+  queryClient: QueryClient;
+}) {
   return mutationOptions({
-    mutationKey: gitMutationKeys.pull(input.cwd),
+    mutationKey: gitMutationKeys.pull(input.environmentId, input.cwd),
     mutationFn: async () => {
-      const api = ensureNativeApi();
+      if (!input.cwd || !input.environmentId) throw new Error("Git pull is unavailable.");
-      if (!input.cwd) throw new Error("Git pull is unavailable.");
+      const api = ensureEnvironmentApi(input.environmentId);
       return api.git.pull({ cwd: input.cwd });
     },
     onSuccess: async () => {
-      await invalidateGitBranchQueries(input.queryClient, input.cwd);
+      await invalidateGitBranchQueries(input.queryClient, input.environmentId, input.cwd);
     },
   });
 }
-export function gitCreateWorktreeMutationOptions(input: { queryClient: QueryClient }) {
+export function gitCreateWorktreeMutationOptions(input: {
+  environmentId: EnvironmentId | null;
+  queryClient: QueryClient;
+}) {
   return mutationOptions({
-    mutationKey: ["git", "mutation", "create-worktree"] as const,
+    mutationKey: ["git", "mutation", "create-worktree", input.environmentId ?? null] as const,
     mutationFn: (
-      args: Parameters<ReturnType<typeof ensureNativeApi>["git"]["createWorktree"]>[0],
+      args: Parameters<ReturnType<typeof ensureEnvironmentApi>["git"]["createWorktree"]>[0],
-    ) => ensureNativeApi().git.createWorktree(args),
+    ) => {
+      if (!input.environmentId) {
+        throw new Error("Worktree creation is unavailable.");
+      }
+      return ensureEnvironmentApi(input.environmentId).git.createWorktree(args);
+    },
     onSuccess: async () => {
-      await invalidateGitQueries(input.queryClient);
+      await invalidateGitQueries(input.queryClient, { environmentId: input.environmentId });
     },
   });
 }
-export function gitRemoveWorktreeMutationOptions(input: { queryClient: QueryClient }) {
+export function gitRemoveWorktreeMutationOptions(input: {
+  environmentId: EnvironmentId | null;
+  queryClient: QueryClient;
+}) {
   return mutationOptions({
-    mutationKey: ["git", "mutation", "remove-worktree"] as const,
+    mutationKey: ["git", "mutation", "remove-worktree", input.environmentId ?? null] as const,
     mutationFn: (
-      args: Parameters<ReturnType<typeof ensureNativeApi>["git"]["removeWorktree"]>[0],
+      args: Parameters<ReturnType<typeof ensureEnvironmentApi>["git"]["removeWorktree"]>[0],
-    ) => ensureNativeApi().git.removeWorktree(args),
+    ) => {
+      if (!input.environmentId) {
+        throw new Error("Worktree removal is unavailable.");
+      }
+      return ensureEnvironmentApi(input.environmentId).git.removeWorktree(args);
+    },
     onSuccess: async () => {
-      await invalidateGitQueries(input.queryClient);
+      await invalidateGitQueries(input.queryClient, { environmentId: input.environmentId });
     },
   });
 }
 export function gitPreparePullRequestThreadMutationOptions(input: {
+  environmentId: EnvironmentId | null;
   cwd: string | null;
   queryClient: QueryClient;
 }) {
   return mutationOptions({
-    mutationKey: gitMutationKeys.preparePullRequestThread(input.cwd),
+    mutationKey: gitMutationKeys.preparePullRequestThread(input.environmentId, input.cwd),
     mutationFn: async (args: {
       reference: string;
       mode: "local" | "worktree";
       threadId?: ThreadId;
     }) => {
-      const api = ensureNativeApi();
+      if (!input.cwd || !input.environmentId) {
-      if (!input.cwd) throw new Error("Pull request thread preparation is unavailable.");
+        throw new Error("Pull request thread preparation is unavailable.");
+      }
+      const api = ensureEnvironmentApi(input.environmentId);
       return api.git.preparePullRequestThread({
         cwd: input.cwd,
         reference: args.reference,
       });
     },
     onSuccess: async () => {
-      await invalidateGitBranchQueries(input.queryClient, input.cwd);
+      await invalidateGitBranchQueries(input.queryClient, input.environmentId, input.cwd);
     },
   });
 }

apps/web/src/lib/gitStatusState.test.ts+47−9

-import type { GitStatusResult } from "@t3tools/contracts";
+import { EnvironmentId, type GitStatusResult } from "@t3tools/contracts";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
 }
 const gitStatusListeners = new Set<(event: GitStatusResult) => void>();
+const ENVIRONMENT_ID = EnvironmentId.makeUnsafe("environment-local");
+const OTHER_ENVIRONMENT_ID = EnvironmentId.makeUnsafe("environment-remote");
+const TARGET = { environmentId: ENVIRONMENT_ID, cwd: "/repo" } as const;
+const FRESH_TARGET = { environmentId: ENVIRONMENT_ID, cwd: "/fresh" } as const;
 const BASE_STATUS: GitStatusResult = {
   isRepo: true,
 describe("gitStatusState", () => {
   it("starts fresh cwd state in a pending state", () => {
-    expect(getGitStatusSnapshot("/fresh")).toEqual({
+    expect(getGitStatusSnapshot(FRESH_TARGET)).toEqual({
       data: null,
       error: null,
       cause: null,
   });
   it("shares one live subscription per cwd and updates the per-cwd atom snapshot", () => {
-    const releaseA = watchGitStatus("/repo", gitClient);
+    const releaseA = watchGitStatus(TARGET, gitClient);
-    const releaseB = watchGitStatus("/repo", gitClient);
+    const releaseB = watchGitStatus(TARGET, gitClient);
     expect(gitClient.onStatus).toHaveBeenCalledOnce();
-    expect(getGitStatusSnapshot("/repo")).toEqual({
+    expect(getGitStatusSnapshot(TARGET)).toEqual({
       data: null,
       error: null,
       cause: null,
     emitGitStatus(BASE_STATUS);
-    expect(getGitStatusSnapshot("/repo")).toEqual({
+    expect(getGitStatusSnapshot(TARGET)).toEqual({
       data: BASE_STATUS,
       error: null,
       cause: null,
   });
   it("refreshes git status through the unary RPC without restarting the stream", async () => {
-    const release = watchGitStatus("/repo", gitClient);
+    const release = watchGitStatus(TARGET, gitClient);
     emitGitStatus(BASE_STATUS);
-    const refreshed = await refreshGitStatus("/repo", gitClient);
+    const refreshed = await refreshGitStatus(TARGET, gitClient);
     expect(gitClient.onStatus).toHaveBeenCalledOnce();
     expect(gitClient.refreshStatus).toHaveBeenCalledWith({ cwd: "/repo" });
     expect(refreshed).toEqual({ ...BASE_STATUS, branch: "/repo-refreshed" });
-    expect(getGitStatusSnapshot("/repo")).toEqual({
+    expect(getGitStatusSnapshot(TARGET)).toEqual({
       data: BASE_STATUS,
       error: null,
       cause: null,
     release();
   });
+  it("keeps git status subscriptions isolated by environment when cwds match", () => {
+    const localListeners = new Set<(event: GitStatusResult) => void>();
+    const remoteListeners = new Set<(event: GitStatusResult) => void>();
+    const localClient = {
+      refreshStatus: vi.fn(),
+      onStatus: vi.fn((_: { cwd: string }, listener: (event: GitStatusResult) => void) =>
+        registerListener(localListeners, listener),
+      ),
+    };
+    const remoteClient = {
+      refreshStatus: vi.fn(),
+      onStatus: vi.fn((_: { cwd: string }, listener: (event: GitStatusResult) => void) =>
+        registerListener(remoteListeners, listener),
+      ),
+    };
+    const remoteTarget = { environmentId: OTHER_ENVIRONMENT_ID, cwd: "/repo" } as const;
+    const releaseLocal = watchGitStatus(TARGET, localClient);
+    const releaseRemote = watchGitStatus(remoteTarget, remoteClient);
+    for (const listener of localListeners) {
+      listener(BASE_STATUS);
+    }
+    for (const listener of remoteListeners) {
+      listener({ ...BASE_STATUS, branch: "remote-branch" });
+    }
+    expect(getGitStatusSnapshot(TARGET).data?.branch).toBe("feature/push-status");
+    expect(getGitStatusSnapshot(remoteTarget).data?.branch).toBe("remote-branch");
+    releaseLocal();
+    releaseRemote();
+  });
 });

apps/web/src/lib/gitStatusState.ts+78−76

@@ -1,11 +1,15 @@
1	import { useAtomValue } from "@effect/atom-react";	1	import { useAtomValue } from "@effect/atom-react";
2	import { type GitManagerServiceError, type GitStatusResult } from "@t3tools/contracts";	2	import {
		3	type EnvironmentId,
		4	type GitManagerServiceError,
		5	type GitStatusResult,
		6	} from "@t3tools/contracts";
3	import { Cause } from "effect";	7	import { Cause } from "effect";
4	import { Atom } from "effect/unstable/reactivity";	8	import { Atom } from "effect/unstable/reactivity";
5	import { useEffect } from "react";	9	import { useEffect } from "react";
6		10
7	import { appAtomRegistry } from "../rpc/atomRegistry";	11	import { appAtomRegistry } from "../rpc/atomRegistry";
8	import { getWsRpcClient, type WsRpcClient } from "../wsRpcClient";	12	import { getWsRpcClient, getWsRpcClientForEnvironment, type WsRpcClient } from "../wsRpcClient";
9		13
10	export type GitStatusStreamError = GitManagerServiceError;	14	export type GitStatusStreamError = GitManagerServiceError;
11		15
@@ -23,6 +27,11 @@ interface WatchedGitStatus { · 11 unmodified lines
23	unsubscribe: () => void;	27	unsubscribe: () => void;
24	}	28	}
25		29
		30	export interface GitStatusTarget {
		31	readonly environmentId: EnvironmentId \| null;
		32	readonly cwd: string \| null;
		33	}
		34
26	const EMPTY_GIT_STATUS_STATE = Object.freeze<GitStatusState>({	35	const EMPTY_GIT_STATUS_STATE = Object.freeze<GitStatusState>({
27	data: null,	36	data: null,
28	error: null,	37	error: null,
@@ -40,79 +49,91 @@ const EMPTY_GIT_STATUS_ATOM = Atom.make(EMPTY_GIT_STATUS_STATE).pipe( · 11 unmodified lines
40		49
41	const NOOP: () => void = () => undefined;	50	const NOOP: () => void = () => undefined;
42	const watchedGitStatuses = new Map<string, WatchedGitStatus>();	51	const watchedGitStatuses = new Map<string, WatchedGitStatus>();
43	const knownGitStatusCwds = new Set<string>();	52	const knownGitStatusKeys = new Set<string>();
44	const gitStatusRefreshInFlight = new Map<string, Promise<GitStatusResult>>();	53	const gitStatusRefreshInFlight = new Map<string, Promise<GitStatusResult>>();
45	const gitStatusLastRefreshAtByCwd = new Map<string, number>();	54	const gitStatusLastRefreshAtByKey = new Map<string, number>();
46		55
47	const GIT_STATUS_REFRESH_DEBOUNCE_MS = 1_000;	56	const GIT_STATUS_REFRESH_DEBOUNCE_MS = 1_000;
48		57
49	let sharedGitStatusClient: GitStatusClient \| null = null;	58	const gitStatusStateAtom = Atom.family((key: string) => {
50		59	knownGitStatusKeys.add(key);
51	const gitStatusStateAtom = Atom.family((cwd: string) => {
52	knownGitStatusCwds.add(cwd);
53	return Atom.make(INITIAL_GIT_STATUS_STATE).pipe(	60	return Atom.make(INITIAL_GIT_STATUS_STATE).pipe(
54	Atom.keepAlive,	61	Atom.keepAlive,
55	Atom.withLabel(`git-status:${cwd}`),	62	Atom.withLabel(`git-status:${key}`),
56	);	63	);
57	});	64	});
58		65
59	export function getGitStatusSnapshot(cwd: string \| null): GitStatusState {	66	function getGitStatusTargetKey(target: GitStatusTarget): string \| null {
60	if (cwd === null) {	67	if (target.cwd === null) {
		68	return null;
		69	}
		70
		71	return `${target.environmentId ?? "__default__"}:${target.cwd}`;
		72	}
		73
		74	function resolveGitStatusClient(target: GitStatusTarget): GitStatusClient {
		75	if (target.environmentId) {
		76	return getWsRpcClientForEnvironment(target.environmentId).git;
		77	}
		78	return getWsRpcClient().git;
		79	}
		80
		81	export function getGitStatusSnapshot(target: GitStatusTarget): GitStatusState {
		82	const targetKey = getGitStatusTargetKey(target);
		83	if (targetKey === null) {
61	return EMPTY_GIT_STATUS_STATE;	84	return EMPTY_GIT_STATUS_STATE;
62	}	85	}
63		86
64	return appAtomRegistry.get(gitStatusStateAtom(cwd));	87	return appAtomRegistry.get(gitStatusStateAtom(targetKey));
65	}	88	}
66		89
67	export function watchGitStatus(	90	export function watchGitStatus(
68	cwd: string \| null,	91	target: GitStatusTarget,
69	client: GitStatusClient = getWsRpcClient().git,	92	client: GitStatusClient = resolveGitStatusClient(target),
70	): () => void {	93	): () => void {
71	if (cwd === null) {	94	const targetKey = getGitStatusTargetKey(target);
		95	if (targetKey === null) {
72	return NOOP;	96	return NOOP;
73	}	97	}
74		98
75	ensureGitStatusClient(client);	99	const watched = watchedGitStatuses.get(targetKey);
76
77	const watched = watchedGitStatuses.get(cwd);
78	if (watched) {	100	if (watched) {
79	watched.refCount += 1;	101	watched.refCount += 1;
80	return () => unwatchGitStatus(cwd);	102	return () => unwatchGitStatus(targetKey);
81	}	103	}
82		104
83	watchedGitStatuses.set(cwd, {	105	watchedGitStatuses.set(targetKey, {
84	refCount: 1,	106	refCount: 1,
85	unsubscribe: subscribeToGitStatus(cwd),	107	unsubscribe: subscribeToGitStatus(targetKey, target.cwd!, client),
86	});	108	});
87		109
88	return () => unwatchGitStatus(cwd);	110	return () => unwatchGitStatus(targetKey);
89	}	111	}
90		112
91	export function refreshGitStatus(	113	export function refreshGitStatus(
92	cwd: string \| null,	114	target: GitStatusTarget,
93	client: GitStatusClient = getWsRpcClient().git,	115	client: GitStatusClient = resolveGitStatusClient(target),
94	): Promise<GitStatusResult \| null> {	116	): Promise<GitStatusResult \| null> {
95	if (cwd === null) {	117	const targetKey = getGitStatusTargetKey(target);
		118	if (targetKey === null \|\| target.cwd === null) {
96	return Promise.resolve(null);	119	return Promise.resolve(null);
97	}	120	}
98		121
99	ensureGitStatusClient(client);	122	const currentInFlight = gitStatusRefreshInFlight.get(targetKey);
100
101	const currentInFlight = gitStatusRefreshInFlight.get(cwd);
102	if (currentInFlight) {	123	if (currentInFlight) {
103	return currentInFlight;	124	return currentInFlight;
104	}	125	}
105		126
106	const lastRequestedAt = gitStatusLastRefreshAtByCwd.get(cwd) ?? 0;	127	const lastRequestedAt = gitStatusLastRefreshAtByKey.get(targetKey) ?? 0;
107	if (Date.now() - lastRequestedAt < GIT_STATUS_REFRESH_DEBOUNCE_MS) {	128	if (Date.now() - lastRequestedAt < GIT_STATUS_REFRESH_DEBOUNCE_MS) {
108	return Promise.resolve(getGitStatusSnapshot(cwd).data);	129	return Promise.resolve(getGitStatusSnapshot(target).data);
109	}	130	}
110		131
111	gitStatusLastRefreshAtByCwd.set(cwd, Date.now());	132	gitStatusLastRefreshAtByKey.set(targetKey, Date.now());
112	const refreshPromise = client.refreshStatus({ cwd }).finally(() => {	133	const refreshPromise = client.refreshStatus({ cwd: target.cwd }).finally(() => {
113	gitStatusRefreshInFlight.delete(cwd);	134	gitStatusRefreshInFlight.delete(targetKey);
114	});	135	});
115	gitStatusRefreshInFlight.set(cwd, refreshPromise);	136	gitStatusRefreshInFlight.set(targetKey, refreshPromise);
116	return refreshPromise;	137	return refreshPromise;
117	}	138	}
118		139
@@ -122,43 +143,29 @@ export function resetGitStatusStateForTests(): void { · 3 unmodified lines
122	}	143	}
123	watchedGitStatuses.clear();	144	watchedGitStatuses.clear();
124	gitStatusRefreshInFlight.clear();	145	gitStatusRefreshInFlight.clear();
125	gitStatusLastRefreshAtByCwd.clear();	146	gitStatusLastRefreshAtByKey.clear();
126	sharedGitStatusClient = null;
127		147
128	for (const cwd of knownGitStatusCwds) {	148	for (const key of knownGitStatusKeys) {
129	appAtomRegistry.set(gitStatusStateAtom(cwd), INITIAL_GIT_STATUS_STATE);	149	appAtomRegistry.set(gitStatusStateAtom(key), INITIAL_GIT_STATUS_STATE);
130	}	150	}
131	knownGitStatusCwds.clear();	151	knownGitStatusKeys.clear();
132	}
133
134	export function useGitStatus(cwd: string \| null): GitStatusState {
135	useEffect(() => watchGitStatus(cwd), [cwd]);
136
137	const state = useAtomValue(cwd !== null ? gitStatusStateAtom(cwd) : EMPTY_GIT_STATUS_ATOM);
138	return cwd === null ? EMPTY_GIT_STATUS_STATE : state;
139	}	152	}
140		153
141	function ensureGitStatusClient(client: GitStatusClient): void {	154	export function useGitStatus(target: GitStatusTarget): GitStatusState {
142	if (sharedGitStatusClient === client) {	155	const targetKey = getGitStatusTargetKey(target);
143	return;	156	useEffect(
144	}	157	() => watchGitStatus({ environmentId: target.environmentId, cwd: target.cwd }),
145		158	[target.environmentId, target.cwd],
146	if (sharedGitStatusClient !== null) {	159	);
147	resetLiveGitStatusSubscriptions();
148	}
149
150	sharedGitStatusClient = client;
151	}
152		160
153	function resetLiveGitStatusSubscriptions(): void {	161	const state = useAtomValue(
154	for (const watched of watchedGitStatuses.values()) {	162	targetKey !== null ? gitStatusStateAtom(targetKey) : EMPTY_GIT_STATUS_ATOM,
155	watched.unsubscribe();	163	);
156	}	164	return targetKey === null ? EMPTY_GIT_STATUS_STATE : state;
157	watchedGitStatuses.clear();
158	}	165	}
159		166
160	function unwatchGitStatus(cwd: string): void {	167	function unwatchGitStatus(targetKey: string): void {
161	const watched = watchedGitStatuses.get(cwd);	168	const watched = watchedGitStatuses.get(targetKey);
162	if (!watched) {	169	if (!watched) {
163	return;	170	return;
164	}	171	}
@@ -169,20 +176,15 @@ function unwatchGitStatus(cwd: string): void { · 4 unmodified lines
169	}	176	}
170		177
171	watched.unsubscribe();	178	watched.unsubscribe();
172	watchedGitStatuses.delete(cwd);	179	watchedGitStatuses.delete(targetKey);
173	}	180	}
174		181
175	function subscribeToGitStatus(cwd: string): () => void {	182	function subscribeToGitStatus(targetKey: string, cwd: string, client: GitStatusClient): () => void {
176	const client = sharedGitStatusClient;	183	markGitStatusPending(targetKey);
177	if (!client) {
178	return NOOP;
179	}
180
181	markGitStatusPending(cwd);
182	return client.onStatus(	184	return client.onStatus(
183	{ cwd },	185	{ cwd },
184	(status) => {	186	(status) => {
185	appAtomRegistry.set(gitStatusStateAtom(cwd), {	187	appAtomRegistry.set(gitStatusStateAtom(targetKey), {
186	data: status,	188	data: status,
187	error: null,	189	error: null,
188	cause: null,	190	cause: null,
@@ -191,14 +193,14 @@ function subscribeToGitStatus(cwd: string): () => void { · 2 unmodified lines
191	},	193	},
192	{	194	{
193	onResubscribe: () => {	195	onResubscribe: () => {
194	markGitStatusPending(cwd);	196	markGitStatusPending(targetKey);
195	},	197	},
196	},	198	},
197	);	199	);
198	}	200	}
199		201
200	function markGitStatusPending(cwd: string): void {	202	function markGitStatusPending(targetKey: string): void {
201	const atom = gitStatusStateAtom(cwd);	203	const atom = gitStatusStateAtom(targetKey);
202	const current = appAtomRegistry.get(atom);	204	const current = appAtomRegistry.get(atom);
203	const next =	205	const next =
204	current.data === null	206	current.data === null

apps/web/src/lib/projectReactQuery.ts+17−8

-import type { ProjectSearchEntriesResult } from "@t3tools/contracts";
+import type { EnvironmentId, ProjectSearchEntriesResult } from "@t3tools/contracts";
 import { queryOptions } from "@tanstack/react-query";
-import { ensureNativeApi } from "~/nativeApi";
+import { ensureEnvironmentApi } from "~/environmentApi";
 export const projectQueryKeys = {
   all: ["projects"] as const,
-  searchEntries: (cwd: string | null, query: string, limit: number) =>
+  searchEntries: (
-    ["projects", "search-entries", cwd, query, limit] as const,
+    environmentId: EnvironmentId | null,
+    cwd: string | null,
+    query: string,
+    limit: number,
+  ) => ["projects", "search-entries", environmentId ?? null, cwd, query, limit] as const,
 };
 const DEFAULT_SEARCH_ENTRIES_LIMIT = 80;
 };
 export function projectSearchEntriesQueryOptions(input: {
+  environmentId: EnvironmentId | null;
   cwd: string | null;
   query: string;
   enabled?: boolean;
 }) {
   const limit = input.limit ?? DEFAULT_SEARCH_ENTRIES_LIMIT;
   return queryOptions({
-    queryKey: projectQueryKeys.searchEntries(input.cwd, input.query, limit),
+    queryKey: projectQueryKeys.searchEntries(input.environmentId, input.cwd, input.query, limit),
     queryFn: async () => {
-      const api = ensureNativeApi();
+      if (!input.cwd || !input.environmentId) {
-      if (!input.cwd) {
         throw new Error("Workspace entry search is unavailable.");
       }
+      const api = ensureEnvironmentApi(input.environmentId);
       return api.projects.searchEntries({
         cwd: input.cwd,
         query: input.query,
         limit,
       });
     },
-    enabled: (input.enabled ?? true) && input.cwd !== null && input.query.length > 0,
+    enabled:
+      (input.enabled ?? true) &&
+      input.environmentId !== null &&
+      input.cwd !== null &&
+      input.query.length > 0,
     staleTime: input.staleTime ?? DEFAULT_SEARCH_ENTRIES_STALE_TIME,
     placeholderData: (previous) => previous ?? EMPTY_SEARCH_ENTRIES_RESULT,
   });

apps/web/src/lib/providerReactQuery.test.ts+11−4

-import { ThreadId, type NativeApi } from "@t3tools/contracts";
+import { EnvironmentId, ThreadId, type EnvironmentApi } from "@t3tools/contracts";
 import { QueryClient } from "@tanstack/react-query";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { checkpointDiffQueryOptions, providerQueryKeys } from "./providerReactQuery";
-import * as nativeApi from "../nativeApi";
+import * as environmentApi from "../environmentApi";
 const threadId = ThreadId.makeUnsafe("thread-id");
+const environmentId = EnvironmentId.makeUnsafe("environment-local");
 function mockNativeApi(input: {
   getTurnDiff: ReturnType<typeof vi.fn>;
   getFullThreadDiff: ReturnType<typeof vi.fn>;
 }) {
-  vi.spyOn(nativeApi, "ensureNativeApi").mockReturnValue({
+  vi.spyOn(environmentApi, "ensureEnvironmentApi").mockReturnValue({
     orchestration: {
       getTurnDiff: input.getTurnDiff,
       getFullThreadDiff: input.getFullThreadDiff,
     },
-  } as unknown as NativeApi);
+  } as unknown as EnvironmentApi);
 }
 afterEach(() => {
 describe("providerQueryKeys.checkpointDiff", () => {
   it("includes cacheScope so reused turn counts do not collide", () => {
     const baseInput = {
+      environmentId,
       threadId,
       fromTurnCount: 1,
       toTurnCount: 2,
     mockNativeApi({ getTurnDiff, getFullThreadDiff });
     const options = checkpointDiffQueryOptions({
+      environmentId,
       threadId,
       fromTurnCount: 3,
       toTurnCount: 4,
     mockNativeApi({ getTurnDiff, getFullThreadDiff });
     const options = checkpointDiffQueryOptions({
+      environmentId,
       threadId,
       fromTurnCount: 0,
       toTurnCount: 2,
     mockNativeApi({ getTurnDiff, getFullThreadDiff });
     const options = checkpointDiffQueryOptions({
+      environmentId,
       threadId,
       fromTurnCount: 4,
       toTurnCount: 3,
   it("retries checkpoint-not-ready errors longer than generic failures", () => {
     const options = checkpointDiffQueryOptions({
+      environmentId,
       threadId,
       fromTurnCount: 1,
       toTurnCount: 2,
   it("backs off longer for checkpoint-not-ready errors", () => {
     const options = checkpointDiffQueryOptions({
+      environmentId,
       threadId,
       fromTurnCount: 1,
       toTurnCount: 2,

apps/web/src/lib/providerReactQuery.ts+11−4

 import {
+  type EnvironmentId,
   OrchestrationGetFullThreadDiffInput,
   OrchestrationGetTurnDiffInput,
   ThreadId,
 } from "@t3tools/contracts";
 import { queryOptions } from "@tanstack/react-query";
 import { Option, Schema } from "effect";
-import { ensureNativeApi } from "../nativeApi";
+import { ensureEnvironmentApi } from "../environmentApi";
 interface CheckpointDiffQueryInput {
+  environmentId: EnvironmentId | null;
   threadId: ThreadId | null;
   fromTurnCount: number | null;
   toTurnCount: number | null;
     [
       "providers",
       "checkpointDiff",
+      input.environmentId ?? null,
       input.threadId,
       input.fromTurnCount,
       input.toTurnCount,
   return queryOptions({
     queryKey: providerQueryKeys.checkpointDiff(input),
     queryFn: async () => {
-      const api = ensureNativeApi();
+      if (!input.environmentId || !input.threadId || decodedRequest._tag === "None") {
-      if (!input.threadId || decodedRequest._tag === "None") {
         throw new Error("Checkpoint diff is unavailable.");
       }
+      const api = ensureEnvironmentApi(input.environmentId);
       try {
         if (decodedRequest.value.kind === "fullThreadDiff") {
           return await api.orchestration.getFullThreadDiff(decodedRequest.value.input);
         throw new Error(normalizeCheckpointErrorMessage(error), { cause: error });
       }
     },
-    enabled: (input.enabled ?? true) && !!input.threadId && decodedRequest._tag === "Some",
+    enabled:
+      (input.enabled ?? true) &&
+      !!input.environmentId &&
+      !!input.threadId &&
+      decodedRequest._tag === "Some",
     staleTime: Infinity,
     retry: (failureCount, error) => {
       if (isCheckpointTemporarilyUnavailable(error)) {

apps/web/src/lib/terminalStateCleanup.test.ts+20−13

+import { scopedThreadKey, scopeThreadRef } from "@t3tools/client-runtime";
 import { ThreadId } from "@t3tools/contracts";
 import { describe, expect, it } from "vitest";
 import { collectActiveTerminalThreadIds } from "./terminalStateCleanup";
 const threadId = (id: string): ThreadId => ThreadId.makeUnsafe(id);
+const threadKey = (environmentId: string, id: string): string =>
+  scopedThreadKey(scopeThreadRef(environmentId as never, threadId(id)));
 describe("collectActiveTerminalThreadIds", () => {
   it("retains non-deleted server threads", () => {
     const activeThreadIds = collectActiveTerminalThreadIds({
       snapshotThreads: [
-        { id: threadId("server-1"), deletedAt: null, archivedAt: null },
+        { key: threadKey("env-a", "server-1"), deletedAt: null, archivedAt: null },
-        { id: threadId("server-2"), deletedAt: null, archivedAt: null },
+        { key: threadKey("env-b", "server-2"), deletedAt: null, archivedAt: null },
       ],
-      draftThreadIds: [],
+      draftThreadKeys: [],
     });
-    expect(activeThreadIds).toEqual(new Set([threadId("server-1"), threadId("server-2")]));
+    expect(activeThreadIds).toEqual(
+      new Set([threadKey("env-a", "server-1"), threadKey("env-b", "server-2")]),
+    );
   });
   it("ignores deleted and archived server threads and keeps local draft threads", () => {
     const activeThreadIds = collectActiveTerminalThreadIds({
       snapshotThreads: [
-        { id: threadId("server-active"), deletedAt: null, archivedAt: null },
+        { key: threadKey("env-a", "server-active"), deletedAt: null, archivedAt: null },
         {
-          id: threadId("server-deleted"),
+          key: threadKey("env-a", "server-deleted"),
           deletedAt: "2026-03-05T08:00:00.000Z",
           archivedAt: null,
         },
         {
-          id: threadId("server-archived"),
+          key: threadKey("env-a", "server-archived"),
           deletedAt: null,
           archivedAt: "2026-03-05T09:00:00.000Z",
         },
       ],
-      draftThreadIds: [threadId("local-draft")],
+      draftThreadKeys: [threadKey("env-a", "local-draft")],
     });
-    expect(activeThreadIds).toEqual(new Set([threadId("server-active"), threadId("local-draft")]));
+    expect(activeThreadIds).toEqual(
+      new Set([threadKey("env-a", "server-active"), threadKey("env-a", "local-draft")]),
+    );
   });
   it("does not keep draft-linked terminal state for archived server threads", () => {
-    const archivedThreadId = threadId("server-archived");
+    const archivedThreadId = threadKey("env-a", "server-archived");
     const activeThreadIds = collectActiveTerminalThreadIds({
       snapshotThreads: [
         {
-          id: archivedThreadId,
+          key: archivedThreadId,
           deletedAt: null,
           archivedAt: "2026-03-05T09:00:00.000Z",
         },
       ],
-      draftThreadIds: [archivedThreadId, threadId("local-draft")],
+      draftThreadKeys: [archivedThreadId, threadKey("env-a", "local-draft")],
     });
-    expect(activeThreadIds).toEqual(new Set([threadId("local-draft")]));
+    expect(activeThreadIds).toEqual(new Set([threadKey("env-a", "local-draft")]));
   });
 });

apps/web/src/lib/terminalStateCleanup.ts+9−11

-import type { ThreadId } from "@t3tools/contracts";
 interface TerminalRetentionThread {
-  id: ThreadId;
+  key: string;
   deletedAt: string | null;
   archivedAt: string | null;
 }
 interface CollectActiveTerminalThreadIdsInput {
   snapshotThreads: readonly TerminalRetentionThread[];
-  draftThreadIds: Iterable<ThreadId>;
+  draftThreadKeys: Iterable<string>;
 }
 export function collectActiveTerminalThreadIds(
   input: CollectActiveTerminalThreadIdsInput,
-): Set<ThreadId> {
+): Set<string> {
-  const activeThreadIds = new Set<ThreadId>();
+  const activeThreadIds = new Set<string>();
-  const snapshotThreadById = new Map(input.snapshotThreads.map((thread) => [thread.id, thread]));
+  const snapshotThreadById = new Map(input.snapshotThreads.map((thread) => [thread.key, thread]));
   for (const thread of input.snapshotThreads) {
     if (thread.deletedAt !== null) continue;
     if (thread.archivedAt !== null) continue;
-    activeThreadIds.add(thread.id);
+    activeThreadIds.add(thread.key);
   }
-  for (const draftThreadId of input.draftThreadIds) {
+  for (const draftThreadKey of input.draftThreadKeys) {
-    const snapshotThread = snapshotThreadById.get(draftThreadId);
+    const snapshotThread = snapshotThreadById.get(draftThreadKey);
     if (
       snapshotThread &&
       (snapshotThread.deletedAt !== null || snapshotThread.archivedAt !== null)
     ) {
       continue;
     }
-    activeThreadIds.add(draftThreadId);
+    activeThreadIds.add(draftThreadKey);
   }
   return activeThreadIds;
 }

apps/web/src/lib/utils.test.ts+41−1

@@ -1,6 +1,15 @@
1	import { assert, describe, it } from "vitest";	1	import { assert, describe, expect, it, vi } from "vitest";
		2
		3	const { resolvePrimaryEnvironmentBootstrapUrlMock } = vi.hoisted(() => ({
		4	resolvePrimaryEnvironmentBootstrapUrlMock: vi.fn(() => "http://bootstrap.test:4321"),
		5	}));
		6
		7	vi.mock("../environmentBootstrap", () => ({
		8	resolvePrimaryEnvironmentBootstrapUrl: resolvePrimaryEnvironmentBootstrapUrlMock,
		9	}));
2		10
3	import { isWindowsPlatform } from "./utils";	11	import { isWindowsPlatform } from "./utils";
		12	import { resolveServerUrl } from "./utils";
4		13
5	describe("isWindowsPlatform", () => {	14	describe("isWindowsPlatform", () => {
6	it("matches Windows platform identifiers", () => {	15	it("matches Windows platform identifiers", () => {
@@ -13,3 +22,34 @@ describe("isWindowsPlatform", () => { · 6 unmodified lines
13	assert.isFalse(isWindowsPlatform("darwin"));	22	assert.isFalse(isWindowsPlatform("darwin"));
14	});	23	});
15	});	24	});
		25
		26	describe("resolveServerUrl", () => {
		27	it("falls back to the bootstrap environment URL when the explicit URL is empty", () => {
		28	expect(resolveServerUrl({ url: "" })).toBe("http://bootstrap.test:4321/");
		29	});
		30
		31	it("uses the bootstrap environment URL when no explicit URL is provided", () => {
		32	expect(resolveServerUrl()).toBe("http://bootstrap.test:4321/");
		33	});
		34
		35	it("prefers an explicit URL override", () => {
		36	expect(
		37	resolveServerUrl({
		38	url: "https://override.test:9999",
		39	protocol: "wss",
		40	pathname: "/rpc",
		41	searchParams: { hello: "world" },
		42	}),
		43	).toBe("wss://override.test:9999/rpc?hello=world");
		44	});
		45
		46	it("does not evaluate the bootstrap resolver when an explicit URL is provided", () => {
		47	resolvePrimaryEnvironmentBootstrapUrlMock.mockImplementationOnce(() => {
		48	throw new Error("bootstrap unavailable");
		49	});
		50
		51	expect(resolveServerUrl({ url: "https://override.test:9999" })).toBe(
		52	"https://override.test:9999/",
		53	);
		54	});
		55	});

apps/web/src/lib/utils.ts+7−14

 import { twMerge } from "tailwind-merge";
 import * as Random from "effect/Random";
 import * as Effect from "effect/Effect";
+import { resolvePrimaryEnvironmentBootstrapUrl } from "../environmentBootstrap";
+import { DraftId } from "../composerDraftStore";
 export function cn(...inputs: CxOptions) {
   return twMerge(cx(inputs));
 export const newThreadId = (): ThreadId => ThreadId.makeUnsafe(randomUUID());
+export const newDraftId = (): DraftId => DraftId.makeUnsafe(randomUUID());
 export const newMessageId = (): MessageId => MessageId.makeUnsafe(randomUUID());
 const isNonEmptyString = Predicate.compose(Predicate.isString, String.isNonEmpty);
-const firstNonEmptyString = (...values: unknown[]): string => {
-  for (const value of values) {
-    if (isNonEmptyString(value)) {
-      return value;
-    }
-  }
-  throw new Error("No non-empty string provided");
-};
 export const resolveServerUrl = (options?: {
   url?: string | undefined;
   pathname?: string | undefined;
   searchParams?: Record<string, string> | undefined;
 }): string => {
-  const rawUrl = firstNonEmptyString(
+  const rawUrl = isNonEmptyString(options?.url)
-    options?.url,
+    ? options.url
-    window.desktopBridge?.getWsUrl(),
+    : resolvePrimaryEnvironmentBootstrapUrl();
-    import.meta.env.VITE_WS_URL,
-    window.location.origin,
-  );
   const parsedUrl = new URL(rawUrl);
   if (options?.protocol) {

apps/web/src/localApi.test.tsrenamed from apps/web/src/wsNativeApi.test.ts+52−25

   CommandId,
   DEFAULT_SERVER_SETTINGS,
   type DesktopBridge,
+  EnvironmentId,
   EventId,
   type GitStatusResult,
   ProjectId,
 vi.mock("./wsRpcClient", () => {
   return {
     getWsRpcClient: () => rpcClientMock,
+    getPrimaryWsRpcClientEntry: () => ({
+      key: "primary",
+      knownEnvironment: {
+        id: "primary",
+        label: "Primary",
+        source: "manual",
+        target: { type: "ws", wsUrl: "ws://localhost:3000" },
+      },
+      client: rpcClientMock,
+      environmentId: null,
+    }),
     __resetWsRpcClientForTests: vi.fn(),
   };
 });
 function makeDesktopBridge(overrides: Partial<DesktopBridge> = {}): DesktopBridge {
   return {
     getWsUrl: () => null,
+    getLocalEnvironmentBootstrap: () => null,
     pickFolder: async () => null,
     confirm: async () => true,
     setTheme: async () => undefined,
   },
 ];
+const baseEnvironment = {
+  environmentId: EnvironmentId.makeUnsafe("environment-local"),
+  label: "Local environment",
+  platform: {
+    os: "darwin" as const,
+    arch: "arm64" as const,
+  },
+  serverVersion: "0.0.0-test",
+  capabilities: {
+    repositoryIdentity: true,
+  },
+};
 const baseServerConfig: ServerConfig = {
+  environment: baseEnvironment,
   cwd: "/tmp/workspace",
   keybindingsConfigPath: "/tmp/workspace/.config/keybindings.json",
   keybindings: [],
   vi.restoreAllMocks();
 });
-describe("wsNativeApi", () => {
+describe("wsApi", () => {
   it("forwards server config fetches directly to the RPC client", async () => {
     rpcClientMock.server.getConfig.mockResolvedValue(baseServerConfig);
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createLocalApi } = await import("./localApi");
-    const api = createWsNativeApi();
+    const api = createLocalApi();
     await expect(api.server.getConfig()).resolves.toEqual(baseServerConfig);
     expect(rpcClientMock.server.getConfig).toHaveBeenCalledWith();
   });
   it("forwards terminal and orchestration stream events", async () => {
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createEnvironmentApi } = await import("./environmentApi");
-    const api = createWsNativeApi();
+    const api = createEnvironmentApi(rpcClientMock as never);
     const onTerminalEvent = vi.fn();
     const onDomainEvent = vi.fn();
   });
   it("forwards git status stream events", async () => {
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createEnvironmentApi } = await import("./environmentApi");
-    const api = createWsNativeApi();
+    const api = createEnvironmentApi(rpcClientMock as never);
     const onStatus = vi.fn();
     api.git.onStatus({ cwd: "/repo" }, onStatus);
   it("forwards git status refreshes directly to the RPC client", async () => {
     rpcClientMock.git.refreshStatus.mockResolvedValue(baseGitStatus);
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createEnvironmentApi } = await import("./environmentApi");
-    const api = createWsNativeApi();
+    const api = createEnvironmentApi(rpcClientMock as never);
     await api.git.refreshStatus({ cwd: "/repo" });
   });
   it("forwards orchestration stream subscription options to the RPC client", async () => {
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createEnvironmentApi } = await import("./environmentApi");
-    const api = createWsNativeApi();
+    const api = createEnvironmentApi(rpcClientMock as never);
     const onDomainEvent = vi.fn();
     const onResubscribe = vi.fn();
   it("sends orchestration dispatch commands as the direct RPC payload", async () => {
     rpcClientMock.orchestration.dispatchCommand.mockResolvedValue({ sequence: 1 });
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createEnvironmentApi } = await import("./environmentApi");
-    const api = createWsNativeApi();
+    const api = createEnvironmentApi(rpcClientMock as never);
     const command = {
       type: "project.create",
       commandId: CommandId.makeUnsafe("cmd-1"),
   it("forwards workspace file writes to the project RPC", async () => {
     rpcClientMock.projects.writeFile.mockResolvedValue({ relativePath: "plan.md" });
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createEnvironmentApi } = await import("./environmentApi");
-    const api = createWsNativeApi();
+    const api = createEnvironmentApi(rpcClientMock as never);
     await api.projects.writeFile({
       cwd: "/tmp/project",
       relativePath: "plan.md",
   it("forwards full-thread diff requests to the orchestration RPC", async () => {
     rpcClientMock.orchestration.getFullThreadDiff.mockResolvedValue({ diff: "patch" });
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createEnvironmentApi } = await import("./environmentApi");
-    const api = createWsNativeApi();
+    const api = createEnvironmentApi(rpcClientMock as never);
     await api.orchestration.getFullThreadDiff({
       threadId: ThreadId.makeUnsafe("thread-1"),
       toTurnCount: 1,
       },
     ];
     rpcClientMock.server.refreshProviders.mockResolvedValue({ providers: nextProviders });
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createLocalApi } = await import("./localApi");
-    const api = createWsNativeApi();
+    const api = createLocalApi();
     await expect(api.server.refreshProviders()).resolves.toEqual({ providers: nextProviders });
     expect(rpcClientMock.server.refreshProviders).toHaveBeenCalledWith();
       enableAssistantStreaming: true,
     };
     rpcClientMock.server.updateSettings.mockResolvedValue(nextSettings);
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createLocalApi } = await import("./localApi");
-    const api = createWsNativeApi();
+    const api = createLocalApi();
     await expect(api.server.updateSettings({ enableAssistantStreaming: true })).resolves.toEqual(
       nextSettings,
     const showContextMenu = vi.fn().mockResolvedValue("delete");
     getWindowForTest().desktopBridge = makeDesktopBridge({ showContextMenu });
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createLocalApi } = await import("./localApi");
-    const api = createWsNativeApi();
+    const api = createLocalApi();
     const items = [{ id: "delete", label: "Delete" }] as const;
     await expect(api.contextMenu.show(items)).resolves.toBe("delete");
   it("falls back to the browser context menu helper when the desktop bridge is missing", async () => {
     showContextMenuFallbackMock.mockResolvedValue("rename");
-    const { createWsNativeApi } = await import("./wsNativeApi");
+    const { createLocalApi } = await import("./localApi");
-    const api = createWsNativeApi();
+    const api = createLocalApi();
     const items = [{ id: "rename", label: "Rename" }] as const;
     await expect(api.contextMenu.show(items, { x: 4, y: 5 })).resolves.toBe("rename");

apps/web/src/localApi.ts+94−0

@@ -0,0 +1,94 @@
	1	import type { ContextMenuItem, LocalApi } from "@t3tools/contracts";
	2
	3	import { resetGitStatusStateForTests } from "./lib/gitStatusState";
	4
	5	import { __resetWsRpcAtomClientForTests } from "./rpc/client";
	6	import { resetRequestLatencyStateForTests } from "./rpc/requestLatencyState";
	7	import { resetServerStateForTests } from "./rpc/serverState";
	8	import { resetWsConnectionStateForTests } from "./rpc/wsConnectionState";
	9	import { getPrimaryWsRpcClientEntry, WsRpcClient, __resetWsRpcClientForTests } from "./wsRpcClient";
	10	import { showContextMenuFallback } from "./contextMenuFallback";
	11
	12	let cachedApi: LocalApi \| undefined;
	13
	14	export function createLocalApi(
	15	rpcClient: WsRpcClient = getPrimaryWsRpcClientEntry().client,
	16	): LocalApi {
	17	return {
	18	dialogs: {
	19	pickFolder: async () => {
	20	if (!window.desktopBridge) return null;
	21	return window.desktopBridge.pickFolder();
	22	},
	23	confirm: async (message) => {
	24	if (window.desktopBridge) {
	25	return window.desktopBridge.confirm(message);
	26	}
	27	return window.confirm(message);
	28	},
	29	},
	30	shell: {
	31	openInEditor: (cwd, editor) => rpcClient.shell.openInEditor({ cwd, editor }),
	32	openExternal: async (url) => {
	33	if (window.desktopBridge) {
	34	const opened = await window.desktopBridge.openExternal(url);
	35	if (!opened) {
	36	throw new Error("Unable to open link.");
	37	}
	38	return;
	39	}
	40
	41	window.open(url, "_blank", "noopener,noreferrer");
	42	},
	43	},
	44	contextMenu: {
	45	show: async <T extends string>(
	46	items: readonly ContextMenuItem<T>[],
	47	position?: { x: number; y: number },
	48	): Promise<T \| null> => {
	49	if (window.desktopBridge) {
	50	return window.desktopBridge.showContextMenu(items, position) as Promise<T \| null>;
	51	}
	52	return showContextMenuFallback(items, position);
	53	},
	54	},
	55	server: {
	56	getConfig: rpcClient.server.getConfig,
	57	refreshProviders: rpcClient.server.refreshProviders,
	58	upsertKeybinding: rpcClient.server.upsertKeybinding,
	59	getSettings: rpcClient.server.getSettings,
	60	updateSettings: rpcClient.server.updateSettings,
	61	},
	62	};
	63	}
	64
	65	export function readLocalApi(): LocalApi \| undefined {
	66	if (typeof window === "undefined") return undefined;
	67	if (cachedApi) return cachedApi;
	68
	69	if (window.nativeApi) {
	70	cachedApi = window.nativeApi;
	71	return cachedApi;
	72	}
	73
	74	cachedApi = createLocalApi();
	75	return cachedApi;
	76	}
	77
	78	export function ensureLocalApi(): LocalApi {
	79	const api = readLocalApi();
	80	if (!api) {
	81	throw new Error("Local API not found");
	82	}
	83	return api;
	84	}
	85
	86	export async function __resetLocalApiForTests() {
	87	cachedApi = undefined;
	88	await __resetWsRpcAtomClientForTests();
	89	await __resetWsRpcClientForTests();
	90	resetGitStatusStateForTests();
	91	resetRequestLatencyStateForTests();
	92	resetServerStateForTests();
	93	resetWsConnectionStateForTests();
	94	}

apps/web/src/logicalProject.ts+19−0

@@ -0,0 +1,19 @@
	1	import { scopedProjectKey, scopeProjectRef } from "@t3tools/client-runtime";
	2	import type { ScopedProjectRef } from "@t3tools/contracts";
	3	import type { Project } from "./types";
	4
	5	export function deriveLogicalProjectKey(
	6	project: Pick<Project, "environmentId" \| "id" \| "repositoryIdentity">,
	7	): string {
	8	return (
	9	project.repositoryIdentity?.canonicalKey ??
	10	scopedProjectKey(scopeProjectRef(project.environmentId, project.id))
	11	);
	12	}
	13
	14	export function deriveLogicalProjectKeyFromRef(
	15	projectRef: ScopedProjectRef,
	16	project: Pick<Project, "repositoryIdentity"> \| null \| undefined,
	17	): string {
	18	return project?.repositoryIdentity?.canonicalKey ?? scopedProjectKey(projectRef);
	19	}

apps/web/src/nativeApi.ts+0−31

@@ -1,31 +0,0 @@
1	import type { NativeApi } from "@t3tools/contracts";
2
3	import { __resetWsNativeApiForTests, createWsNativeApi } from "./wsNativeApi";
4
5	let cachedApi: NativeApi \| undefined;
6
7	export function readNativeApi(): NativeApi \| undefined {
8	if (typeof window === "undefined") return undefined;
9	if (cachedApi) return cachedApi;
10
11	if (window.nativeApi) {
12	cachedApi = window.nativeApi;
13	return cachedApi;
14	}
15
16	cachedApi = createWsNativeApi();
17	return cachedApi;
18	}
19
20	export function ensureNativeApi(): NativeApi {
21	const api = readNativeApi();
22	if (!api) {
23	throw new Error("Native API not found");
24	}
25	return api;
26	}
27
28	export async function __resetNativeApiForTests() {
29	cachedApi = undefined;
30	await __resetWsNativeApiForTests();
31	}

apps/web/src/orchestrationEventEffects.test.ts+3−3

@@ -68,7 +68,7 @@ describe("deriveOrchestrationBatchEffects", () => { · 67 unmodified lines
68	}),	68	}),
69	]);	69	]);
70		70
71	expect(effects.clearPromotedDraftThreadIds).toEqual([createdThreadId]);	71	expect(effects.promoteDraftThreadIds).toEqual([createdThreadId]);
72	expect(effects.clearDeletedThreadIds).toEqual([deletedThreadId]);	72	expect(effects.clearDeletedThreadIds).toEqual([deletedThreadId]);
73	expect(effects.removeTerminalStateThreadIds).toEqual([deletedThreadId, archivedThreadId]);	73	expect(effects.removeTerminalStateThreadIds).toEqual([deletedThreadId, archivedThreadId]);
74	expect(effects.needsProviderInvalidation).toBe(false);	74	expect(effects.needsProviderInvalidation).toBe(false);
@@ -106,7 +106,7 @@ describe("deriveOrchestrationBatchEffects", () => { · 31 unmodified lines
106	}),	106	}),
107	]);	107	]);
108		108
109	expect(effects.clearPromotedDraftThreadIds).toEqual([threadId]);	109	expect(effects.promoteDraftThreadIds).toEqual([threadId]);
110	expect(effects.clearDeletedThreadIds).toEqual([]);	110	expect(effects.clearDeletedThreadIds).toEqual([]);
111	expect(effects.removeTerminalStateThreadIds).toEqual([]);	111	expect(effects.removeTerminalStateThreadIds).toEqual([]);
112	expect(effects.needsProviderInvalidation).toBe(true);	112	expect(effects.needsProviderInvalidation).toBe(true);
@@ -127,7 +127,7 @@ describe("deriveOrchestrationBatchEffects", () => { · 14 unmodified lines
127	}),	127	}),
128	]);	128	]);
129		129
130	expect(effects.clearPromotedDraftThreadIds).toEqual([]);	130	expect(effects.promoteDraftThreadIds).toEqual([]);
131	expect(effects.clearDeletedThreadIds).toEqual([]);	131	expect(effects.clearDeletedThreadIds).toEqual([]);
132	expect(effects.removeTerminalStateThreadIds).toEqual([]);	132	expect(effects.removeTerminalStateThreadIds).toEqual([]);
133	});	133	});

apps/web/src/orchestrationEventEffects.ts+4−4

@@ -1,7 +1,7 @@
1	import type { OrchestrationEvent, ThreadId } from "@t3tools/contracts";	1	import type { OrchestrationEvent, ThreadId } from "@t3tools/contracts";
2		2
3	export interface OrchestrationBatchEffects {	3	export interface OrchestrationBatchEffects {
4	clearPromotedDraftThreadIds: ThreadId[];	4	promoteDraftThreadIds: ThreadId[];
5	clearDeletedThreadIds: ThreadId[];	5	clearDeletedThreadIds: ThreadId[];
6	removeTerminalStateThreadIds: ThreadId[];	6	removeTerminalStateThreadIds: ThreadId[];
7	needsProviderInvalidation: boolean;	7	needsProviderInvalidation: boolean;
@@ -70,12 +70,12 @@ export function deriveOrchestrationBatchEffects( · 62 unmodified lines
70	}	70	}
71	}	71	}
72		72
73	const clearPromotedDraftThreadIds: ThreadId[] = [];	73	const promoteDraftThreadIds: ThreadId[] = [];
74	const clearDeletedThreadIds: ThreadId[] = [];	74	const clearDeletedThreadIds: ThreadId[] = [];
75	const removeTerminalStateThreadIds: ThreadId[] = [];	75	const removeTerminalStateThreadIds: ThreadId[] = [];
76	for (const [threadId, effect] of threadLifecycleEffects) {	76	for (const [threadId, effect] of threadLifecycleEffects) {
77	if (effect.clearPromotedDraft) {	77	if (effect.clearPromotedDraft) {
78	clearPromotedDraftThreadIds.push(threadId);	78	promoteDraftThreadIds.push(threadId);
79	}	79	}
80	if (effect.clearDeletedThread) {	80	if (effect.clearDeletedThread) {
81	clearDeletedThreadIds.push(threadId);	81	clearDeletedThreadIds.push(threadId);
@@ -86,7 +86,7 @@ export function deriveOrchestrationBatchEffects( · 4 unmodified lines
86	}	86	}
87		87
88	return {	88	return {
89	clearPromotedDraftThreadIds,	89	promoteDraftThreadIds,
90	clearDeletedThreadIds,	90	clearDeletedThreadIds,
91	removeTerminalStateThreadIds,	91	removeTerminalStateThreadIds,
92	needsProviderInvalidation,	92	needsProviderInvalidation,

apps/web/src/routeTree.gen.ts+39−17

 import { Route as ChatIndexRouteImport } from './routes/_chat.index'
 import { Route as SettingsGeneralRouteImport } from './routes/settings.general'
 import { Route as SettingsArchivedRouteImport } from './routes/settings.archived'
-import { Route as ChatThreadIdRouteImport } from './routes/_chat.$threadId'
+import { Route as ChatDraftDraftIdRouteImport } from './routes/_chat.draft.$draftId'
+import { Route as ChatEnvironmentIdThreadIdRouteImport } from './routes/_chat.$environmentId.$threadId'
 const SettingsRoute = SettingsRouteImport.update({
   id: '/settings',
   path: '/archived',
   getParentRoute: () => SettingsRoute,
 } as any)
-const ChatThreadIdRoute = ChatThreadIdRouteImport.update({
+const ChatDraftDraftIdRoute = ChatDraftDraftIdRouteImport.update({
-  id: '/$threadId',
+  id: '/draft/$draftId',
-  path: '/$threadId',
+  path: '/draft/$draftId',
   getParentRoute: () => ChatRoute,
 } as any)
+const ChatEnvironmentIdThreadIdRoute =
+  ChatEnvironmentIdThreadIdRouteImport.update({
+    id: '/$environmentId/$threadId',
+    path: '/$environmentId/$threadId',
+    getParentRoute: () => ChatRoute,
+  } as any)
 export interface FileRoutesByFullPath {
   '/': typeof ChatIndexRoute
   '/settings': typeof SettingsRouteWithChildren
-  '/$threadId': typeof ChatThreadIdRoute
   '/settings/archived': typeof SettingsArchivedRoute
   '/settings/general': typeof SettingsGeneralRoute
+  '/$environmentId/$threadId': typeof ChatEnvironmentIdThreadIdRoute
+  '/draft/$draftId': typeof ChatDraftDraftIdRoute
 }
 export interface FileRoutesByTo {
   '/settings': typeof SettingsRouteWithChildren
-  '/$threadId': typeof ChatThreadIdRoute
   '/settings/archived': typeof SettingsArchivedRoute
   '/settings/general': typeof SettingsGeneralRoute
   '/': typeof ChatIndexRoute
+  '/$environmentId/$threadId': typeof ChatEnvironmentIdThreadIdRoute
+  '/draft/$draftId': typeof ChatDraftDraftIdRoute
 }
 export interface FileRoutesById {
   __root__: typeof rootRouteImport
   '/_chat': typeof ChatRouteWithChildren
   '/settings': typeof SettingsRouteWithChildren
-  '/_chat/$threadId': typeof ChatThreadIdRoute
   '/settings/archived': typeof SettingsArchivedRoute
   '/settings/general': typeof SettingsGeneralRoute
   '/_chat/': typeof ChatIndexRoute
+  '/_chat/$environmentId/$threadId': typeof ChatEnvironmentIdThreadIdRoute
+  '/_chat/draft/$draftId': typeof ChatDraftDraftIdRoute
 }
 export interface FileRouteTypes {
   fileRoutesByFullPath: FileRoutesByFullPath
   fullPaths:
     | '/'
     | '/settings'
-    | '/$threadId'
     | '/settings/archived'
     | '/settings/general'
+    | '/$environmentId/$threadId'
+    | '/draft/$draftId'
   fileRoutesByTo: FileRoutesByTo
   to:
     | '/settings'
-    | '/$threadId'
     | '/settings/archived'
     | '/settings/general'
     | '/'
+    | '/$environmentId/$threadId'
+    | '/draft/$draftId'
   id:
     | '__root__'
     | '/_chat'
     | '/settings'
-    | '/_chat/$threadId'
     | '/settings/archived'
     | '/settings/general'
     | '/_chat/'
+    | '/_chat/$environmentId/$threadId'
+    | '/_chat/draft/$draftId'
   fileRoutesById: FileRoutesById
 }
 export interface RootRouteChildren {
       preLoaderRoute: typeof SettingsArchivedRouteImport
       parentRoute: typeof SettingsRoute
     }
-    '/_chat/$threadId': {
+    '/_chat/draft/$draftId': {
-      id: '/_chat/$threadId'
+      id: '/_chat/draft/$draftId'
-      path: '/$threadId'
+      path: '/draft/$draftId'
-      fullPath: '/$threadId'
+      fullPath: '/draft/$draftId'
-      preLoaderRoute: typeof ChatThreadIdRouteImport
+      preLoaderRoute: typeof ChatDraftDraftIdRouteImport
+      parentRoute: typeof ChatRoute
+    }
+    '/_chat/$environmentId/$threadId': {
+      id: '/_chat/$environmentId/$threadId'
+      path: '/$environmentId/$threadId'
+      fullPath: '/$environmentId/$threadId'
+      preLoaderRoute: typeof ChatEnvironmentIdThreadIdRouteImport
       parentRoute: typeof ChatRoute
     }
   }
 }
 interface ChatRouteChildren {
-  ChatThreadIdRoute: typeof ChatThreadIdRoute
   ChatIndexRoute: typeof ChatIndexRoute
+  ChatEnvironmentIdThreadIdRoute: typeof ChatEnvironmentIdThreadIdRoute
+  ChatDraftDraftIdRoute: typeof ChatDraftDraftIdRoute
 }
 const ChatRouteChildren: ChatRouteChildren = {
-  ChatThreadIdRoute: ChatThreadIdRoute,
   ChatIndexRoute: ChatIndexRoute,
+  ChatEnvironmentIdThreadIdRoute: ChatEnvironmentIdThreadIdRoute,
+  ChatDraftDraftIdRoute: ChatDraftDraftIdRoute,
 }
 const ChatRouteWithChildren = ChatRoute._addFileChildren(ChatRouteChildren)

apps/web/src/routes/__root.tsx+319−166

@@ -1,8 +1,15 @@
1	import {	1	import {
		2	type EnvironmentId,
2	OrchestrationEvent,	3	OrchestrationEvent,
3	type ServerLifecycleWelcomePayload,	4	type ServerLifecycleWelcomePayload,
4	ThreadId,	5	ThreadId,
5	} from "@t3tools/contracts";	6	} from "@t3tools/contracts";
		7	import {
		8	scopedProjectKey,
		9	scopedThreadKey,
		10	scopeProjectRef,
		11	scopeThreadRef,
		12	} from "@t3tools/client-runtime";
6	import {	13	import {
7	Outlet,	14	Outlet,
8	createRootRouteWithContext,	15	createRootRouteWithContext,
@@ -10,7 +17,7 @@ import { · 1 unmodified line
10	useNavigate,	17	useNavigate,
11	useLocation,	18	useLocation,
12	} from "@tanstack/react-router";	19	} from "@tanstack/react-router";
13	import { useEffect, useEffectEvent, useRef } from "react";	20	import { useEffect, useEffectEvent, useRef, useState } from "react";
14	import { QueryClient, useQueryClient } from "@tanstack/react-query";	21	import { QueryClient, useQueryClient } from "@tanstack/react-query";
15	import { Throttler } from "@tanstack/react-pacer";	22	import { Throttler } from "@tanstack/react-pacer";
16		23
@@ -24,7 +31,7 @@ import { · 7 unmodified lines
24	import { Button } from "../components/ui/button";	31	import { Button } from "../components/ui/button";
25	import { AnchoredToastProvider, ToastProvider, toastManager } from "../components/ui/toast";	32	import { AnchoredToastProvider, ToastProvider, toastManager } from "../components/ui/toast";
26	import { resolveAndPersistPreferredEditor } from "../editorPreferences";	33	import { resolveAndPersistPreferredEditor } from "../editorPreferences";
27	import { readNativeApi } from "../nativeApi";	34	import { readLocalApi } from "../localApi";
28	import {	35	import {
29	getServerConfigUpdatedNotification,	36	getServerConfigUpdatedNotification,
30	ServerConfigUpdatedNotification,	37	ServerConfigUpdatedNotification,
@@ -34,11 +41,15 @@ import { · 3 unmodified lines
34	useServerWelcomeSubscription,	41	useServerWelcomeSubscription,
35	} from "../rpc/serverState";	42	} from "../rpc/serverState";
36	import {	43	import {
37	clearPromotedDraftThread,	44	markPromotedDraftThreadByRef,
38	clearPromotedDraftThreads,	45	markPromotedDraftThreadsByRef,
39	useComposerDraftStore,	46	useComposerDraftStore,
40	} from "../composerDraftStore";	47	} from "../composerDraftStore";
41	import { selectProjects, selectThreadById, selectThreads, useStore } from "../store";	48	import {
		49	selectProjectsAcrossEnvironments,
		50	selectThreadsAcrossEnvironments,
		51	useStore,
		52	} from "../store";
42	import { useUiStateStore } from "../uiStateStore";	53	import { useUiStateStore } from "../uiStateStore";
43	import { useTerminalStateStore } from "../terminalStateStore";	54	import { useTerminalStateStore } from "../terminalStateStore";
44	import { migrateLocalSettingsToServer } from "../hooks/useSettings";	55	import { migrateLocalSettingsToServer } from "../hooks/useSettings";
@@ -48,7 +59,15 @@ import { collectActiveTerminalThreadIds } from "../lib/terminalStateCleanup"; · 3 unmodified lines
48	import { deriveOrchestrationBatchEffects } from "../orchestrationEventEffects";	59	import { deriveOrchestrationBatchEffects } from "../orchestrationEventEffects";
49	import { createOrchestrationRecoveryCoordinator } from "../orchestrationRecovery";	60	import { createOrchestrationRecoveryCoordinator } from "../orchestrationRecovery";
50	import { deriveReplayRetryDecision } from "../orchestrationRecovery";	61	import { deriveReplayRetryDecision } from "../orchestrationRecovery";
51	import { getWsRpcClient } from "~/wsRpcClient";	62	import { selectThreadByRef } from "../store";
		63	import {
		64	bindPrimaryWsRpcClientEnvironment,
		65	bindWsRpcClientEntryEnvironment,
		66	getPrimaryWsRpcClientEntry,
		67	listWsRpcClientEntries,
		68	subscribeWsRpcClientRegistry,
		69	type WsRpcClientEntry,
		70	} from "~/wsRpcClient";
52		71
53	export const Route = createRootRouteWithContext<{	72	export const Route = createRootRouteWithContext<{
54	queryClient: QueryClient;	73	queryClient: QueryClient;
@@ -61,7 +80,7 @@ export const Route = createRootRouteWithContext<{ · 6 unmodified lines
61	});	80	});
62		81
63	function RootRouteView() {	82	function RootRouteView() {
64	if (!readNativeApi()) {	83	if (!readLocalApi()) {
65	return (	84	return (
66	<div className="flex h-screen flex-col bg-background text-foreground">	85	<div className="flex h-screen flex-col bg-background text-foreground">
67	<div className="flex flex-1 items-center justify-center">	86	<div className="flex flex-1 items-center justify-center">
@@ -201,14 +220,24 @@ function coalesceOrchestrationUiEvents( · 133 unmodified lines
201	const REPLAY_RECOVERY_RETRY_DELAY_MS = 100;	220	const REPLAY_RECOVERY_RETRY_DELAY_MS = 100;
202	const MAX_NO_PROGRESS_REPLAY_RETRIES = 3;	221	const MAX_NO_PROGRESS_REPLAY_RETRIES = 3;
203		222
		223	function useRegisteredWsRpcClientEntries(): ReadonlyArray<WsRpcClientEntry> {
		224	const [, setRevision] = useState(0);
		225
		226	useEffect(() => subscribeWsRpcClientRegistry(() => setRevision((value) => value + 1)), []);
		227
		228	const entries = listWsRpcClientEntries();
		229	return entries.length > 0 ? entries : [getPrimaryWsRpcClientEntry()];
		230	}
		231
204	function ServerStateBootstrap() {	232	function ServerStateBootstrap() {
205	useEffect(() => startServerStateSync(getWsRpcClient().server), []);	233	useEffect(() => startServerStateSync(getPrimaryWsRpcClientEntry().client.server), []);
206		234
207	return null;	235	return null;
208	}	236	}
209		237
210	function EventRouter() {	238	function EventRouter() {
211	const applyOrchestrationEvents = useStore((store) => store.applyOrchestrationEvents);	239	const applyOrchestrationEvents = useStore((store) => store.applyOrchestrationEvents);
		240	const setActiveEnvironmentId = useStore((store) => store.setActiveEnvironmentId);
212	const syncServerReadModel = useStore((store) => store.syncServerReadModel);	241	const syncServerReadModel = useStore((store) => store.syncServerReadModel);
213	const setProjectExpanded = useUiStateStore((store) => store.setProjectExpanded);	242	const setProjectExpanded = useUiStateStore((store) => store.setProjectExpanded);
214	const syncProjects = useUiStateStore((store) => store.syncProjects);	243	const syncProjects = useUiStateStore((store) => store.syncProjects);
@@ -226,15 +255,22 @@ function EventRouter() { · 11 unmodified lines
226	const handledBootstrapThreadIdRef = useRef<string \| null>(null);	255	const handledBootstrapThreadIdRef = useRef<string \| null>(null);
227	const seenServerConfigUpdateIdRef = useRef(getServerConfigUpdatedNotification()?.id ?? 0);	256	const seenServerConfigUpdateIdRef = useRef(getServerConfigUpdatedNotification()?.id ?? 0);
228	const disposedRef = useRef(false);	257	const disposedRef = useRef(false);
229	const bootstrapFromSnapshotRef = useRef<() => Promise<void>>(async () => undefined);	258	const bootstrapFromSnapshotRef = useRef<(environmentId: EnvironmentId) => Promise<void>>(
		259	async () => undefined,
		260	);
		261	const schedulePendingDomainEventFlushRef = useRef<() => void>(() => undefined);
230	const serverConfig = useServerConfig();	262	const serverConfig = useServerConfig();
		263	const clientEntries = useRegisteredWsRpcClientEntries();
231		264
232	const handleWelcome = useEffectEvent((payload: ServerLifecycleWelcomePayload \| null) => {	265	const handleWelcome = useEffectEvent((payload: ServerLifecycleWelcomePayload \| null) => {
233	if (!payload) return;	266	if (!payload) return;
234		267
		268	bindPrimaryWsRpcClientEnvironment(payload.environment.environmentId);
		269	setActiveEnvironmentId(payload.environment.environmentId);
		270	schedulePendingDomainEventFlushRef.current();
235	migrateLocalSettingsToServer();	271	migrateLocalSettingsToServer();
236	void (async () => {	272	void (async () => {
237	await bootstrapFromSnapshotRef.current();	273	await bootstrapFromSnapshotRef.current(payload.environment.environmentId);
238	if (disposedRef.current) {	274	if (disposedRef.current) {
239	return;	275	return;
240	}	276	}
@@ -242,7 +278,12 @@ function EventRouter() { · 1 unmodified line
242	if (!payload.bootstrapProjectId \|\| !payload.bootstrapThreadId) {	278	if (!payload.bootstrapProjectId \|\| !payload.bootstrapThreadId) {
243	return;	279	return;
244	}	280	}
245	setProjectExpanded(payload.bootstrapProjectId, true);	281	setProjectExpanded(
		282	scopedProjectKey(
		283	scopeProjectRef(payload.environment.environmentId, payload.bootstrapProjectId),
		284	),
		285	true,
		286	);
246		287
247	if (readPathname() !== "/") {	288	if (readPathname() !== "/") {
248	return;	289	return;
@@ -251,8 +292,11 @@ function EventRouter() { · 2 unmodified lines
251	return;	292	return;
252	}	293	}
253	await navigate({	294	await navigate({
254	to: "/$threadId",	295	to: "/$environmentId/$threadId",
255	params: { threadId: payload.bootstrapThreadId },	296	params: {
		297	environmentId: payload.environment.environmentId,
		298	threadId: payload.bootstrapThreadId,
		299	},
256	replace: true,	300	replace: true,
257	});	301	});
258	handledBootstrapThreadIdRef.current = payload.bootstrapThreadId;	302	handledBootstrapThreadIdRef.current = payload.bootstrapThreadId;
@@ -289,7 +333,7 @@ function EventRouter() { · 30 unmodified lines
289	actionProps: {	333	actionProps: {
290	children: "Open keybindings.json",	334	children: "Open keybindings.json",
291	onClick: () => {	335	onClick: () => {
292	const api = readNativeApi();	336	const api = readLocalApi();
293	if (!api) {	337	if (!api) {
294	return;	338	return;
295	}	339	}
@@ -317,40 +361,49 @@ function EventRouter() { · 21 unmodified lines
317	);	361	);
318		362
319	useEffect(() => {	363	useEffect(() => {
320	const api = readNativeApi();	364	if (!serverConfig) {
321	if (!api) return;	365	return;
		366	}
		367
		368	bindPrimaryWsRpcClientEnvironment(serverConfig.environment.environmentId);
		369	setActiveEnvironmentId(serverConfig.environment.environmentId);
		370	schedulePendingDomainEventFlushRef.current();
		371	}, [serverConfig, setActiveEnvironmentId]);
		372
		373	useEffect(() => {
322	let disposed = false;	374	let disposed = false;
323	disposedRef.current = false;	375	disposedRef.current = false;
324	const recovery = createOrchestrationRecoveryCoordinator();
325	let replayRetryTracker: import("../orchestrationRecovery").ReplayRetryTracker \| null = null;
326	let needsProviderInvalidation = false;	376	let needsProviderInvalidation = false;
327	const pendingDomainEvents: OrchestrationEvent[] = [];	377	const primaryClientKey = getPrimaryWsRpcClientEntry().key;
328	let flushPendingDomainEventsScheduled = false;
329		378
330	const reconcileSnapshotDerivedState = () => {	379	const reconcileSnapshotDerivedState = () => {
331	const storeState = useStore.getState();	380	const storeState = useStore.getState();
332	const threads = selectThreads(storeState);	381	const threads = selectThreadsAcrossEnvironments(storeState);
333	const projects = selectProjects(storeState);	382	const projects = selectProjectsAcrossEnvironments(storeState);
334	syncProjects(projects.map((project) => ({ id: project.id, cwd: project.cwd })));	383	syncProjects(
		384	projects.map((project) => ({
		385	key: scopedProjectKey(scopeProjectRef(project.environmentId, project.id)),
		386	cwd: project.cwd,
		387	})),
		388	);
335	syncThreads(	389	syncThreads(
336	threads.map((thread) => ({	390	threads.map((thread) => ({
337	id: thread.id,	391	key: scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
338	seedVisitedAt: thread.updatedAt ?? thread.createdAt,	392	seedVisitedAt: thread.updatedAt ?? thread.createdAt,
339	})),	393	})),
340	);	394	);
341	clearPromotedDraftThreads(threads.map((thread) => thread.id));	395	markPromotedDraftThreadsByRef(
342	const draftThreadIds = Object.keys(	396	threads.map((thread) => scopeThreadRef(thread.environmentId, thread.id)),
343	useComposerDraftStore.getState().draftThreadsByThreadId,	397	);
344	) as ThreadId[];	398	const activeThreadKeys = collectActiveTerminalThreadIds({
345	const activeThreadIds = collectActiveTerminalThreadIds({
346	snapshotThreads: threads.map((thread) => ({	399	snapshotThreads: threads.map((thread) => ({
347	id: thread.id,	400	key: scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
348	deletedAt: null,	401	deletedAt: null,
349	archivedAt: thread.archivedAt,	402	archivedAt: thread.archivedAt,
350	})),	403	})),
351	draftThreadIds,	404	draftThreadKeys: useComposerDraftStore.getState().listDraftThreadKeys(),
352	});	405	});
353	removeOrphanedTerminalStates(activeThreadIds);	406	removeOrphanedTerminalStates(activeThreadKeys);
354	};	407	};
355		408
356	const queryInvalidationThrottler = new Throttler(	409	const queryInvalidationThrottler = new Throttler(
@@ -371,7 +424,11 @@ function EventRouter() { · 14 unmodified lines
371	},	424	},
372	);	425	);
373		426
374	const applyEventBatch = (events: ReadonlyArray<OrchestrationEvent>) => {	427	const applyEventBatch = (
		428	events: ReadonlyArray<OrchestrationEvent>,
		429	environmentId: EnvironmentId,
		430	recovery: ReturnType<typeof createOrchestrationRecoveryCoordinator>,
		431	) => {
375	const nextEvents = recovery.markEventBatchApplied(events);	432	const nextEvents = recovery.markEventBatchApplied(events);
376	if (nextEvents.length === 0) {	433	if (nextEvents.length === 0) {
377	return;	434	return;
@@ -391,189 +448,284 @@ function EventRouter() { · 13 unmodified lines
391	void queryInvalidationThrottler.maybeExecute();	448	void queryInvalidationThrottler.maybeExecute();
392	}	449	}
393		450
394	applyOrchestrationEvents(uiEvents);	451	applyOrchestrationEvents(uiEvents, environmentId);
395	if (needsProjectUiSync) {	452	if (needsProjectUiSync) {
396	const projects = selectProjects(useStore.getState());	453	const projects = selectProjectsAcrossEnvironments(useStore.getState());
397	syncProjects(projects.map((project) => ({ id: project.id, cwd: project.cwd })));	454	syncProjects(
		455	projects.map((project) => ({
		456	key: scopedProjectKey(scopeProjectRef(project.environmentId, project.id)),
		457	cwd: project.cwd,
		458	})),
		459	);
398	}	460	}
399	const needsThreadUiSync = nextEvents.some(	461	const needsThreadUiSync = nextEvents.some(
400	(event) => event.type === "thread.created" \|\| event.type === "thread.deleted",	462	(event) => event.type === "thread.created" \|\| event.type === "thread.deleted",
401	);	463	);
402	if (needsThreadUiSync) {	464	if (needsThreadUiSync) {
403	const threads = selectThreads(useStore.getState());	465	const threads = selectThreadsAcrossEnvironments(useStore.getState());
404	syncThreads(	466	syncThreads(
405	threads.map((thread) => ({	467	threads.map((thread) => ({
406	id: thread.id,	468	key: scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
407	seedVisitedAt: thread.updatedAt ?? thread.createdAt,	469	seedVisitedAt: thread.updatedAt ?? thread.createdAt,
408	})),	470	})),
409	);	471	);
410	}	472	}
411	const draftStore = useComposerDraftStore.getState();	473	const draftStore = useComposerDraftStore.getState();
412	for (const threadId of batchEffects.clearPromotedDraftThreadIds) {	474	for (const threadId of batchEffects.promoteDraftThreadIds) {
413	clearPromotedDraftThread(threadId);	475	markPromotedDraftThreadByRef(scopeThreadRef(environmentId, threadId));
414	}	476	}
415	for (const threadId of batchEffects.clearDeletedThreadIds) {	477	for (const threadId of batchEffects.clearDeletedThreadIds) {
416	draftStore.clearDraftThread(threadId);	478	draftStore.clearDraftThread(scopeThreadRef(environmentId, threadId));
417	clearThreadUi(threadId);	479	clearThreadUi(scopedThreadKey(scopeThreadRef(environmentId, threadId)));
418	}	480	}
419	for (const threadId of batchEffects.removeTerminalStateThreadIds) {	481	for (const threadId of batchEffects.removeTerminalStateThreadIds) {
420	removeTerminalState(threadId);	482	removeTerminalState(scopeThreadRef(environmentId, threadId));
421	}	483	}
422	};	484	};
423	const flushPendingDomainEvents = () => {	485	const clientContexts = clientEntries.map((entry) => {
424	flushPendingDomainEventsScheduled = false;	486	const recovery = createOrchestrationRecoveryCoordinator();
425	if (disposed \|\| pendingDomainEvents.length === 0) {	487	let replayRetryTracker: import("../orchestrationRecovery").ReplayRetryTracker \| null = null;
426	return;	488	const pendingDomainEvents: OrchestrationEvent[] = [];
427	}	489	let flushPendingDomainEventsScheduled = false;
		490	let boundEnvironmentId = entry.environmentId;
		491
		492	const bindEnvironmentId = (environmentId: EnvironmentId) => {
		493	if (boundEnvironmentId === environmentId) {
		494	return;
		495	}
		496	boundEnvironmentId = environmentId;
		497	bindWsRpcClientEntryEnvironment(entry.key, environmentId);
		498	schedulePendingDomainEventFlush();
		499	};
428		500
429	const events = pendingDomainEvents.splice(0, pendingDomainEvents.length);	501	const flushPendingDomainEvents = () => {
430	applyEventBatch(events);	502	flushPendingDomainEventsScheduled = false;
431	};	503	if (disposed \|\| pendingDomainEvents.length === 0 \|\| boundEnvironmentId === null) {
432	const schedulePendingDomainEventFlush = () => {	504	return;
433	if (flushPendingDomainEventsScheduled) {	505	}
434	return;
435	}
436		506
437	flushPendingDomainEventsScheduled = true;	507	const events = pendingDomainEvents.splice(0, pendingDomainEvents.length);
438	queueMicrotask(flushPendingDomainEvents);	508	applyEventBatch(events, boundEnvironmentId, recovery);
439	};	509	};
440		510
441	const runReplayRecovery = async (reason: "sequence-gap" \| "resubscribe"): Promise<void> => {	511	const schedulePendingDomainEventFlush = () => {
442	if (!recovery.beginReplayRecovery(reason)) {	512	if (flushPendingDomainEventsScheduled) {
443	return;	513	return;
444	}	514	}
445		515
446	const fromSequenceExclusive = recovery.getState().latestSequence;	516	flushPendingDomainEventsScheduled = true;
447	try {	517	queueMicrotask(flushPendingDomainEvents);
448	const events = await api.orchestration.replayEvents(fromSequenceExclusive);	518	};
449	if (!disposed) {	519
450	applyEventBatch(events);	520	const runSnapshotRecovery = async (
		521	reason: "bootstrap" \| "replay-failed",
		522	environmentId: EnvironmentId,
		523	): Promise<void> => {
		524	const started = recovery.beginSnapshotRecovery(reason);
		525	if (import.meta.env.MODE !== "test") {
		526	const state = recovery.getState();
		527	console.info("[orchestration-recovery]", "Snapshot recovery requested.", {
		528	reason,
		529	clientKey: entry.key,
		530	environmentId,
		531	skipped: !started,
		532	...(started
		533	? {}
		534	: {
		535	blockedBy: state.inFlight?.kind ?? null,
		536	blockedByReason: state.inFlight?.reason ?? null,
		537	}),
		538	state,
		539	});
		540	}
		541	if (!started) {
		542	return;
451	}	543	}
452	} catch {
453	replayRetryTracker = null;
454	recovery.failReplayRecovery();
455	void fallbackToSnapshotRecovery();
456	return;
457	}
458		544
459	if (!disposed) {	545	try {
460	const replayCompletion = recovery.completeReplayRecovery();	546	const snapshot = await entry.client.orchestration.getSnapshot();
461	const retryDecision = deriveReplayRetryDecision({	547	if (!disposed) {
462	previousTracker: replayRetryTracker,	548	bindEnvironmentId(environmentId);
463	completion: replayCompletion,	549	syncServerReadModel(snapshot, environmentId);
464	recoveryState: recovery.getState(),	550	reconcileSnapshotDerivedState();
465	baseDelayMs: REPLAY_RECOVERY_RETRY_DELAY_MS,	551	if (recovery.completeSnapshotRecovery(snapshot.snapshotSequence)) {
466	maxNoProgressRetries: MAX_NO_PROGRESS_REPLAY_RETRIES,	552	void runReplayRecovery("sequence-gap");
467	});	553	}
468	replayRetryTracker = retryDecision.tracker;	554	}
		555	} catch {
		556	recovery.failSnapshotRecovery();
		557	}
		558	};
469		559
470	if (retryDecision.shouldRetry) {	560	const fallbackToSnapshotRecovery = async (): Promise<void> => {
471	if (retryDecision.delayMs > 0) {	561	if (boundEnvironmentId === null) {
472	await new Promise<void>((resolve) => {	562	return;
473	setTimeout(resolve, retryDecision.delayMs);	563	}
474	});	564	await runSnapshotRecovery("replay-failed", boundEnvironmentId);
475	if (disposed) {	565	};
		566
		567	const runReplayRecovery = async (reason: "sequence-gap" \| "resubscribe"): Promise<void> => {
		568	if (!recovery.beginReplayRecovery(reason)) {
		569	return;
		570	}
		571
		572	const fromSequenceExclusive = recovery.getState().latestSequence;
		573	try {
		574	const events = await entry.client.orchestration.replayEvents({ fromSequenceExclusive });
		575	if (!disposed) {
		576	if (boundEnvironmentId === null) {
		577	replayRetryTracker = null;
		578	recovery.failReplayRecovery();
476	return;	579	return;
477	}	580	}
		581	applyEventBatch(events, boundEnvironmentId, recovery);
478	}	582	}
479	void runReplayRecovery(reason);	583	} catch {
480	} else if (replayCompletion.shouldReplay && import.meta.env.MODE !== "test") {	584	replayRetryTracker = null;
481	console.warn(	585	recovery.failReplayRecovery();
482	"[orchestration-recovery]",	586	void fallbackToSnapshotRecovery();
483	"Stopping replay recovery after no-progress retries.",	587	return;
484	{
485	state: recovery.getState(),
486	},
487	);
488	}	588	}
489	}
490	};
491
492	const runSnapshotRecovery = async (reason: "bootstrap" \| "replay-failed"): Promise<void> => {
493	const started = recovery.beginSnapshotRecovery(reason);
494	if (import.meta.env.MODE !== "test") {
495	const state = recovery.getState();
496	console.info("[orchestration-recovery]", "Snapshot recovery requested.", {
497	reason,
498	skipped: !started,
499	...(started
500	? {}
501	: {
502	blockedBy: state.inFlight?.kind ?? null,
503	blockedByReason: state.inFlight?.reason ?? null,
504	}),
505	state,
506	});
507	}
508	if (!started) {
509	return;
510	}
511		589
512	try {
513	const snapshot = await api.orchestration.getSnapshot();
514	if (!disposed) {	590	if (!disposed) {
515	syncServerReadModel(snapshot);	591	const replayCompletion = recovery.completeReplayRecovery();
516	reconcileSnapshotDerivedState();	592	const retryDecision = deriveReplayRetryDecision({
517	if (recovery.completeSnapshotRecovery(snapshot.snapshotSequence)) {	593	previousTracker: replayRetryTracker,
518	void runReplayRecovery("sequence-gap");	594	completion: replayCompletion,
		595	recoveryState: recovery.getState(),
		596	baseDelayMs: REPLAY_RECOVERY_RETRY_DELAY_MS,
		597	maxNoProgressRetries: MAX_NO_PROGRESS_REPLAY_RETRIES,
		598	});
		599	replayRetryTracker = retryDecision.tracker;
		600
		601	if (retryDecision.shouldRetry) {
		602	if (retryDecision.delayMs > 0) {
		603	await new Promise<void>((resolve) => {
		604	setTimeout(resolve, retryDecision.delayMs);
		605	});
		606	if (disposed) {
		607	return;
		608	}
		609	}
		610	void runReplayRecovery(reason);
		611	} else if (replayCompletion.shouldReplay && import.meta.env.MODE !== "test") {
		612	console.warn(
		613	"[orchestration-recovery]",
		614	"Stopping replay recovery after no-progress retries.",
		615	{
		616	clientKey: entry.key,
		617	environmentId: boundEnvironmentId,
		618	state: recovery.getState(),
		619	},
		620	);
519	}	621	}
520	}	622	}
521	} catch {	623	};
522	// Keep prior state and wait for welcome or a later replay attempt.
523	recovery.failSnapshotRecovery();
524	}
525	};
526
527	const bootstrapFromSnapshot = async (): Promise<void> => {
528	await runSnapshotRecovery("bootstrap");
529	};
530	bootstrapFromSnapshotRef.current = bootstrapFromSnapshot;
531		624
532	const fallbackToSnapshotRecovery = async (): Promise<void> => {	625	const unsubLifecycle = entry.client.server.subscribeLifecycle((event) => {
533	await runSnapshotRecovery("replay-failed");	626	if (event.type === "welcome") {
534	};	627	bindEnvironmentId(event.payload.environment.environmentId);
535	const unsubDomainEvent = api.orchestration.onDomainEvent(
536	(event) => {
537	const action = recovery.classifyDomainEvent(event.sequence);
538	if (action === "apply") {
539	pendingDomainEvents.push(event);
540	schedulePendingDomainEventFlush();
541	return;
542	}	628	}
543	if (action === "recover") {	629	});
544	flushPendingDomainEvents();	630	const unsubConfig = entry.client.server.subscribeConfig((event) => {
545	void runReplayRecovery("sequence-gap");	631	if (event.type === "snapshot") {
		632	bindEnvironmentId(event.config.environment.environmentId);
546	}	633	}
547	},	634	});
548	{	635	if (boundEnvironmentId === null) {
549	onResubscribe: () => {	636	void entry.client.server
550	if (disposed) {	637	.getConfig()
		638	.then((config) => {
		639	if (!disposed) {
		640	bindEnvironmentId(config.environment.environmentId);
		641	}
		642	})
		643	.catch(() => undefined);
		644	}
		645	const unsubDomainEvent = entry.client.orchestration.onDomainEvent(
		646	(event) => {
		647	const action = recovery.classifyDomainEvent(event.sequence);
		648	if (action === "apply") {
		649	pendingDomainEvents.push(event);
		650	schedulePendingDomainEventFlush();
551	return;	651	return;
552	}	652	}
553	flushPendingDomainEvents();	653	if (action === "recover") {
554	void runReplayRecovery("resubscribe");	654	flushPendingDomainEvents();
		655	void runReplayRecovery("sequence-gap");
		656	}
555	},	657	},
556	},	658	{
557	);	659	onResubscribe: () => {
558	const unsubTerminalEvent = api.terminal.onEvent((event) => {	660	if (disposed) {
559	const thread = selectThreadById(ThreadId.makeUnsafe(event.threadId))(useStore.getState());	661	return;
560	if (thread && thread.archivedAt !== null) {	662	}
		663	flushPendingDomainEvents();
		664	void runReplayRecovery("resubscribe");
		665	},
		666	},
		667	);
		668	const unsubTerminalEvent = entry.client.terminal.onEvent((event) => {
		669	if (boundEnvironmentId === null) {
		670	return;
		671	}
		672
		673	const threadRef = scopeThreadRef(boundEnvironmentId, ThreadId.makeUnsafe(event.threadId));
		674	const thread = selectThreadByRef(useStore.getState(), threadRef);
		675	if (!thread \|\| thread.archivedAt !== null) {
		676	return;
		677	}
		678	applyTerminalEvent(threadRef, event);
		679	});
		680
		681	return {
		682	key: entry.key,
		683	bindEnvironmentId,
		684	flushPendingDomainEvents,
		685	schedulePendingDomainEventFlush,
		686	runSnapshotRecovery,
		687	cleanup: () => {
		688	flushPendingDomainEventsScheduled = false;
		689	pendingDomainEvents.length = 0;
		690	unsubDomainEvent();
		691	unsubTerminalEvent();
		692	unsubLifecycle();
		693	unsubConfig();
		694	},
		695	};
		696	});
		697
		698	schedulePendingDomainEventFlushRef.current = () => {
		699	for (const context of clientContexts) {
		700	context.schedulePendingDomainEventFlush();
		701	}
		702	};
		703
		704	const primaryClientContext =
		705	clientContexts.find((context) => context.key === primaryClientKey) ??
		706	clientContexts[0] ??
		707	null;
		708	bootstrapFromSnapshotRef.current = async (environmentId: EnvironmentId) => {
		709	if (!primaryClientContext) {
561	return;	710	return;
562	}	711	}
563	applyTerminalEvent(event);	712	primaryClientContext.bindEnvironmentId(environmentId);
564	});	713	await primaryClientContext.runSnapshotRecovery("bootstrap", environmentId);
		714	};
		715
565	return () => {	716	return () => {
566	disposed = true;	717	disposed = true;
567	disposedRef.current = true;	718	disposedRef.current = true;
568	needsProviderInvalidation = false;	719	needsProviderInvalidation = false;
569	flushPendingDomainEventsScheduled = false;	720	schedulePendingDomainEventFlushRef.current = () => undefined;
570	pendingDomainEvents.length = 0;
571	queryInvalidationThrottler.cancel();	721	queryInvalidationThrottler.cancel();
572	unsubDomainEvent();	722	for (const context of clientContexts) {
573	unsubTerminalEvent();	723	context.cleanup();
		724	}
574	};	725	};
575	}, [	726	}, [
576	applyOrchestrationEvents,	727	applyOrchestrationEvents,
		728	clientEntries,
577	navigate,	729	navigate,
578	queryClient,	730	queryClient,
579	removeTerminalState,	731	removeTerminalState,
@@ -581,6 +733,7 @@ function EventRouter() { · 1 unmodified line
581	applyTerminalEvent,	733	applyTerminalEvent,
582	clearThreadUi,	734	clearThreadUi,
583	setProjectExpanded,	735	setProjectExpanded,
		736	setActiveEnvironmentId,
584	syncProjects,	737	syncProjects,
585	syncServerReadModel,	738	syncServerReadModel,
586	syncThreads,	739	syncThreads,

apps/web/src/routes/_chat.$environmentId.$threadId.tsxrenamed from apps/web/src/routes/_chat.$threadId.tsx+61−24

-import { ThreadId } from "@t3tools/contracts";
 import { createFileRoute, retainSearchParams, useNavigate } from "@tanstack/react-router";
-import { Suspense, lazy, type ReactNode, useCallback, useEffect, useState } from "react";
+import { Suspense, lazy, type ReactNode, useCallback, useEffect, useMemo, useState } from "react";
 import ChatView from "../components/ChatView";
+import { threadHasStarted } from "../components/ChatView.logic";
 import { DiffWorkerPoolProvider } from "../components/DiffWorkerPoolProvider";
 import {
   DiffPanelHeaderSkeleton,
   DiffPanelShell,
   type DiffPanelMode,
 } from "../components/DiffPanelShell";
-import { useComposerDraftStore } from "../composerDraftStore";
+import { finalizePromotedDraftThreadByRef, useComposerDraftStore } from "../composerDraftStore";
 import {
   type DiffRouteSearch,
   parseDiffRouteSearch,
   stripDiffSearchParams,
 } from "../diffRouteSearch";
 import { useMediaQuery } from "../hooks/useMediaQuery";
-import { useStore } from "../store";
+import { selectEnvironmentState, selectThreadByRef, useStore } from "../store";
+import { createThreadSelectorByRef } from "../storeSelectors";
+import { resolveThreadRouteRef, buildThreadRouteParams } from "../threadRoutes";
 import { Sheet, SheetPopup } from "../components/ui/sheet";
 import { Sidebar, SidebarInset, SidebarProvider, SidebarRail } from "~/components/ui/sidebar";
 };
 function ChatThreadRouteView() {
-  const bootstrapComplete = useStore((store) => store.bootstrapComplete);
   const navigate = useNavigate();
-  const threadId = Route.useParams({
+  const threadRef = Route.useParams({
-    select: (params) => ThreadId.makeUnsafe(params.threadId),
+    select: (params) => resolveThreadRouteRef(params),
   });
   const search = Route.useSearch();
-  const threadExists = useStore((store) => store.threadShellById[threadId] !== undefined);
+  const bootstrapComplete = useStore(
+    (store) => selectEnvironmentState(store, threadRef?.environmentId ?? null).bootstrapComplete,
+  );
+  const serverThread = useStore(useMemo(() => createThreadSelectorByRef(threadRef), [threadRef]));
+  const threadExists = useStore((store) => selectThreadByRef(store, threadRef) !== undefined);
+  const environmentHasServerThreads = useStore(
+    (store) => selectEnvironmentState(store, threadRef?.environmentId ?? null).threadIds.length > 0,
+  );
   const draftThreadExists = useComposerDraftStore((store) =>
-    Object.hasOwn(store.draftThreadsByThreadId, threadId),
+    threadRef ? store.getDraftThreadByRef(threadRef) !== null : false,
   );
+  const draftThread = useComposerDraftStore((store) =>
+    threadRef ? store.getDraftThreadByRef(threadRef) : null,
+  );
+  const environmentHasDraftThreads = useComposerDraftStore((store) => {
+    if (!threadRef) {
+      return false;
+    }
+    return store.hasDraftThreadsInEnvironment(threadRef.environmentId);
+  });
   const routeThreadExists = threadExists || draftThreadExists;
+  const serverThreadStarted = threadHasStarted(serverThread);
+  const environmentHasAnyThreads = environmentHasServerThreads || environmentHasDraftThreads;
   const diffOpen = search.diff === "1";
   const shouldUseDiffSheet = useMediaQuery(DIFF_INLINE_LAYOUT_MEDIA_QUERY);
-  // TanStack Router keeps active route components mounted across param-only navigations
-  // unless remountDeps are configured, so this stays warm across thread switches.
   const [hasOpenedDiff, setHasOpenedDiff] = useState(diffOpen);
   const closeDiff = useCallback(() => {
+    if (!threadRef) {
+      return;
+    }
     void navigate({
-      to: "/$threadId",
+      to: "/$environmentId/$threadId",
-      params: { threadId },
+      params: buildThreadRouteParams(threadRef),
       search: { diff: undefined },
     });
-  }, [navigate, threadId]);
+  }, [navigate, threadRef]);
   const openDiff = useCallback(() => {
+    if (!threadRef) {
+      return;
+    }
     void navigate({
-      to: "/$threadId",
+      to: "/$environmentId/$threadId",
-      params: { threadId },
+      params: buildThreadRouteParams(threadRef),
       search: (previous) => {
         const rest = stripDiffSearchParams(previous);
         return { ...rest, diff: "1" };
       },
     });
-  }, [navigate, threadId]);
+  }, [navigate, threadRef]);
   useEffect(() => {
     if (diffOpen) {
   }, [diffOpen]);
   useEffect(() => {
-    if (!bootstrapComplete) {
+    if (!threadRef || !bootstrapComplete) {
       return;
     }
-    if (!routeThreadExists) {
+    if (!routeThreadExists && environmentHasAnyThreads) {
       void navigate({ to: "/", replace: true });
+    }
+  }, [bootstrapComplete, environmentHasAnyThreads, navigate, routeThreadExists, threadRef]);
+  useEffect(() => {
+    if (!threadRef || !serverThreadStarted || !draftThread?.promotedTo) {
       return;
     }
-  }, [bootstrapComplete, navigate, routeThreadExists, threadId]);
+    finalizePromotedDraftThreadByRef(threadRef);
+  }, [draftThread?.promotedTo, serverThreadStarted, threadRef]);
-  if (!bootstrapComplete || !routeThreadExists) {
+  if (!threadRef || !bootstrapComplete || !routeThreadExists) {
     return null;
   }
     return (
       <>
         <SidebarInset className="h-dvh  min-h-0 overflow-hidden overscroll-y-none bg-background text-foreground">
-          <ChatView threadId={threadId} />
+          <ChatView
+            environmentId={threadRef.environmentId}
+            threadId={threadRef.threadId}
+            routeKind="server"
+          />
         </SidebarInset>
         <DiffPanelInlineSidebar
           diffOpen={diffOpen}
   return (
     <>
       <SidebarInset className="h-dvh min-h-0 overflow-hidden overscroll-y-none bg-background text-foreground">
-        <ChatView threadId={threadId} />
+        <ChatView
+          environmentId={threadRef.environmentId}
+          threadId={threadRef.threadId}
+          routeKind="server"
+        />
       </SidebarInset>
       <DiffPanelSheet diffOpen={diffOpen} onCloseDiff={closeDiff}>
         {shouldRenderDiffContent ? <LazyDiffPanel mode="sheet" /> : null}
   );
 }
-export const Route = createFileRoute("/_chat/$threadId")({
+export const Route = createFileRoute("/_chat/$environmentId/$threadId")({
   validateSearch: (search) => parseDiffRouteSearch(search),
   search: {
     middlewares: [retainSearchParams<DiffRouteSearch>(["diff"])],

apps/web/src/routes/_chat.draft.$draftId.tsx+86−0

@@ -0,0 +1,86 @@
	1	import { createFileRoute, useNavigate } from "@tanstack/react-router";
	2	import { useEffect, useMemo } from "react";
	3	import ChatView from "../components/ChatView";
	4	import { threadHasStarted } from "../components/ChatView.logic";
	5	import { useComposerDraftStore, DraftId } from "../composerDraftStore";
	6	import { SidebarInset } from "../components/ui/sidebar";
	7	import { createThreadSelectorAcrossEnvironments } from "../storeSelectors";
	8	import { useStore } from "../store";
	9	import { buildThreadRouteParams } from "../threadRoutes";
	10
	11	function DraftChatThreadRouteView() {
	12	const navigate = useNavigate();
	13	const { draftId: rawDraftId } = Route.useParams();
	14	const draftId = DraftId.makeUnsafe(rawDraftId);
	15	const draftSession = useComposerDraftStore((store) => store.getDraftSession(draftId));
	16	const serverThread = useStore(
	17	useMemo(
	18	() => createThreadSelectorAcrossEnvironments(draftSession?.threadId ?? null),
	19	[draftSession?.threadId],
	20	),
	21	);
	22	const serverThreadStarted = threadHasStarted(serverThread);
	23	const canonicalThreadRef = useMemo(
	24	() =>
	25	draftSession?.promotedTo
	26	? serverThreadStarted
	27	? draftSession.promotedTo
	28	: null
	29	: serverThread
	30	? {
	31	environmentId: serverThread.environmentId,
	32	threadId: serverThread.id,
	33	}
	34	: null,
	35	[draftSession?.promotedTo, serverThread, serverThreadStarted],
	36	);
	37
	38	useEffect(() => {
	39	if (!canonicalThreadRef) {
	40	return;
	41	}
	42	void navigate({
	43	to: "/$environmentId/$threadId",
	44	params: buildThreadRouteParams(canonicalThreadRef),
	45	replace: true,
	46	});
	47	}, [canonicalThreadRef, navigate]);
	48
	49	useEffect(() => {
	50	if (draftSession \|\| canonicalThreadRef) {
	51	return;
	52	}
	53	void navigate({ to: "/", replace: true });
	54	}, [canonicalThreadRef, draftSession, navigate]);
	55
	56	if (canonicalThreadRef) {
	57	return (
	58	<SidebarInset className="h-dvh min-h-0 overflow-hidden overscroll-y-none bg-background text-foreground">
	59	<ChatView
	60	environmentId={canonicalThreadRef.environmentId}
	61	threadId={canonicalThreadRef.threadId}
	62	routeKind="server"
	63	/>
	64	</SidebarInset>
	65	);
	66	}
	67
	68	if (!draftSession) {
	69	return null;
	70	}
	71
	72	return (
	73	<SidebarInset className="h-dvh min-h-0 overflow-hidden overscroll-y-none bg-background text-foreground">
	74	<ChatView
	75	draftId={draftId}
	76	environmentId={draftSession.environmentId}
	77	threadId={draftSession.threadId}
	78	routeKind="draft"
	79	/>
	80	</SidebarInset>
	81	);
	82	}
	83
	84	export const Route = createFileRoute("/_chat/draft/$draftId")({
	85	component: DraftChatThreadRouteView,
	86	});

apps/web/src/routes/_chat.tsx+17−11

+import { scopeProjectRef } from "@t3tools/client-runtime";
 import { Outlet, createFileRoute } from "@tanstack/react-router";
 import { useEffect } from "react";
 function ChatRouteGlobalShortcuts() {
   const clearSelection = useThreadSelectionStore((state) => state.clearSelection);
-  const selectedThreadIdsSize = useThreadSelectionStore((state) => state.selectedThreadIds.size);
+  const selectedThreadKeysSize = useThreadSelectionStore((state) => state.selectedThreadKeys.size);
-  const { activeDraftThread, activeThread, defaultProjectId, handleNewThread, routeThreadId } =
+  const { activeDraftThread, activeThread, defaultProjectRef, handleNewThread, routeThreadRef } =
     useHandleNewThread();
   const keybindings = useServerKeybindings();
   const terminalOpen = useTerminalStateStore((state) =>
-    routeThreadId
+    routeThreadRef
-      ? selectThreadTerminalState(state.terminalStateByThreadId, routeThreadId).terminalOpen
+      ? selectThreadTerminalState(state.terminalStateByThreadKey, routeThreadRef).terminalOpen
       : false,
   );
   const appSettings = useSettings();
     const onWindowKeyDown = (event: KeyboardEvent) => {
       if (event.defaultPrevented) return;
-      if (event.key === "Escape" && selectedThreadIdsSize > 0) {
+      if (event.key === "Escape" && selectedThreadKeysSize > 0) {
         event.preventDefault();
         clearSelection();
         return;
       }
-      const projectId = activeThread?.projectId ?? activeDraftThread?.projectId ?? defaultProjectId;
+      const projectRef = activeThread
-      if (!projectId) return;
+        ? scopeProjectRef(activeThread.environmentId, activeThread.projectId)
+        : activeDraftThread && routeThreadRef
+          ? scopeProjectRef(routeThreadRef.environmentId, activeDraftThread.projectId)
+          : defaultProjectRef;
+      if (!projectRef) return;
       const command = resolveShortcutCommand(event, keybindings, {
         context: {
       if (command === "chat.newLocal") {
         event.preventDefault();
         event.stopPropagation();
-        void handleNewThread(projectId, {
+        void handleNewThread(projectRef, {
           envMode: resolveSidebarNewThreadEnvMode({
             defaultEnvMode: appSettings.defaultThreadEnvMode,
           }),
       if (command === "chat.new") {
         event.preventDefault();
         event.stopPropagation();
-        void handleNewThread(projectId, {
+        void handleNewThread(projectRef, {
           branch: activeThread?.branch ?? activeDraftThread?.branch ?? null,
           worktreePath: activeThread?.worktreePath ?? activeDraftThread?.worktreePath ?? null,
           envMode:
     clearSelection,
     handleNewThread,
     keybindings,
-    defaultProjectId,
+    defaultProjectRef,
-    selectedThreadIdsSize,
+    routeThreadRef,
+    selectedThreadKeysSize,
     terminalOpen,
     appSettings.defaultThreadEnvMode,
   ]);

apps/web/src/rpc/serverState.test.ts+18−0

 import {
   DEFAULT_SERVER_SETTINGS,
+  EnvironmentId,
   ProjectId,
   ThreadId,
   type ServerConfig,
   },
 ];
+const baseEnvironment = {
+  environmentId: EnvironmentId.makeUnsafe("environment-local"),
+  label: "Local environment",
+  platform: {
+    os: "darwin" as const,
+    arch: "arm64" as const,
+  },
+  serverVersion: "0.0.0-test",
+  capabilities: {
+    repositoryIdentity: true,
+  },
+};
 const baseServerConfig: ServerConfig = {
+  environment: baseEnvironment,
   cwd: "/tmp/workspace",
   keybindingsConfigPath: "/tmp/workspace/.config/keybindings.json",
   keybindings: [],
       sequence: 1,
       type: "welcome",
       payload: {
+        environment: baseEnvironment,
         cwd: "/tmp/workspace",
         projectName: "t3-code",
         bootstrapProjectId: ProjectId.makeUnsafe("project-1"),
     });
     expect(listener).toHaveBeenCalledWith({
+      environment: baseEnvironment,
       cwd: "/tmp/workspace",
       projectName: "t3-code",
       bootstrapProjectId: ProjectId.makeUnsafe("project-1"),
     const lateListener = vi.fn();
     const unsubscribeLate = onWelcome(lateListener);
     expect(lateListener).toHaveBeenCalledWith({
+      environment: baseEnvironment,
       cwd: "/tmp/workspace",
       projectName: "t3-code",
       bootstrapProjectId: ProjectId.makeUnsafe("project-1"),

apps/web/src/store.test.ts+166−105

 import {
   CheckpointRef,
   DEFAULT_MODEL_BY_PROVIDER,
+  EnvironmentId,
   EventId,
   MessageId,
   ProjectId,
 import {
   applyOrchestrationEvent,
   applyOrchestrationEvents,
-  selectProjects,
+  selectEnvironmentState,
-  selectThreads,
+  selectProjectsAcrossEnvironments,
+  selectThreadsAcrossEnvironments,
   syncServerReadModel,
   type AppState,
+  type EnvironmentState,
 } from "./store";
 import { DEFAULT_INTERACTION_MODE, DEFAULT_RUNTIME_MODE, type Thread } from "./types";
+const localEnvironmentId = EnvironmentId.makeUnsafe("environment-local");
+function withActiveEnvironmentState(
+  environmentState: EnvironmentState,
+  overrides: Partial<AppState & EnvironmentState> = {},
+): AppState {
+  const {
+    activeEnvironmentId: overrideActiveEnvironmentId,
+    environmentStateById: overrideEnvironmentStateById,
+    ...environmentOverrides
+  } = overrides;
+  const activeEnvironmentId = overrideActiveEnvironmentId ?? localEnvironmentId;
+  const mergedEnvironmentState = {
+    ...environmentState,
+    ...environmentOverrides,
+  };
+  const environmentStateById =
+    overrideEnvironmentStateById ??
+    (activeEnvironmentId
+      ? {
+          [activeEnvironmentId]: mergedEnvironmentState,
+        }
+      : {});
+  return {
+    activeEnvironmentId,
+    environmentStateById,
+  };
+}
 function makeThread(overrides: Partial<Thread> = {}): Thread {
   return {
     id: ThreadId.makeUnsafe("thread-1"),
+    environmentId: localEnvironmentId,
     codexThreadId: null,
     projectId: ProjectId.makeUnsafe("project-1"),
     title: "Thread",
   const projectId = ProjectId.makeUnsafe("project-1");
   const project = {
     id: projectId,
+    environmentId: localEnvironmentId,
     name: "Project",
     cwd: "/tmp/project",
     defaultModelSelection: {
     updatedAt: "2026-02-13T00:00:00.000Z",
     scripts: [],
   };
-  const threadIdsByProjectId: AppState["threadIdsByProjectId"] = {
+  const threadIdsByProjectId: EnvironmentState["threadIdsByProjectId"] = {
     [thread.projectId]: [thread.id],
   };
-  return {
+  const environmentState = {
     projectIds: [projectId],
     projectById: {
       [projectId]: project,
     threadShellById: {
       [thread.id]: {
         id: thread.id,
+        environmentId: thread.environmentId,
         codexThreadId: thread.codexThreadId,
         projectId: thread.projectId,
         title: thread.title,
     messageByThreadId: {
       [thread.id]: Object.fromEntries(
         thread.messages.map((message) => [message.id, message] as const),
-      ) as AppState["messageByThreadId"][ThreadId],
+      ) as EnvironmentState["messageByThreadId"][ThreadId],
     },
     activityIdsByThreadId: {
       [thread.id]: thread.activities.map((activity) => activity.id),
     activityByThreadId: {
       [thread.id]: Object.fromEntries(
         thread.activities.map((activity) => [activity.id, activity] as const),
-      ) as AppState["activityByThreadId"][ThreadId],
+      ) as EnvironmentState["activityByThreadId"][ThreadId],
     },
     proposedPlanIdsByThreadId: {
       [thread.id]: thread.proposedPlans.map((plan) => plan.id),
     proposedPlanByThreadId: {
       [thread.id]: Object.fromEntries(
         thread.proposedPlans.map((plan) => [plan.id, plan] as const),
-      ) as AppState["proposedPlanByThreadId"][ThreadId],
+      ) as EnvironmentState["proposedPlanByThreadId"][ThreadId],
     },
     turnDiffIdsByThreadId: {
       [thread.id]: thread.turnDiffSummaries.map((summary) => summary.turnId),
     turnDiffSummaryByThreadId: {
       [thread.id]: Object.fromEntries(
         thread.turnDiffSummaries.map((summary) => [summary.turnId, summary] as const),
-      ) as AppState["turnDiffSummaryByThreadId"][ThreadId],
+      ) as EnvironmentState["turnDiffSummaryByThreadId"][ThreadId],
     },
     sidebarThreadSummaryById: {},
     bootstrapComplete: true,
   };
+  return withActiveEnvironmentState(environmentState);
 }
-function makeEmptyState(overrides: Partial<AppState> = {}): AppState {
+function makeEmptyState(overrides: Partial<AppState & EnvironmentState> = {}): AppState {
-  return {
+  const environmentState: EnvironmentState = {
     projectIds: [],
     projectById: {},
     threadIds: [],
     turnDiffSummaryByThreadId: {},
     sidebarThreadSummaryById: {},
     bootstrapComplete: true,
-    ...overrides,
   };
+  return withActiveEnvironmentState(environmentState, overrides);
+}
+function localEnvironmentStateOf(state: AppState): EnvironmentState {
+  return selectEnvironmentState(state, localEnvironmentId);
 }
 function projectsOf(state: AppState) {
-  return selectProjects(state);
+  return selectProjectsAcrossEnvironments(state);
 }
 function threadsOf(state: AppState) {
-  return selectThreads(state);
+  return selectThreadsAcrossEnvironments(state);
 }
 function makeEvent<T extends OrchestrationEvent["type"]>(
 describe("store read model sync", () => {
   it("marks bootstrap complete after snapshot sync", () => {
-    const initialState: AppState = {
+    const initialState = withActiveEnvironmentState(
-      ...makeState(makeThread()),
+      localEnvironmentStateOf(makeState(makeThread())),
-      bootstrapComplete: false,
+      {
-    };
+        bootstrapComplete: false,
+      },
+    );
-    const next = syncServerReadModel(initialState, makeReadModel(makeReadModelThread({})));
+    const next = syncServerReadModel(
+      initialState,
+      makeReadModel(makeReadModelThread({})),
+      localEnvironmentId,
+    );
-    expect(next.bootstrapComplete).toBe(true);
+    expect(localEnvironmentStateOf(next).bootstrapComplete).toBe(true);
   });
   it("preserves claude model slugs without an active session", () => {
       }),
     );
-    const next = syncServerReadModel(initialState, readModel);
+    const next = syncServerReadModel(initialState, readModel, localEnvironmentId);
     expect(threadsOf(next)[0]?.modelSelection.model).toBe("claude-opus-4-6");
   });
       }),
     );
-    const next = syncServerReadModel(initialState, readModel);
+    const next = syncServerReadModel(initialState, readModel, localEnvironmentId);
     expect(threadsOf(next)[0]?.modelSelection.model).toBe("claude-sonnet-4-6");
   });
       }),
     );
-    const next = syncServerReadModel(initialState, readModel);
+    const next = syncServerReadModel(initialState, readModel, localEnvironmentId);
     expect(projectsOf(next)[0]?.updatedAt).toBe("2026-02-27T00:00:00.000Z");
     expect(threadsOf(next)[0]?.updatedAt).toBe("2026-02-27T00:05:00.000Z");
           archivedAt,
         }),
       ),
+      localEnvironmentId,
     );
     expect(threadsOf(next)[0]?.archivedAt).toBe(archivedAt);
       projectById: {
         [project2]: {
           id: project2,
+          environmentId: localEnvironmentId,
           name: "Project 2",
           cwd: "/tmp/project-2",
           defaultModelSelection: {
         },
         [project1]: {
           id: project1,
+          environmentId: localEnvironmentId,
           name: "Project 1",
           cwd: "/tmp/project-1",
           defaultModelSelection: {
       threads: [],
     };
-    const next = syncServerReadModel(initialState, readModel);
+    const next = syncServerReadModel(initialState, readModel, localEnvironmentId);
     expect(projectsOf(next).map((project) => project.id)).toEqual([project1, project2, project3]);
   });
 describe("incremental orchestration updates", () => {
   it("does not mark bootstrap complete for incremental events", () => {
-    const state: AppState = {
+    const state = withActiveEnvironmentState(localEnvironmentStateOf(makeState(makeThread())), {
-      ...makeState(makeThread()),
       bootstrapComplete: false,
-    };
+    });
     const next = applyOrchestrationEvent(
       state,
         title: "Updated title",
         updatedAt: "2026-02-27T00:00:01.000Z",
       }),
+      localEnvironmentId,
     );
-    expect(next.bootstrapComplete).toBe(false);
+    expect(localEnvironmentStateOf(next).bootstrapComplete).toBe(false);
-  });
-  it("updates the existing project title when project.meta-updated arrives", () => {
-    const projectId = ProjectId.makeUnsafe("project-1");
-    const state = makeState(
-      makeThread({
-        projectId,
-      }),
-    );
-    const next = applyOrchestrationEvent(
-      state,
-      makeEvent("project.meta-updated", {
-        projectId,
-        title: "Renamed Project",
-        updatedAt: "2026-02-27T00:00:01.000Z",
-      }),
-    );
-    expect(next.projectById[projectId]?.name).toBe("Renamed Project");
-    expect(next.projectById[projectId]?.updatedAt).toBe("2026-02-27T00:00:01.000Z");
   });
   it("preserves state identity for no-op project and thread deletes", () => {
         projectId: ProjectId.makeUnsafe("project-missing"),
         deletedAt: "2026-02-27T00:00:01.000Z",
       }),
+      localEnvironmentId,
     );
     const nextAfterThreadDelete = applyOrchestrationEvent(
       state,
         threadId: ThreadId.makeUnsafe("thread-missing"),
         deletedAt: "2026-02-27T00:00:01.000Z",
       }),
+      localEnvironmentId,
     );
     expect(nextAfterProjectDelete).toBe(state);
       projectById: {
         [originalProjectId]: {
           id: originalProjectId,
+          environmentId: localEnvironmentId,
           name: "Project",
           cwd: "/tmp/project",
           defaultModelSelection: {
         createdAt: "2026-02-27T00:00:01.000Z",
         updatedAt: "2026-02-27T00:00:01.000Z",
       }),
+      localEnvironmentId,
     );
     expect(projectsOf(next)).toHaveLength(1);
     expect(projectsOf(next)[0]?.id).toBe(recreatedProjectId);
     expect(projectsOf(next)[0]?.cwd).toBe("/tmp/project");
     expect(projectsOf(next)[0]?.name).toBe("Project Recreated");
-    expect(next.projectIds).toEqual([recreatedProjectId]);
+    expect(localEnvironmentStateOf(next).projectIds).toEqual([recreatedProjectId]);
-    expect(next.projectById[originalProjectId]).toBeUndefined();
+    expect(localEnvironmentStateOf(next).projectById[originalProjectId]).toBeUndefined();
-    expect(next.projectById[recreatedProjectId]?.id).toBe(recreatedProjectId);
+    expect(localEnvironmentStateOf(next).projectById[recreatedProjectId]?.id).toBe(
+      recreatedProjectId,
+    );
   });
   it("removes stale project index entries when thread.created recreates a thread under a new project", () => {
       id: threadId,
       projectId: originalProjectId,
     });
-    const state: AppState = {
+    const state = withActiveEnvironmentState(localEnvironmentStateOf(makeState(thread)), {
-      ...makeState(thread),
       projectIds: [originalProjectId, recreatedProjectId],
       projectById: {
         [originalProjectId]: {
           id: originalProjectId,
+          environmentId: localEnvironmentId,
           name: "Project 1",
           cwd: "/tmp/project-1",
           defaultModelSelection: {
         },
         [recreatedProjectId]: {
           id: recreatedProjectId,
+          environmentId: localEnvironmentId,
           name: "Project 2",
           cwd: "/tmp/project-2",
           defaultModelSelection: {
           scripts: [],
         },
       },
-    };
+    });
     const next = applyOrchestrationEvent(
       state,
         createdAt: "2026-02-27T00:00:01.000Z",
         updatedAt: "2026-02-27T00:00:01.000Z",
       }),
+      localEnvironmentId,
     );
     expect(threadsOf(next)).toHaveLength(1);
     expect(threadsOf(next)[0]?.projectId).toBe(recreatedProjectId);
-    expect(next.threadIdsByProjectId[originalProjectId]).toBeUndefined();
+    expect(localEnvironmentStateOf(next).threadIdsByProjectId[originalProjectId]).toBeUndefined();
-    expect(next.threadIdsByProjectId[recreatedProjectId]).toEqual([threadId]);
+    expect(localEnvironmentStateOf(next).threadIdsByProjectId[recreatedProjectId]).toEqual([
+      threadId,
+    ]);
   });
   it("updates only the affected thread for message events", () => {
       ],
     });
     const thread2 = makeThread({ id: ThreadId.makeUnsafe("thread-2") });
-    const state: AppState = {
+    const baseState = makeState(thread1);
-      ...makeState(thread1),
+    const baseEnvironmentState = localEnvironmentStateOf(baseState);
+    const state = withActiveEnvironmentState(baseEnvironmentState, {
       threadIds: [thread1.id, thread2.id],
       threadShellById: {
-        ...makeState(thread1).threadShellById,
+        ...baseEnvironmentState.threadShellById,
         [thread2.id]: {
           id: thread2.id,
+          environmentId: thread2.environmentId,
           codexThreadId: thread2.codexThreadId,
           projectId: thread2.projectId,
           title: thread2.title,
         },
       },
       threadSessionById: {
-        ...makeState(thread1).threadSessionById,
+        ...baseEnvironmentState.threadSessionById,
         [thread2.id]: thread2.session,
       },
       threadTurnStateById: {
-        ...makeState(thread1).threadTurnStateById,
+        ...baseEnvironmentState.threadTurnStateById,
         [thread2.id]: {
           latestTurn: thread2.latestTurn,
         },
       },
       messageIdsByThreadId: {
-        ...makeState(thread1).messageIdsByThreadId,
+        ...baseEnvironmentState.messageIdsByThreadId,
         [thread2.id]: [],
       },
       messageByThreadId: {
-        ...makeState(thread1).messageByThreadId,
+        ...baseEnvironmentState.messageByThreadId,
         [thread2.id]: {},
       },
       activityIdsByThreadId: {
-        ...makeState(thread1).activityIdsByThreadId,
+        ...baseEnvironmentState.activityIdsByThreadId,
         [thread2.id]: [],
       },
       activityByThreadId: {
-        ...makeState(thread1).activityByThreadId,
+        ...baseEnvironmentState.activityByThreadId,
         [thread2.id]: {},
       },
       proposedPlanIdsByThreadId: {
-        ...makeState(thread1).proposedPlanIdsByThreadId,
+        ...baseEnvironmentState.proposedPlanIdsByThreadId,
         [thread2.id]: [],
       },
       proposedPlanByThreadId: {
-        ...makeState(thread1).proposedPlanByThreadId,
+        ...baseEnvironmentState.proposedPlanByThreadId,
         [thread2.id]: {},
       },
       turnDiffIdsByThreadId: {
-        ...makeState(thread1).turnDiffIdsByThreadId,
+        ...baseEnvironmentState.turnDiffIdsByThreadId,
         [thread2.id]: [],
       },
       turnDiffSummaryByThreadId: {
-        ...makeState(thread1).turnDiffSummaryByThreadId,
+        ...baseEnvironmentState.turnDiffSummaryByThreadId,
         [thread2.id]: {},
       },
       sidebarThreadSummaryById: {
-        ...makeState(thread1).sidebarThreadSummaryById,
+        ...baseEnvironmentState.sidebarThreadSummaryById,
       },
       threadIdsByProjectId: {
         [thread1.projectId]: [thread1.id, thread2.id],
       },
-    };
+    });
     const next = applyOrchestrationEvent(
       state,
         createdAt: "2026-02-27T00:00:01.000Z",
         updatedAt: "2026-02-27T00:00:01.000Z",
       }),
+      localEnvironmentId,
     );
     expect(threadsOf(next)[0]?.messages[0]?.text).toBe("hello world");
     expect(threadsOf(next)[0]?.latestTurn?.state).toBe("running");
-    expect(next.threadShellById[thread2.id]).toBe(state.threadShellById[thread2.id]);
+    const nextEnvironmentState = next.environmentStateById[localEnvironmentId];
-    expect(next.threadSessionById[thread2.id]).toBe(state.threadSessionById[thread2.id]);
+    const previousEnvironmentState = state.environmentStateById[localEnvironmentId];
-    expect(next.messageIdsByThreadId[thread2.id]).toBe(state.messageIdsByThreadId[thread2.id]);
+    expect(nextEnvironmentState?.threadShellById[thread2.id]).toBe(
-    expect(next.messageByThreadId[thread2.id]).toBe(state.messageByThreadId[thread2.id]);
+      previousEnvironmentState?.threadShellById[thread2.id],
+    );
+    expect(nextEnvironmentState?.threadSessionById[thread2.id]).toBe(
+      previousEnvironmentState?.threadSessionById[thread2.id],
+    );
+    expect(nextEnvironmentState?.messageIdsByThreadId[thread2.id]).toBe(
+      previousEnvironmentState?.messageIdsByThreadId[thread2.id],
+    );
+    expect(nextEnvironmentState?.messageByThreadId[thread2.id]).toBe(
+      previousEnvironmentState?.messageByThreadId[thread2.id],
+    );
   });
   it("applies replay batches in sequence and updates session state", () => {
     });
     const state = makeState(thread);
-    const next = applyOrchestrationEvents(state, [
+    const next = applyOrchestrationEvents(
-      makeEvent(
+      state,
-        "thread.session-set",
+      [
-        {
+        makeEvent(
-          threadId: thread.id,
+          "thread.session-set",
-          session: {
+          {
             threadId: thread.id,
-            status: "running",
+            session: {
-            providerName: "codex",
+              threadId: thread.id,
-            runtimeMode: "full-access",
+              status: "running",
-            activeTurnId: TurnId.makeUnsafe("turn-1"),
+              providerName: "codex",
-            lastError: null,
+              runtimeMode: "full-access",
-            updatedAt: "2026-02-27T00:00:02.000Z",
+              activeTurnId: TurnId.makeUnsafe("turn-1"),
+              lastError: null,
+              updatedAt: "2026-02-27T00:00:02.000Z",
+            },
           },
-        },
+          { sequence: 2 },
-        { sequence: 2 },
+        ),
-      ),
+        makeEvent(
-      makeEvent(
+          "thread.message-sent",
-        "thread.message-sent",
+          {
-        {
+            threadId: thread.id,
-          threadId: thread.id,
+            messageId: MessageId.makeUnsafe("assistant-1"),
-          messageId: MessageId.makeUnsafe("assistant-1"),
+            role: "assistant",
-          role: "assistant",
+            text: "done",
-          text: "done",
+            turnId: TurnId.makeUnsafe("turn-1"),
-          turnId: TurnId.makeUnsafe("turn-1"),
+            streaming: false,
-          streaming: false,
+            createdAt: "2026-02-27T00:00:03.000Z",
-          createdAt: "2026-02-27T00:00:03.000Z",
+            updatedAt: "2026-02-27T00:00:03.000Z",
-          updatedAt: "2026-02-27T00:00:03.000Z",
+          },
-        },
+          { sequence: 3 },
-        { sequence: 3 },
+        ),
-      ),
+      ],
-    ]);
+      localEnvironmentId,
+    );
     expect(threadsOf(next)[0]?.session?.status).toBe("running");
     expect(threadsOf(next)[0]?.latestTurn?.state).toBe("completed");
         assistantMessageId: MessageId.makeUnsafe("assistant-1"),
         completedAt: "2026-02-27T00:00:04.000Z",
       }),
+      localEnvironmentId,
     );
     expect(threadsOf(next)[0]?.turnDiffSummaries).toHaveLength(1);
         createdAt: "2026-02-27T00:00:03.000Z",
         updatedAt: "2026-02-27T00:00:03.000Z",
       }),
+      localEnvironmentId,
     );
     expect(threadsOf(next)[0]?.turnDiffSummaries[0]?.assistantMessageId).toBe(
         threadId: ThreadId.makeUnsafe("thread-1"),
         turnCount: 1,
       }),
+      localEnvironmentId,
     );
     expect(threadsOf(next)[0]?.messages.map((message) => message.id)).toEqual([
         threadId: thread.id,
         turnCount: 1,
       }),
+      localEnvironmentId,
     );
     expect(threadsOf(reverted)[0]?.pendingSourceProposedPlan).toBeUndefined();
           updatedAt: "2026-02-27T00:00:04.000Z",
         },
       }),
+      localEnvironmentId,
     );
     expect(threadsOf(next)[0]?.latestTurn).toMatchObject({

apps/web/src/store.ts+336−92

@@ -1,4 +1,5 @@
1	import {	1	import {
		2	type EnvironmentId,
2	type MessageId,	3	type MessageId,
3	type OrchestrationCheckpointSummary,	4	type OrchestrationCheckpointSummary,
4	type OrchestrationEvent,	5	type OrchestrationEvent,
@@ -11,6 +12,8 @@ import { · 6 unmodified lines
11	type OrchestrationThreadActivity,	12	type OrchestrationThreadActivity,
12	type ProjectId,	13	type ProjectId,
13	type ProviderKind,	14	type ProviderKind,
		15	type ScopedProjectRef,
		16	type ScopedThreadRef,
14	ThreadId,	17	ThreadId,
15	type TurnId,	18	type TurnId,
16	} from "@t3tools/contracts";	19	} from "@t3tools/contracts";
@@ -35,7 +38,7 @@ import { · 18 unmodified lines
35	} from "./types";	38	} from "./types";
36	import { sanitizeThreadErrorMessage } from "./rpc/transportError";	39	import { sanitizeThreadErrorMessage } from "./rpc/transportError";
37		40
38	export interface AppState {	41	export interface EnvironmentState {
39	projectIds: ProjectId[];	42	projectIds: ProjectId[];
40	projectById: Record<ProjectId, Project>;	43	projectById: Record<ProjectId, Project>;
41	threadIds: ThreadId[];	44	threadIds: ThreadId[];
@@ -55,7 +58,12 @@ export interface AppState { · 13 unmodified lines
55	bootstrapComplete: boolean;	58	bootstrapComplete: boolean;
56	}	59	}
57		60
58	const initialState: AppState = {	61	export interface AppState {
		62	activeEnvironmentId: EnvironmentId \| null;
		63	environmentStateById: Record<string, EnvironmentState>;
		64	}
		65
		66	const initialEnvironmentState: EnvironmentState = {
59	projectIds: [],	67	projectIds: [],
60	projectById: {},	68	projectById: {},
61	threadIds: [],	69	threadIds: [],
@@ -75,6 +83,11 @@ const initialState: AppState = { · 13 unmodified lines
75	bootstrapComplete: false,	83	bootstrapComplete: false,
76	};	84	};
77		85
		86	const initialState: AppState = {
		87	activeEnvironmentId: null,
		88	environmentStateById: {},
		89	};
		90
78	const MAX_THREAD_MESSAGES = 2_000;	91	const MAX_THREAD_MESSAGES = 2_000;
79	const MAX_THREAD_CHECKPOINTS = 500;	92	const MAX_THREAD_CHECKPOINTS = 500;
80	const MAX_THREAD_PROPOSED_PLANS = 200;	93	const MAX_THREAD_PROPOSED_PLANS = 200;
@@ -169,11 +182,16 @@ function mapTurnDiffSummary(checkpoint: OrchestrationCheckpointSummary): TurnDif · 88 unmodified lines
169	};	182	};
170	}	183	}
171		184
172	function mapProject(project: OrchestrationReadModel["projects"][number]): Project {	185	function mapProject(
		186	project: OrchestrationReadModel["projects"][number],
		187	environmentId: EnvironmentId,
		188	): Project {
173	return {	189	return {
174	id: project.id,	190	id: project.id,
		191	environmentId,
175	name: project.title,	192	name: project.title,
176	cwd: project.workspaceRoot,	193	cwd: project.workspaceRoot,
		194	repositoryIdentity: project.repositoryIdentity ?? null,
177	defaultModelSelection: project.defaultModelSelection	195	defaultModelSelection: project.defaultModelSelection
178	? normalizeModelSelection(project.defaultModelSelection)	196	? normalizeModelSelection(project.defaultModelSelection)
179	: null,	197	: null,
@@ -183,9 +201,10 @@ function mapProject(project: OrchestrationReadModel["projects"][number]): Projec · 3 unmodified lines
183	};	201	};
184	}	202	}
185		203
186	function mapThread(thread: OrchestrationThread): Thread {	204	function mapThread(thread: OrchestrationThread, environmentId: EnvironmentId): Thread {
187	return {	205	return {
188	id: thread.id,	206	id: thread.id,
		207	environmentId,
189	codexThreadId: null,	208	codexThreadId: null,
190	projectId: thread.projectId,	209	projectId: thread.projectId,
191	title: thread.title,	210	title: thread.title,
@@ -211,6 +230,7 @@ function mapThread(thread: OrchestrationThread): Thread { · 19 unmodified lines
211	function toThreadShell(thread: Thread): ThreadShell {	230	function toThreadShell(thread: Thread): ThreadShell {
212	return {	231	return {
213	id: thread.id,	232	id: thread.id,
		233	environmentId: thread.environmentId,
214	codexThreadId: thread.codexThreadId,	234	codexThreadId: thread.codexThreadId,
215	projectId: thread.projectId,	235	projectId: thread.projectId,
216	title: thread.title,	236	title: thread.title,
@@ -251,6 +271,7 @@ function getLatestUserMessageAt(messages: ReadonlyArray<ChatMessage>): string \| · 34 unmodified lines
251	function buildSidebarThreadSummary(thread: Thread): SidebarThreadSummary {	271	function buildSidebarThreadSummary(thread: Thread): SidebarThreadSummary {
252	return {	272	return {
253	id: thread.id,	273	id: thread.id,
		274	environmentId: thread.environmentId,
254	projectId: thread.projectId,	275	projectId: thread.projectId,
255	title: thread.title,	276	title: thread.title,
256	interactionMode: thread.interactionMode,	277	interactionMode: thread.interactionMode,
@@ -298,6 +319,7 @@ function threadShellsEqual(left: ThreadShell \| undefined, right: ThreadShell): b · 41 unmodified lines
298	return (	319	return (
299	left !== undefined &&	320	left !== undefined &&
300	left.id === right.id &&	321	left.id === right.id &&
		322	left.environmentId === right.environmentId &&
301	left.codexThreadId === right.codexThreadId &&	323	left.codexThreadId === right.codexThreadId &&
302	left.projectId === right.projectId &&	324	left.projectId === right.projectId &&
303	left.title === right.title &&	325	left.title === right.title &&
@@ -377,7 +399,7 @@ function buildTurnDiffSlice(thread: Thread): { · 73 unmodified lines
377	};	399	};
378	}	400	}
379		401
380	function selectThreadMessages(state: AppState, threadId: ThreadId): ChatMessage[] {	402	function selectThreadMessages(state: EnvironmentState, threadId: ThreadId): ChatMessage[] {
381	const ids = state.messageIdsByThreadId[threadId] ?? EMPTY_MESSAGE_IDS;	403	const ids = state.messageIdsByThreadId[threadId] ?? EMPTY_MESSAGE_IDS;
382	const byId = state.messageByThreadId[threadId] ?? EMPTY_MESSAGE_MAP;	404	const byId = state.messageByThreadId[threadId] ?? EMPTY_MESSAGE_MAP;
383	if (ids.length === 0) {	405	if (ids.length === 0) {
@@ -390,7 +412,7 @@ function selectThreadMessages(state: AppState, threadId: ThreadId): ChatMessage[ · 6 unmodified lines
390	}	412	}
391		413
392	function selectThreadActivities(	414	function selectThreadActivities(
393	state: AppState,	415	state: EnvironmentState,
394	threadId: ThreadId,	416	threadId: ThreadId,
395	): OrchestrationThreadActivity[] {	417	): OrchestrationThreadActivity[] {
396	const ids = state.activityIdsByThreadId[threadId] ?? EMPTY_ACTIVITY_IDS;	418	const ids = state.activityIdsByThreadId[threadId] ?? EMPTY_ACTIVITY_IDS;
@@ -404,7 +426,7 @@ function selectThreadActivities( · 7 unmodified lines
404	});	426	});
405	}	427	}
406		428
407	function selectThreadProposedPlans(state: AppState, threadId: ThreadId): ProposedPlan[] {	429	function selectThreadProposedPlans(state: EnvironmentState, threadId: ThreadId): ProposedPlan[] {
408	const ids = state.proposedPlanIdsByThreadId[threadId] ?? EMPTY_PROPOSED_PLAN_IDS;	430	const ids = state.proposedPlanIdsByThreadId[threadId] ?? EMPTY_PROPOSED_PLAN_IDS;
409	const byId = state.proposedPlanByThreadId[threadId] ?? EMPTY_PROPOSED_PLAN_MAP;	431	const byId = state.proposedPlanByThreadId[threadId] ?? EMPTY_PROPOSED_PLAN_MAP;
410	if (ids.length === 0) {	432	if (ids.length === 0) {
@@ -416,7 +438,10 @@ function selectThreadProposedPlans(state: AppState, threadId: ThreadId): Propose · 5 unmodified lines
416	});	438	});
417	}	439	}
418		440
419	function selectThreadTurnDiffSummaries(state: AppState, threadId: ThreadId): TurnDiffSummary[] {	441	function selectThreadTurnDiffSummaries(
		442	state: EnvironmentState,
		443	threadId: ThreadId,
		444	): TurnDiffSummary[] {
420	const ids = state.turnDiffIdsByThreadId[threadId] ?? EMPTY_TURN_IDS;	445	const ids = state.turnDiffIdsByThreadId[threadId] ?? EMPTY_TURN_IDS;
421	const byId = state.turnDiffSummaryByThreadId[threadId] ?? EMPTY_TURN_DIFF_MAP;	446	const byId = state.turnDiffSummaryByThreadId[threadId] ?? EMPTY_TURN_DIFF_MAP;
422	if (ids.length === 0) {	447	if (ids.length === 0) {
@@ -428,7 +453,7 @@ function selectThreadTurnDiffSummaries(state: AppState, threadId: ThreadId): Tur · 5 unmodified lines
428	});	453	});
429	}	454	}
430		455
431	function getThread(state: AppState, threadId: ThreadId): Thread \| undefined {	456	function getThread(state: EnvironmentState, threadId: ThreadId): Thread \| undefined {
432	const shell = state.threadShellById[threadId];	457	const shell = state.threadShellById[threadId];
433	if (!shell) {	458	if (!shell) {
434	return undefined;	459	return undefined;
@@ -446,21 +471,25 @@ function getThread(state: AppState, threadId: ThreadId): Thread \| undefined { · 11 unmodified lines
446	};	471	};
447	}	472	}
448		473
449	function getProjects(state: AppState): Project[] {	474	function getProjects(state: EnvironmentState): Project[] {
450	return state.projectIds.flatMap((projectId) => {	475	return state.projectIds.flatMap((projectId) => {
451	const project = state.projectById[projectId];	476	const project = state.projectById[projectId];
452	return project ? [project] : [];	477	return project ? [project] : [];
453	});	478	});
454	}	479	}
455		480
456	function getThreads(state: AppState): Thread[] {	481	function getThreads(state: EnvironmentState): Thread[] {
457	return state.threadIds.flatMap((threadId) => {	482	return state.threadIds.flatMap((threadId) => {
458	const thread = getThread(state, threadId);	483	const thread = getThread(state, threadId);
459	return thread ? [thread] : [];	484	return thread ? [thread] : [];
460	});	485	});
461	}	486	}
462		487
463	function writeThreadState(state: AppState, nextThread: Thread, previousThread?: Thread): AppState {	488	function writeThreadState(
		489	state: EnvironmentState,
		490	nextThread: Thread,
		491	previousThread?: Thread,
		492	): EnvironmentState {
464	const nextShell = toThreadShell(nextThread);	493	const nextShell = toThreadShell(nextThread);
465	const nextTurnState = toThreadTurnState(nextThread);	494	const nextTurnState = toThreadTurnState(nextThread);
466	const previousShell = state.threadShellById[nextThread.id];	495	const previousShell = state.threadShellById[nextThread.id];
@@ -613,7 +642,7 @@ function writeThreadState(state: AppState, nextThread: Thread, previousThread?: · 146 unmodified lines
613	return nextState;	642	return nextState;
614	}	643	}
615		644
616	function removeThreadState(state: AppState, threadId: ThreadId): AppState {	645	function removeThreadState(state: EnvironmentState, threadId: ThreadId): EnvironmentState {
617	const shell = state.threadShellById[threadId];	646	const shell = state.threadShellById[threadId];
618	if (!shell) {	647	if (!shell) {
619	return state;	648	return state;
@@ -887,10 +916,10 @@ function attachmentPreviewRoutePath(attachmentId: string): string { · 267 unmodified lines
887	}	916	}
888		917
889	function updateThreadState(	918	function updateThreadState(
890	state: AppState,	919	state: EnvironmentState,
891	threadId: ThreadId,	920	threadId: ThreadId,
892	updater: (thread: Thread) => Thread,	921	updater: (thread: Thread) => Thread,
893	): AppState {	922	): EnvironmentState {
894	const currentThread = getThread(state, threadId);	923	const currentThread = getThread(state, threadId);
895	if (!currentThread) {	924	if (!currentThread) {
896	return state;	925	return state;
@@ -904,7 +933,7 @@ function updateThreadState( · 7 unmodified lines
904		933
905	function buildProjectState(	934	function buildProjectState(
906	projects: ReadonlyArray<Project>,	935	projects: ReadonlyArray<Project>,
907	): Pick<AppState, "projectIds" \| "projectById"> {	936	): Pick<EnvironmentState, "projectIds" \| "projectById"> {
908	return {	937	return {
909	projectIds: projects.map((project) => project.id),	938	projectIds: projects.map((project) => project.id),
910	projectById: Object.fromEntries(	939	projectById: Object.fromEntries(
@@ -916,7 +945,7 @@ function buildProjectState( · 5 unmodified lines
916	function buildThreadState(	945	function buildThreadState(
917	threads: ReadonlyArray<Thread>,	946	threads: ReadonlyArray<Thread>,
918	): Pick<	947	): Pick<
919	AppState,	948	EnvironmentState,
920	\| "threadIds"	949	\| "threadIds"
921	\| "threadIdsByProjectId"	950	\| "threadIdsByProjectId"
922	\| "threadShellById"	951	\| "threadShellById"
@@ -989,11 +1018,48 @@ function buildThreadState( · 66 unmodified lines
989	};	1018	};
990	}	1019	}
991		1020
992	export function syncServerReadModel(state: AppState, readModel: OrchestrationReadModel): AppState {	1021	function getStoredEnvironmentState(
		1022	state: AppState,
		1023	environmentId: EnvironmentId,
		1024	): EnvironmentState {
		1025	return state.environmentStateById[environmentId] ?? initialEnvironmentState;
		1026	}
		1027
		1028	function commitEnvironmentState(
		1029	state: AppState,
		1030	environmentId: EnvironmentId,
		1031	nextEnvironmentState: EnvironmentState,
		1032	): AppState {
		1033	const currentEnvironmentState = state.environmentStateById[environmentId];
		1034	const environmentStateById =
		1035	currentEnvironmentState === nextEnvironmentState
		1036	? state.environmentStateById
		1037	: {
		1038	...state.environmentStateById,
		1039	[environmentId]: nextEnvironmentState,
		1040	};
		1041
		1042	if (environmentStateById === state.environmentStateById) {
		1043	return state;
		1044	}
		1045
		1046	return {
		1047	...state,
		1048	environmentStateById,
		1049	};
		1050	}
		1051
		1052	function syncEnvironmentReadModel(
		1053	state: EnvironmentState,
		1054	readModel: OrchestrationReadModel,
		1055	environmentId: EnvironmentId,
		1056	): EnvironmentState {
993	const projects = readModel.projects	1057	const projects = readModel.projects
994	.filter((project) => project.deletedAt === null)	1058	.filter((project) => project.deletedAt === null)
995	.map(mapProject);	1059	.map((project) => mapProject(project, environmentId));
996	const threads = readModel.threads.filter((thread) => thread.deletedAt === null).map(mapThread);	1060	const threads = readModel.threads
		1061	.filter((thread) => thread.deletedAt === null)
		1062	.map((thread) => mapThread(thread, environmentId));
997	return {	1063	return {
998	...state,	1064	...state,
999	...buildProjectState(projects),	1065	...buildProjectState(projects),
@@ -1002,19 +1068,43 @@ export function syncServerReadModel(state: AppState, readModel: OrchestrationRea · 2 unmodified lines
1002	};	1068	};
1003	}	1069	}
1004		1070
1005	export function applyOrchestrationEvent(state: AppState, event: OrchestrationEvent): AppState {	1071	export function syncServerReadModel(
		1072	state: AppState,
		1073	readModel: OrchestrationReadModel,
		1074	environmentId: EnvironmentId,
		1075	): AppState {
		1076	return commitEnvironmentState(
		1077	state,
		1078	environmentId,
		1079	syncEnvironmentReadModel(
		1080	getStoredEnvironmentState(state, environmentId),
		1081	readModel,
		1082	environmentId,
		1083	),
		1084	);
		1085	}
		1086
		1087	function applyEnvironmentOrchestrationEvent(
		1088	state: EnvironmentState,
		1089	event: OrchestrationEvent,
		1090	environmentId: EnvironmentId,
		1091	): EnvironmentState {
1006	switch (event.type) {	1092	switch (event.type) {
1007	case "project.created": {	1093	case "project.created": {
1008	const nextProject = mapProject({	1094	const nextProject = mapProject(
1009	id: event.payload.projectId,	1095	{
1010	title: event.payload.title,	1096	id: event.payload.projectId,
1011	workspaceRoot: event.payload.workspaceRoot,	1097	title: event.payload.title,
1012	defaultModelSelection: event.payload.defaultModelSelection,	1098	workspaceRoot: event.payload.workspaceRoot,
1013	scripts: event.payload.scripts,	1099	repositoryIdentity: event.payload.repositoryIdentity ?? null,
1014	createdAt: event.payload.createdAt,	1100	defaultModelSelection: event.payload.defaultModelSelection,
1015	updatedAt: event.payload.updatedAt,	1101	scripts: event.payload.scripts,
1016	deletedAt: null,	1102	createdAt: event.payload.createdAt,
1017	});	1103	updatedAt: event.payload.updatedAt,
		1104	deletedAt: null,
		1105	},
		1106	environmentId,
		1107	);
1018	const existingProjectId =	1108	const existingProjectId =
1019	state.projectIds.find(	1109	state.projectIds.find(
1020	(projectId) =>	1110	(projectId) =>
@@ -1060,6 +1150,9 @@ export function applyOrchestrationEvent(state: AppState, event: OrchestrationEve · 39 unmodified lines
1060	...project,	1150	...project,
1061	...(event.payload.title !== undefined ? { name: event.payload.title } : {}),	1151	...(event.payload.title !== undefined ? { name: event.payload.title } : {}),
1062	...(event.payload.workspaceRoot !== undefined ? { cwd: event.payload.workspaceRoot } : {}),	1152	...(event.payload.workspaceRoot !== undefined ? { cwd: event.payload.workspaceRoot } : {}),
		1153	...(event.payload.repositoryIdentity !== undefined
		1154	? { repositoryIdentity: event.payload.repositoryIdentity ?? null }
		1155	: {}),
1063	...(event.payload.defaultModelSelection !== undefined	1156	...(event.payload.defaultModelSelection !== undefined
1064	? {	1157	? {
1065	defaultModelSelection: event.payload.defaultModelSelection	1158	defaultModelSelection: event.payload.defaultModelSelection
@@ -1095,26 +1188,29 @@ export function applyOrchestrationEvent(state: AppState, event: OrchestrationEve · 29 unmodified lines
1095		1188
1096	case "thread.created": {	1189	case "thread.created": {
1097	const previousThread = getThread(state, event.payload.threadId);	1190	const previousThread = getThread(state, event.payload.threadId);
1098	const nextThread = mapThread({	1191	const nextThread = mapThread(
1099	id: event.payload.threadId,	1192	{
1100	projectId: event.payload.projectId,	1193	id: event.payload.threadId,
1101	title: event.payload.title,	1194	projectId: event.payload.projectId,
1102	modelSelection: event.payload.modelSelection,	1195	title: event.payload.title,
1103	runtimeMode: event.payload.runtimeMode,	1196	modelSelection: event.payload.modelSelection,
1104	interactionMode: event.payload.interactionMode,	1197	runtimeMode: event.payload.runtimeMode,
1105	branch: event.payload.branch,	1198	interactionMode: event.payload.interactionMode,
1106	worktreePath: event.payload.worktreePath,	1199	branch: event.payload.branch,
1107	latestTurn: null,	1200	worktreePath: event.payload.worktreePath,
1108	createdAt: event.payload.createdAt,	1201	latestTurn: null,
1109	updatedAt: event.payload.updatedAt,	1202	createdAt: event.payload.createdAt,
1110	archivedAt: null,	1203	updatedAt: event.payload.updatedAt,
1111	deletedAt: null,	1204	archivedAt: null,
1112	messages: [],	1205	deletedAt: null,
1113	proposedPlans: [],	1206	messages: [],
1114	activities: [],	1207	proposedPlans: [],
1115	checkpoints: [],	1208	activities: [],
1116	session: null,	1209	checkpoints: [],
1117	});	1210	session: null,
		1211	},
		1212	environmentId,
		1213	);
1118	return writeThreadState(state, nextThread, previousThread);	1214	return writeThreadState(state, nextThread, previousThread);
1119	}	1215	}
1120		1216
@@ -1481,70 +1577,218 @@ export function applyOrchestrationEvent(state: AppState, event: OrchestrationEve · 360 unmodified lines
1481	export function applyOrchestrationEvents(	1577	export function applyOrchestrationEvents(
1482	state: AppState,	1578	state: AppState,
1483	events: ReadonlyArray<OrchestrationEvent>,	1579	events: ReadonlyArray<OrchestrationEvent>,
		1580	environmentId: EnvironmentId,
1484	): AppState {	1581	): AppState {
1485	if (events.length === 0) {	1582	if (events.length === 0) {
1486	return state;	1583	return state;
1487	}	1584	}
1488	return events.reduce((nextState, event) => applyOrchestrationEvent(nextState, event), state);	1585	const currentEnvironmentState = getStoredEnvironmentState(state, environmentId);
1489	}	1586	const nextEnvironmentState = events.reduce(
1490		1587	(nextState, event) => applyEnvironmentOrchestrationEvent(nextState, event, environmentId),
1491	export const selectProjects = (state: AppState): Project[] => getProjects(state);	1588	currentEnvironmentState,
1492	export const selectThreads = (state: AppState): Thread[] => getThreads(state);	1589	);
1493	export const selectProjectById =	1590	return commitEnvironmentState(state, environmentId, nextEnvironmentState);
1494	(projectId: Project["id"] \| null \| undefined) =>	1591	}
1495	(state: AppState): Project \| undefined =>
1496	projectId ? state.projectById[projectId] : undefined;
1497	export const selectThreadById =
1498	(threadId: ThreadId \| null \| undefined) =>
1499	(state: AppState): Thread \| undefined =>
1500	threadId ? getThread(state, threadId) : undefined;
1501	export const selectSidebarThreadSummaryById =
1502	(threadId: ThreadId \| null \| undefined) =>
1503	(state: AppState): SidebarThreadSummary \| undefined =>
1504	threadId ? state.sidebarThreadSummaryById[threadId] : undefined;
1505	export const selectThreadIdsByProjectId =
1506	(projectId: ProjectId \| null \| undefined) =>
1507	(state: AppState): ThreadId[] =>
1508	projectId ? (state.threadIdsByProjectId[projectId] ?? EMPTY_THREAD_IDS) : EMPTY_THREAD_IDS;
1509		1592
1510	export function setError(state: AppState, threadId: ThreadId, error: string \| null): AppState {	1593	function getEnvironmentEntries(
1511	return updateThreadState(state, threadId, (thread) => {	1594	state: AppState,
1512	if (thread.error === error) return thread;	1595	): ReadonlyArray<readonly [EnvironmentId, EnvironmentState]> {
1513	return { ...thread, error };	1596	return Object.entries(state.environmentStateById) as unknown as ReadonlyArray<
		1597	readonly [EnvironmentId, EnvironmentState]
		1598	>;
		1599	}
		1600
		1601	export function selectEnvironmentState(
		1602	state: AppState,
		1603	environmentId: EnvironmentId \| null \| undefined,
		1604	): EnvironmentState {
		1605	return environmentId ? getStoredEnvironmentState(state, environmentId) : initialEnvironmentState;
		1606	}
		1607
		1608	export function selectProjectsForEnvironment(
		1609	state: AppState,
		1610	environmentId: EnvironmentId \| null \| undefined,
		1611	): Project[] {
		1612	return getProjects(selectEnvironmentState(state, environmentId));
		1613	}
		1614
		1615	export function selectThreadsForEnvironment(
		1616	state: AppState,
		1617	environmentId: EnvironmentId \| null \| undefined,
		1618	): Thread[] {
		1619	return getThreads(selectEnvironmentState(state, environmentId));
		1620	}
		1621
		1622	export function selectProjectsAcrossEnvironments(state: AppState): Project[] {
		1623	return getEnvironmentEntries(state).flatMap(([, environmentState]) =>
		1624	getProjects(environmentState),
		1625	);
		1626	}
		1627
		1628	export function selectThreadsAcrossEnvironments(state: AppState): Thread[] {
		1629	return getEnvironmentEntries(state).flatMap(([, environmentState]) =>
		1630	getThreads(environmentState),
		1631	);
		1632	}
		1633
		1634	export function selectSidebarThreadsAcrossEnvironments(state: AppState): SidebarThreadSummary[] {
		1635	return getEnvironmentEntries(state).flatMap(([environmentId, environmentState]) =>
		1636	environmentState.threadIds.flatMap((threadId) => {
		1637	const thread = environmentState.sidebarThreadSummaryById[threadId];
		1638	return thread && thread.environmentId === environmentId ? [thread] : [];
		1639	}),
		1640	);
		1641	}
		1642
		1643	export function selectSidebarThreadsForProjectRef(
		1644	state: AppState,
		1645	ref: ScopedProjectRef \| null \| undefined,
		1646	): SidebarThreadSummary[] {
		1647	if (!ref) {
		1648	return [];
		1649	}
		1650
		1651	const environmentState = selectEnvironmentState(state, ref.environmentId);
		1652	const threadIds = environmentState.threadIdsByProjectId[ref.projectId] ?? EMPTY_THREAD_IDS;
		1653	return threadIds.flatMap((threadId) => {
		1654	const thread = environmentState.sidebarThreadSummaryById[threadId];
		1655	return thread ? [thread] : [];
1514	});	1656	});
1515	}	1657	}
1516		1658
		1659	export function selectBootstrapCompleteForActiveEnvironment(state: AppState): boolean {
		1660	return selectEnvironmentState(state, state.activeEnvironmentId).bootstrapComplete;
		1661	}
		1662
		1663	export function selectProjectByRef(
		1664	state: AppState,
		1665	ref: ScopedProjectRef \| null \| undefined,
		1666	): Project \| undefined {
		1667	return ref
		1668	? selectEnvironmentState(state, ref.environmentId).projectById[ref.projectId]
		1669	: undefined;
		1670	}
		1671
		1672	export function selectThreadByRef(
		1673	state: AppState,
		1674	ref: ScopedThreadRef \| null \| undefined,
		1675	): Thread \| undefined {
		1676	return ref
		1677	? getThread(selectEnvironmentState(state, ref.environmentId), ref.threadId)
		1678	: undefined;
		1679	}
		1680
		1681	export function selectSidebarThreadSummaryByRef(
		1682	state: AppState,
		1683	ref: ScopedThreadRef \| null \| undefined,
		1684	): SidebarThreadSummary \| undefined {
		1685	return ref
		1686	? selectEnvironmentState(state, ref.environmentId).sidebarThreadSummaryById[ref.threadId]
		1687	: undefined;
		1688	}
		1689
		1690	export function selectThreadIdsByProjectRef(
		1691	state: AppState,
		1692	ref: ScopedProjectRef \| null \| undefined,
		1693	): ThreadId[] {
		1694	return ref
		1695	? (selectEnvironmentState(state, ref.environmentId).threadIdsByProjectId[ref.projectId] ??
		1696	EMPTY_THREAD_IDS)
		1697	: EMPTY_THREAD_IDS;
		1698	}
		1699
		1700	export function setError(state: AppState, threadId: ThreadId, error: string \| null): AppState {
		1701	if (state.activeEnvironmentId === null) {
		1702	return state;
		1703	}
		1704
		1705	const nextEnvironmentState = updateThreadState(
		1706	getStoredEnvironmentState(state, state.activeEnvironmentId),
		1707	threadId,
		1708	(thread) => {
		1709	if (thread.error === error) return thread;
		1710	return { ...thread, error };
		1711	},
		1712	);
		1713	return commitEnvironmentState(state, state.activeEnvironmentId, nextEnvironmentState);
		1714	}
		1715
		1716	export function applyOrchestrationEvent(
		1717	state: AppState,
		1718	event: OrchestrationEvent,
		1719	environmentId: EnvironmentId,
		1720	): AppState {
		1721	return commitEnvironmentState(
		1722	state,
		1723	environmentId,
		1724	applyEnvironmentOrchestrationEvent(
		1725	getStoredEnvironmentState(state, environmentId),
		1726	event,
		1727	environmentId,
		1728	),
		1729	);
		1730	}
		1731
		1732	export function setActiveEnvironmentId(state: AppState, environmentId: EnvironmentId): AppState {
		1733	if (state.activeEnvironmentId === environmentId) {
		1734	return state;
		1735	}
		1736
		1737	return {
		1738	...state,
		1739	activeEnvironmentId: environmentId,
		1740	};
		1741	}
		1742
1517	export function setThreadBranch(	1743	export function setThreadBranch(
1518	state: AppState,	1744	state: AppState,
1519	threadId: ThreadId,	1745	threadId: ThreadId,
1520	branch: string \| null,	1746	branch: string \| null,
1521	worktreePath: string \| null,	1747	worktreePath: string \| null,
1522	): AppState {	1748	): AppState {
1523	return updateThreadState(state, threadId, (thread) => {	1749	if (state.activeEnvironmentId === null) {
1524	if (thread.branch === branch && thread.worktreePath === worktreePath) return thread;	1750	return state;
1525	const cwdChanged = thread.worktreePath !== worktreePath;	1751	}
1526	return {	1752
1527	...thread,	1753	const nextEnvironmentState = updateThreadState(
1528	branch,	1754	getStoredEnvironmentState(state, state.activeEnvironmentId),
1529	worktreePath,	1755	threadId,
1530	...(cwdChanged ? { session: null } : {}),	1756	(thread) => {
1531	};	1757	if (thread.branch === branch && thread.worktreePath === worktreePath) return thread;
1532	});	1758	const cwdChanged = thread.worktreePath !== worktreePath;
		1759	return {
		1760	...thread,
		1761	branch,
		1762	worktreePath,
		1763	...(cwdChanged ? { session: null } : {}),
		1764	};
		1765	},
		1766	);
		1767	return commitEnvironmentState(state, state.activeEnvironmentId, nextEnvironmentState);
1533	}	1768	}
1534		1769
1535	interface AppStore extends AppState {	1770	interface AppStore extends AppState {
1536	syncServerReadModel: (readModel: OrchestrationReadModel) => void;	1771	setActiveEnvironmentId: (environmentId: EnvironmentId) => void;
1537	applyOrchestrationEvent: (event: OrchestrationEvent) => void;	1772	syncServerReadModel: (readModel: OrchestrationReadModel, environmentId: EnvironmentId) => void;
1538	applyOrchestrationEvents: (events: ReadonlyArray<OrchestrationEvent>) => void;	1773	applyOrchestrationEvent: (event: OrchestrationEvent, environmentId: EnvironmentId) => void;
		1774	applyOrchestrationEvents: (
		1775	events: ReadonlyArray<OrchestrationEvent>,
		1776	environmentId: EnvironmentId,
		1777	) => void;
1539	setError: (threadId: ThreadId, error: string \| null) => void;	1778	setError: (threadId: ThreadId, error: string \| null) => void;
1540	setThreadBranch: (threadId: ThreadId, branch: string \| null, worktreePath: string \| null) => void;	1779	setThreadBranch: (threadId: ThreadId, branch: string \| null, worktreePath: string \| null) => void;
1541	}	1780	}
1542		1781
1543	export const useStore = create<AppStore>((set) => ({	1782	export const useStore = create<AppStore>((set) => ({
1544	...initialState,	1783	...initialState,
1545	syncServerReadModel: (readModel) => set((state) => syncServerReadModel(state, readModel)),	1784	setActiveEnvironmentId: (environmentId) =>
1546	applyOrchestrationEvent: (event) => set((state) => applyOrchestrationEvent(state, event)),	1785	set((state) => setActiveEnvironmentId(state, environmentId)),
1547	applyOrchestrationEvents: (events) => set((state) => applyOrchestrationEvents(state, events)),	1786	syncServerReadModel: (readModel, environmentId) =>
		1787	set((state) => syncServerReadModel(state, readModel, environmentId)),
		1788	applyOrchestrationEvent: (event, environmentId) =>
		1789	set((state) => applyOrchestrationEvent(state, event, environmentId)),
		1790	applyOrchestrationEvents: (events, environmentId) =>
		1791	set((state) => applyOrchestrationEvents(state, events, environmentId)),
1548	setError: (threadId, error) => set((state) => setError(state, threadId, error)),	1792	setError: (threadId, error) => set((state) => setError(state, threadId, error)),
1549	setThreadBranch: (threadId, branch, worktreePath) =>	1793	setThreadBranch: (threadId, branch, worktreePath) =>
1550	set((state) => setThreadBranch(state, threadId, branch, worktreePath)),	1794	set((state) => setThreadBranch(state, threadId, branch, worktreePath)),

apps/web/src/storeSelectors.ts+68−27

-import { type MessageId, type ProjectId, type ThreadId, type TurnId } from "@t3tools/contracts";
+import {
-import { type AppState } from "./store";
+  type MessageId,
+  type ScopedProjectRef,
+  type ScopedThreadRef,
+  type ThreadId,
+  type TurnId,
+} from "@t3tools/contracts";
+import { selectEnvironmentState, type AppState, type EnvironmentState } from "./store";
 import {
   type ChatMessage,
   type Project,
   });
 }
-export function createProjectSelector(
+export function createProjectSelectorByRef(
-  projectId: ProjectId | null | undefined,
+  ref: ScopedProjectRef | null | undefined,
 ): (state: AppState) => Project | undefined {
-  return (state) => (projectId ? state.projectById[projectId] : undefined);
+  return (state) =>