lael-labs/t3code

.docs/encyclopedia.md+180−0

@@ -0,0 +1,180 @@
	1	# Encyclopedia
	2
	3	This is a living glossary for T3 Code. It explains what common terms mean in this codebase.
	4
	5	## Table of contents
	6
	7	- [Project and workspace](#project-and-workspace)
	8	- [Thread timeline](#thread-timeline)
	9	- [Orchestration](#orchestration)
	10	- [Provider runtime](#provider-runtime)
	11	- [Checkpointing](#checkpointing)
	12
	13	## Concepts
	14
	15	### Project and workspace
	16
	17	#### Project
	18
	19	The top-level workspace record in the app. In [the orchestration contracts][1], a project has a `workspaceRoot`, a title, and one or more threads. See [workspace-layout.md][2].
	20
	21	#### Workspace root
	22
	23	The root filesystem path for a project. In [the orchestration model][1], it is the base directory for branches and optional worktrees. See [workspace-layout.md][2].
	24
	25	#### Worktree
	26
	27	A Git worktree used as an isolated workspace for a thread. If a thread has a `worktreePath` in [the contracts][1], it runs there instead of in the main working tree. Git operations live in [GitCore.ts][3].
	28
	29	### Thread timeline
	30
	31	#### Thread
	32
	33	The main durable unit of conversation and workspace history. In [the orchestration contracts][1], a thread holds messages, activities, checkpoints, and session-related state. See [projector.ts][4].
	34
	35	#### Turn
	36
	37	A single user-to-assistant work cycle inside a thread. It starts with user input and ends when follow-up work like checkpointing settles. See [the contracts][1], [ProviderRuntimeIngestion.ts][5], and [CheckpointReactor.ts][6].
	38
	39	#### Activity
	40
	41	A user-visible log item attached to a thread. In [the contracts][1], activities cover important non-message events like approvals, tool actions, and failures. They are projected into thread state in [projector.ts][4].
	42
	43	### Orchestration
	44
	45	Orchestration is the server-side domain layer that turns runtime activity into stable app state. The main entry point is [OrchestrationEngine.ts][7], with core logic in [decider.ts][8] and [projector.ts][4].
	46
	47	#### Aggregate
	48
	49	The domain object a command or event belongs to. In [the contracts][1], that is usually `project` or `thread`. See [decider.ts][8].
	50
	51	#### Command
	52
	53	A typed request to change domain state. In [the contracts][1], commands are validated in [commandInvariants.ts][9] and turned into events by [decider.ts][8].
	54	Examples include `thread.create`, `thread.turn.start`, and `thread.checkpoint.revert`.
	55
	56	#### Domain Event
	57
	58	A persisted fact that something already happened. In [the contracts][1], events are the source of truth, and [projector.ts][4] shows how they are applied.
	59	Examples include `thread.created`, `thread.message-sent`, and `thread.turn-diff-completed`.
	60
	61	#### Decider
	62
	63	The pure orchestration logic that turns commands plus current state into events. The core implementation is in [decider.ts][8], with preconditions in [commandInvariants.ts][9].
	64
	65	#### Projection
	66
	67	A read-optimized view derived from events. See [projector.ts][4], [ProjectionPipeline.ts][11], and [ProjectionSnapshotQuery.ts][10].
	68
	69	#### Projector
	70
	71	The logic that applies domain events to the read model or projection tables. See [projector.ts][4] and [ProjectionPipeline.ts][11].
	72
	73	#### Read model
	74
	75	The current materialized view of orchestration state. In [the contracts][1], it holds projects, threads, messages, activities, checkpoints, and session state. See [ProjectionSnapshotQuery.ts][10] and [OrchestrationEngine.ts][7].
	76
	77	#### Reactor
	78
	79	A side-effecting service that handles follow-up work after events or runtime signals. Examples include [CheckpointReactor.ts][6], [ProviderCommandReactor.ts][12], and [ProviderRuntimeIngestion.ts][5].
	80
	81	#### Receipt
	82
	83	A lightweight typed runtime signal emitted when an async milestone completes. See [RuntimeReceiptBus.ts][13].
	84	Examples include `checkpoint.baseline.captured`, `checkpoint.diff.finalized`, and `turn.processing.quiesced`, which are emitted by flows such as [CheckpointReactor.ts][6].
	85
	86	#### Quiesced
	87
	88	"Quiesced" means a turn has gone quiet and stable. In [the receipt schema][13], it means the follow-up work has settled, including work in [CheckpointReactor.ts][6].
	89
	90	### Provider runtime
	91
	92	The live backend agent implementation and its event stream. The main service is [ProviderService.ts][14], the adapter contract is [ProviderAdapter.ts][15], and the overview is in [provider-architecture.md][16].
	93
	94	#### Provider
	95
	96	The backend agent runtime that actually performs work. See [ProviderService.ts][14], [ProviderAdapter.ts][15], and [CodexAdapter.ts][17].
	97
	98	#### Session
	99
	100	The live provider-backed runtime attached to a thread. Session shape is in [the orchestration contracts][1], and lifecycle is managed in [ProviderService.ts][14].
	101
	102	#### Runtime mode
	103
	104	The safety/access mode for a thread or session. In [the contracts][1], the main values are `approval-required` and `full-access`. See [runtime-modes.md][18].
	105
	106	#### Interaction mode
	107
	108	The agent interaction style for a thread. In [the contracts][1], the main values are `default` and `plan`. See [runtime-modes.md][18].
	109
	110	#### Assistant delivery mode
	111
	112	Controls how assistant text reaches the thread timeline. In [the contracts][1], `streaming` updates incrementally and `buffered` delivers a completed result. See [ProviderService.ts][14].
	113
	114	#### Snapshot
	115
	116	A point-in-time view of state. The word is used in multiple layers, including orchestration, provider, and checkpointing. See [ProjectionSnapshotQuery.ts][10], [ProviderAdapter.ts][15], and [CheckpointStore.ts][19].
	117
	118	### Checkpointing
	119
	120	Checkpointing captures workspace state over time so the app can diff turns and restore earlier points. The main pieces are [CheckpointStore.ts][19], [CheckpointDiffQuery.ts][20], and [CheckpointReactor.ts][6].
	121
	122	#### Checkpoint
	123
	124	A saved snapshot of a thread workspace at a particular turn. In practice it is a hidden Git ref in [CheckpointStore.ts][19] plus a projected summary from [ProjectionCheckpoints.ts][21]. Capture and lifecycle work happen in [CheckpointReactor.ts][6].
	125
	126	#### Checkpoint ref
	127
	128	The durable identifier for a filesystem checkpoint, stored as a Git ref. It is typed in [the contracts][1], constructed in [Utils.ts][22], and used by [CheckpointStore.ts][19].
	129
	130	#### Checkpoint baseline
	131
	132	The starting checkpoint for diffing a thread timeline. This flow is surfaced through [RuntimeReceiptBus.ts][13], coordinated in [CheckpointReactor.ts][6], and supported by [Utils.ts][22].
	133
	134	#### Checkpoint diff
	135
	136	The patch difference between two checkpoints. Query logic lives in [CheckpointDiffQuery.ts][20], diff parsing lives in [Diffs.ts][23], and finalization is coordinated by [CheckpointReactor.ts][6].
	137
	138	#### Turn diff
	139
	140	The file patch and changed-file summary for one turn. It is usually computed in [CheckpointDiffQuery.ts][20], represented in [the contracts][1], and recorded into thread state by [projector.ts][4].
	141
	142	## Practical Shortcuts
	143
	144	- If you see `requested`, think "intent recorded".
	145	- If you see `completed`, think "result applied".
	146	- If you see `receipt`, think "async milestone signal".
	147	- If you see `checkpoint`, think "workspace snapshot for diff/restore".
	148	- If you see `quiesced`, think "all relevant follow-up work has gone idle".
	149
	150	## Related Docs
	151
	152	- [architecture.md][24]
	153	- [provider-architecture.md][16]
	154	- [runtime-modes.md][18]
	155	- [workspace-layout.md][2]
	156
	157	[1]: ../packages/contracts/src/orchestration.ts
	158	[2]: ./workspace-layout.md
	159	[3]: ../apps/server/src/git/Layers/GitCore.ts
	160	[4]: ../apps/server/src/orchestration/projector.ts
	161	[5]: ../apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts
	162	[6]: ../apps/server/src/orchestration/Layers/CheckpointReactor.ts
	163	[7]: ../apps/server/src/orchestration/Layers/OrchestrationEngine.ts
	164	[8]: ../apps/server/src/orchestration/decider.ts
	165	[9]: ../apps/server/src/orchestration/commandInvariants.ts
	166	[10]: ../apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts
	167	[11]: ../apps/server/src/orchestration/Layers/ProjectionPipeline.ts
	168	[12]: ../apps/server/src/orchestration/Layers/ProviderCommandReactor.ts
	169	[13]: ../apps/server/src/orchestration/Services/RuntimeReceiptBus.ts
	170	[14]: ../apps/server/src/provider/Layers/ProviderService.ts
	171	[15]: ../apps/server/src/provider/Services/ProviderAdapter.ts
	172	[16]: ./provider-architecture.md
	173	[17]: ../apps/server/src/provider/Layers/CodexAdapter.ts
	174	[18]: ./runtime-modes.md
	175	[19]: ../apps/server/src/checkpointing/Services/CheckpointStore.ts
	176	[20]: ../apps/server/src/checkpointing/Services/CheckpointDiffQuery.ts
	177	[21]: ../apps/server/src/persistence/Services/ProjectionCheckpoints.ts
	178	[22]: ../apps/server/src/checkpointing/Utils.ts
	179	[23]: ../apps/server/src/checkpointing/Diffs.ts
	180	[24]: ./architecture.md

.github/VOUCHED.td+28−0

@@ -0,0 +1,28 @@
	1	# Trust list for this repository.
	2	#
	3	# External contributors listed here are treated as trusted by the vouch
	4	# workflow. Collaborators with write access are automatically trusted and
	5	# do not need to be duplicated in this file.
	6	#
	7	# Syntax:
	8	# github:username
	9	# -github:username reason for denouncement
	10	#
	11	# Keep entries sorted alphabetically.
	12	github:adityavardhansharma
	13	github:binbandit
	14	github:chuks-qua
	15	github:cursoragent
	16	github:gbarros-dev
	17	github:github-actions[bot]
	18	github:hwanseoc
	19	github:jamesx0416
	20	github:jasonLaster
	21	github:JoeEverest
	22	github:nmggithub
	23	github:Noojuno
	24	github:notkainoa
	25	github:PatrickBauer
	26	github:realAhmedRoach
	27	github:shiroyasha9
	28	github:Yash-Singh1

.github/pull_request_template.md+33−0

@@ -0,0 +1,33 @@
	1	<!--
	2	⚠️ READ BEFORE OPENING ⚠️
	3
	4	We are not actively accepting contributions right now.
	5
	6	You can still open a PR, but please do so knowing there is a high chance
	7	we may close it without merging it, or never review it.
	8
	9	- Small, focused PRs are strongly preferred. Bug fixes are most likely to be merged.
	10	- New features will most likely just annoy us.
	11	- 1,000+ line PRs with a bunch of new features will probably get you banned from the repo.
	12	-->
	13
	14	## What Changed
	15
	16	<!-- Describe the change clearly and keep scope tight. -->
	17
	18	## Why
	19
	20	<!-- Explain the problem being solved and why this approach is the right one. -->
	21
	22	## UI Changes
	23
	24	<!-- If this PR changes UI, include clear before/after screenshots.
	25	If the change involves motion or interaction, include a short video.
	26	Delete this section if not applicable. -->
	27
	28	## Checklist
	29
	30	- [ ] This PR is small and focused
	31	- [ ] I explained what changed and why
	32	- [ ] I included before/after screenshots for any UI changes
	33	- [ ] I included a video for animation/interaction changes

.github/workflows/ci.yml+20−0

@@ -69,3 +69,23 @@ jobs: · 68 unmodified lines
69	run: \|	69	run: \|
70	test -f apps/desktop/dist-electron/preload.js	70	test -f apps/desktop/dist-electron/preload.js
71	grep -nE "desktopBridge\|getWsUrl\|PICK_FOLDER_CHANNEL\|wsUrl" apps/desktop/dist-electron/preload.js	71	grep -nE "desktopBridge\|getWsUrl\|PICK_FOLDER_CHANNEL\|wsUrl" apps/desktop/dist-electron/preload.js
		72
		73	release_smoke:
		74	name: Release Smoke
		75	runs-on: ubuntu-24.04
		76	steps:
		77	- name: Checkout
		78	uses: actions/checkout@v4
		79
		80	- name: Setup Bun
		81	uses: oven-sh/setup-bun@v2
		82	with:
		83	bun-version-file: package.json
		84
		85	- name: Setup Node
		86	uses: actions/setup-node@v4
		87	with:
		88	node-version-file: package.json
		89
		90	- name: Exercise release-only workflow steps
		91	run: node scripts/release-smoke.ts

.github/workflows/pr-vouch.yml+175−0

@@ -0,0 +1,175 @@
	1	name: PR Vouch
	2
	3	on:
	4	pull_request_target:
	5	types: [opened, reopened, synchronize, ready_for_review, converted_to_draft]
	6	issue_comment:
	7	types: [created]
	8	push:
	9	branches:
	10	- main
	11	paths:
	12	- .github/VOUCHED.td
	13	- .github/workflows/pr-vouch.yml
	14
	15	permissions:
	16	contents: read
	17	issues: write
	18	pull-requests: write
	19
	20	jobs:
	21	collect-targets:
	22	name: Collect PR targets
	23	runs-on: ubuntu-24.04
	24	outputs:
	25	targets: ${{ steps.collect.outputs.targets }}
	26	steps:
	27	- id: collect
	28	uses: actions/github-script@v7
	29	with:
	30	script: \|
	31	if (context.eventName === "pull_request_target") {
	32	const pr = context.payload.pull_request;
	33	core.setOutput("targets", JSON.stringify([{ number: pr.number, user: pr.user.login }]));
	34	return;
	35	}
	36
	37	if (context.eventName === "issue_comment") {
	38	const issue = context.payload.issue;
	39	const body = context.payload.comment?.body ?? "";
	40	if (!issue?.pull_request \|\| !body.includes("/recheck-vouch")) {
	41	core.setOutput("targets", "[]");
	42	return;
	43	}
	44
	45	core.setOutput(
	46	"targets",
	47	JSON.stringify([{ number: issue.number, user: issue.user.login }]),
	48	);
	49	return;
	50	}
	51
	52	const pulls = await github.paginate(github.rest.pulls.list, {
	53	owner: context.repo.owner,
	54	repo: context.repo.repo,
	55	state: "open",
	56	per_page: 100,
	57	});
	58
	59	const targets = pulls.map((pull) => ({
	60	number: pull.number,
	61	user: pull.user.login,
	62	}));
	63	core.setOutput("targets", JSON.stringify(targets));
	64
	65	label:
	66	name: Label PR ${{ matrix.target.number }}
	67	needs: collect-targets
	68	if: ${{ needs.collect-targets.outputs.targets != '[]' }}
	69	runs-on: ubuntu-24.04
	70	concurrency:
	71	group: pr-vouch-${{ matrix.target.number }}
	72	cancel-in-progress: true
	73	strategy:
	74	fail-fast: false
	75	matrix:
	76	target: ${{ fromJson(needs.collect-targets.outputs.targets) }}
	77	steps:
	78	- id: vouch
	79	name: Check PR author trust
	80	uses: mitchellh/vouch/action/check-user@v1
	81	with:
	82	user: ${{ matrix.target.user }}
	83	allow-fail: true
	84	env:
	85	GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
	86
	87	- name: Sync PR labels
	88	uses: actions/github-script@v7
	89	env:
	90	PR_NUMBER: ${{ matrix.target.number }}
	91	VOUCH_STATUS: ${{ steps.vouch.outputs.status }}
	92	with:
	93	script: \|
	94	const issueNumber = Number(process.env.PR_NUMBER);
	95	const status = process.env.VOUCH_STATUS;
	96	const managedLabels = [
	97	{
	98	name: "vouch:trusted",
	99	color: "1f883d",
	100	description: "PR author is trusted by repo permissions or the VOUCHED list.",
	101	},
	102	{
	103	name: "vouch:unvouched",
	104	color: "fbca04",
	105	description: "PR author is not yet trusted in the VOUCHED list.",
	106	},
	107	{
	108	name: "vouch:denounced",
	109	color: "d1242f",
	110	description: "PR author is explicitly blocked by the VOUCHED list.",
	111	},
	112	];
	113
	114	const managedLabelNames = managedLabels.map((label) => label.name);
	115
	116	for (const label of managedLabels) {
	117	try {
	118	const { data: existing } = await github.rest.issues.getLabel({
	119	owner: context.repo.owner,
	120	repo: context.repo.repo,
	121	name: label.name,
	122	});
	123
	124	if (
	125	existing.color !== label.color \|\|
	126	(existing.description ?? "") !== label.description
	127	) {
	128	await github.rest.issues.updateLabel({
	129	owner: context.repo.owner,
	130	repo: context.repo.repo,
	131	name: label.name,
	132	color: label.color,
	133	description: label.description,
	134	});
	135	}
	136	} catch (error) {
	137	if (error.status !== 404) {
	138	throw error;
	139	}
	140
	141	await github.rest.issues.createLabel({
	142	owner: context.repo.owner,
	143	repo: context.repo.repo,
	144	name: label.name,
	145	color: label.color,
	146	description: label.description,
	147	});
	148	}
	149	}
	150
	151	const nextLabelName =
	152	status === "denounced"
	153	? "vouch:denounced"
	154	: ["bot", "collaborator", "vouched"].includes(status)
	155	? "vouch:trusted"
	156	: "vouch:unvouched";
	157
	158	const { data: currentLabels } = await github.rest.issues.listLabelsOnIssue({
	159	owner: context.repo.owner,
	160	repo: context.repo.repo,
	161	issue_number: issueNumber,
	162	});
	163
	164	const preservedLabels = currentLabels
	165	.map((label) => label.name)
	166	.filter((name) => !managedLabelNames.includes(name));
	167
	168	await github.rest.issues.setLabels({
	169	owner: context.repo.owner,
	170	repo: context.repo.repo,
	171	issue_number: issueNumber,
	172	labels: [...preservedLabels, nextLabelName],
	173	});
	174
	175	core.info(`PR #${issueNumber}: ${status} -> ${nextLabelName}`);

.github/workflows/release.yml+12−28

     needs: [preflight, build, publish_cli]
     runs-on: ubuntu-24.04
     steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.preflight.outputs.ref }}
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: package.json
       - name: Download all desktop artifacts
         uses: actions/download-artifact@v4
         with:
         name: Update version strings
         env:
           RELEASE_VERSION: ${{ needs.preflight.outputs.version }}
-        run: |
+        run: node scripts/update-release-package-versions.ts "$RELEASE_VERSION" --github-output
-          node --input-type=module -e '
-            import { appendFileSync, readFileSync, writeFileSync } from "node:fs";
-            const files = [
-              "apps/server/package.json",
-              "apps/desktop/package.json",
-              "apps/web/package.json",
-              "packages/contracts/package.json",
-            ];
-            let changed = false;
-            for (const file of files) {
-              const packageJson = JSON.parse(readFileSync(file, "utf8"));
-              if (packageJson.version !== process.env.RELEASE_VERSION) {
-                packageJson.version = process.env.RELEASE_VERSION;
-                writeFileSync(file, `${JSON.stringify(packageJson, null, 2)}\n`);
-                changed = true;
-              }
-            }
-            if (!changed) {
-              console.log("All package.json versions already match release version.");
-            }
-            appendFileSync(process.env.GITHUB_OUTPUT, `changed=${changed}\n`);
-          '
       - name: Format package.json files
         if: steps.update_versions.outputs.changed == 'true'
       - name: Refresh lockfile
         if: steps.update_versions.outputs.changed == 'true'
-        run: bun install
+        run: bun install --lockfile-only --ignore-scripts
       - name: Commit and push version bump
         if: steps.update_versions.outputs.changed == 'true'

CONTRIBUTING.md+65−0

@@ -0,0 +1,65 @@
	1	# Contributing
	2
	3	## Read This First
	4
	5	We are not actively accepting contributions right now.
	6
	7	You can still open an issue or PR, but please do so knowing there is a high chance we close it, defer it forever, or never look at it.
	8
	9	If that sounds annoying, that is because it is. This project is still early and we are trying to keep scope, quality, and direction under control.
	10
	11	PRs are automatically labeled with a `vouch:*` trust status.
	12
	13	If you are an external contributor, expect `vouch:unvouched` until we explicitly add you to [.github/VOUCHED.td](.github/VOUCHED.td).
	14
	15	## What We Are Most Likely To Accept
	16
	17	Small, focused bug fixes.
	18
	19	Small reliability fixes.
	20
	21	Small performance improvements.
	22
	23	Tightly scoped maintenance work that clearly improves the project without changing its direction.
	24
	25	## What We Are Least Likely To Accept
	26
	27	Large PRs.
	28
	29	Drive-by feature work.
	30
	31	Opinionated rewrites.
	32
	33	Anything that expands product scope without us asking for it first.
	34
	35	If you open a 1,000+ line PR full of new features, we will probably close it quickly and remember that you ignored the clearly written instructions.
	36
	37	## If You Still Want To Open A PR
	38
	39	Keep it small.
	40
	41	Explain exactly what changed.
	42
	43	Explain exactly why the change should exist.
	44
	45	Do not mix unrelated fixes together.
	46
	47	If the PR makes anything resembling a UI change, include clear before/after images.
	48
	49	If the change depends on motion, timing, transitions, or interaction details, include a short video.
	50
	51	If we have to guess what changed, we are much less likely to review it.
	52
	53	## Issues First
	54
	55	If you are thinking about a non-trivial change, open an issue first.
	56
	57	That still does not mean we will want the PR, but it gives you a chance to avoid wasting your time.
	58
	59	## Be Realistic
	60
	61	Opening a PR does not create an obligation on our side.
	62
	63	We may close it. We may ignore it. We may ask you to shrink it. We may reimplement the idea ourselves later.
	64
	65	If you are fine with that, proceed.

README.md+4−0

@@ -21,4 +21,8 @@ We are very very early in this project. Expect bugs. · 20 unmodified lines
21		21
22	We are not accepting contributions yet.	22	We are not accepting contributions yet.
23		23
		24	## If you REALLY want to contribute still.... read this first
		25
		26	Read [CONTRIBUTING.md](./CONTRIBUTING.md) before opening an issue or PR.
		27
24	Need support? Join the [Discord](https://discord.gg/jn4EGJjrvv).	28	Need support? Join the [Discord](https://discord.gg/jn4EGJjrvv).

apps/desktop/package.json+1−1

@@ -1,6 +1,6 @@
1	{	1	{
2	"name": "@t3tools/desktop",	2	"name": "@t3tools/desktop",
3	"version": "0.0.5",	3	"version": "0.0.9",
4	"private": true,	4	"private": true,
5	"main": "dist-electron/main.js",	5	"main": "dist-electron/main.js",
6	"scripts": {	6	"scripts": {

apps/desktop/src/main.ts+110−16

@@ -31,6 +31,7 @@ import { · 30 unmodified lines
31	reduceDesktopUpdateStateOnNoUpdate,	31	reduceDesktopUpdateStateOnNoUpdate,
32	reduceDesktopUpdateStateOnUpdateAvailable,	32	reduceDesktopUpdateStateOnUpdateAvailable,
33	} from "./updateMachine";	33	} from "./updateMachine";
		34	import { isArm64HostRunningIntelBuild, resolveDesktopRuntimeInfo } from "./runtimeArch";
34		35
35	fixPath();	36	fixPath();
36		37
@@ -50,6 +51,8 @@ const ROOT_DIR = Path.resolve(__dirname, "../../.."); · 13 unmodified lines
50	const isDevelopment = Boolean(process.env.VITE_DEV_SERVER_URL);	51	const isDevelopment = Boolean(process.env.VITE_DEV_SERVER_URL);
51	const APP_DISPLAY_NAME = isDevelopment ? "T3 Code (Dev)" : "T3 Code (Alpha)";	52	const APP_DISPLAY_NAME = isDevelopment ? "T3 Code (Dev)" : "T3 Code (Alpha)";
52	const APP_USER_MODEL_ID = "com.t3tools.t3code";	53	const APP_USER_MODEL_ID = "com.t3tools.t3code";
		54	const USER_DATA_DIR_NAME = isDevelopment ? "t3code-dev" : "t3code";
		55	const LEGACY_USER_DATA_DIR_NAME = isDevelopment ? "T3 Code (Dev)" : "T3 Code (Alpha)";
53	const COMMIT_HASH_PATTERN = /^[0-9a-f]{7,40}$/i;	56	const COMMIT_HASH_PATTERN = /^[0-9a-f]{7,40}$/i;
54	const COMMIT_HASH_DISPLAY_LENGTH = 12;	57	const COMMIT_HASH_DISPLAY_LENGTH = 12;
55	const LOG_DIR = Path.join(STATE_DIR, "logs");	58	const LOG_DIR = Path.join(STATE_DIR, "logs");
@@ -78,7 +81,13 @@ let backendLogSink: RotatingFileSink \| null = null; · 22 unmodified lines
78	let restoreStdIoCapture: (() => void) \| null = null;	81	let restoreStdIoCapture: (() => void) \| null = null;
79		82
80	let destructiveMenuIconCache: Electron.NativeImage \| null \| undefined;	83	let destructiveMenuIconCache: Electron.NativeImage \| null \| undefined;
81	const initialUpdateState = (): DesktopUpdateState => createInitialDesktopUpdateState(app.getVersion());	84	const desktopRuntimeInfo = resolveDesktopRuntimeInfo({
		85	platform: process.platform,
		86	processArch: process.arch,
		87	runningUnderArm64Translation: app.runningUnderARM64Translation === true,
		88	});
		89	const initialUpdateState = (): DesktopUpdateState =>
		90	createInitialDesktopUpdateState(app.getVersion(), desktopRuntimeInfo);
82		91
83	function logTimestamp(): string {	92	function logTimestamp(): string {
84	return new Date().toISOString();	93	return new Date().toISOString();
@@ -112,6 +121,25 @@ function formatErrorMessage(error: unknown): string { · 27 unmodified lines
112	return String(error);	121	return String(error);
113	}	122	}
114		123
		124	function getSafeExternalUrl(rawUrl: unknown): string \| null {
		125	if (typeof rawUrl !== "string" \|\| rawUrl.length === 0) {
		126	return null;
		127	}
		128
		129	let parsedUrl: URL;
		130	try {
		131	parsedUrl = new URL(rawUrl);
		132	} catch {
		133	return null;
		134	}
		135
		136	if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") {
		137	return null;
		138	}
		139
		140	return parsedUrl.toString();
		141	}
		142
115	function writeDesktopStreamChunk(	143	function writeDesktopStreamChunk(
116	streamName: "stdout" \| "stderr",	144	streamName: "stdout" \| "stderr",
117	chunk: unknown,	145	chunk: unknown,
@@ -574,6 +602,34 @@ function resolveIconPath(ext: "ico" \| "icns" \| "png"): string \| null { · 456 unmodified lines
574	return resolveResourcePath(`icon.${ext}`);	602	return resolveResourcePath(`icon.${ext}`);
575	}	603	}
576		604
		605	/**
		606	* Resolve the Electron userData directory path.
		607	*
		608	* Electron derives the default userData path from `productName` in
		609	* package.json, which currently produces directories with spaces and
		610	* parentheses (e.g. `~/.config/T3 Code (Alpha)` on Linux). This is
		611	* unfriendly for shell usage and violates Linux naming conventions.
		612	*
		613	* We override it to a clean lowercase name (`t3code`). If the legacy
		614	* directory already exists we keep using it so existing users don't
		615	* lose their Chromium profile data (localStorage, cookies, sessions).
		616	*/
		617	function resolveUserDataPath(): string {
		618	const appDataBase =
		619	process.platform === "win32"
		620	? process.env.APPDATA \|\| Path.join(OS.homedir(), "AppData", "Roaming")
		621	: process.platform === "darwin"
		622	? Path.join(OS.homedir(), "Library", "Application Support")
		623	: process.env.XDG_CONFIG_HOME \|\| Path.join(OS.homedir(), ".config");
		624
		625	const legacyPath = Path.join(appDataBase, LEGACY_USER_DATA_DIR_NAME);
		626	if (FS.existsSync(legacyPath)) {
		627	return legacyPath;
		628	}
		629
		630	return Path.join(appDataBase, USER_DATA_DIR_NAME);
		631	}
		632
577	function configureAppIdentity(): void {	633	function configureAppIdentity(): void {
578	app.setName(APP_DISPLAY_NAME);	634	app.setName(APP_DISPLAY_NAME);
579	const commitHash = resolveAboutCommitHash();	635	const commitHash = resolveAboutCommitHash();
@@ -659,6 +715,7 @@ async function downloadAvailableUpdate(): Promise<{ accepted: boolean; completed · 79 unmodified lines
659	}	715	}
660	updateDownloadInFlight = true;	716	updateDownloadInFlight = true;
661	setUpdateState(reduceDesktopUpdateStateOnDownloadStart(updateState));	717	setUpdateState(reduceDesktopUpdateStateOnDownloadStart(updateState));
		718	autoUpdater.disableDifferentialDownload = isArm64HostRunningIntelBuild(desktopRuntimeInfo);
662	console.info("[desktop-updater] Downloading update...");	719	console.info("[desktop-updater] Downloading update...");
663		720
664	try {	721	try {
@@ -697,7 +754,7 @@ async function installDownloadedUpdate(): Promise<{ accepted: boolean; completed · 32 unmodified lines
697	function configureAutoUpdater(): void {	754	function configureAutoUpdater(): void {
698	const enabled = shouldEnableAutoUpdates();	755	const enabled = shouldEnableAutoUpdates();
699	setUpdateState({	756	setUpdateState({
700	...createInitialDesktopUpdateState(app.getVersion()),	757	...createInitialDesktopUpdateState(app.getVersion(), desktopRuntimeInfo),
701	enabled,	758	enabled,
702	status: enabled ? "idle" : "disabled",	759	status: enabled ? "idle" : "disabled",
703	});	760	});
@@ -731,8 +788,15 @@ function configureAutoUpdater(): void { · 27 unmodified lines
731	autoUpdater.channel = DESKTOP_UPDATE_CHANNEL;	788	autoUpdater.channel = DESKTOP_UPDATE_CHANNEL;
732	autoUpdater.allowPrerelease = DESKTOP_UPDATE_ALLOW_PRERELEASE;	789	autoUpdater.allowPrerelease = DESKTOP_UPDATE_ALLOW_PRERELEASE;
733	autoUpdater.allowDowngrade = false;	790	autoUpdater.allowDowngrade = false;
		791	autoUpdater.disableDifferentialDownload = isArm64HostRunningIntelBuild(desktopRuntimeInfo);
734	let lastLoggedDownloadMilestone = -1;	792	let lastLoggedDownloadMilestone = -1;
735		793
		794	if (isArm64HostRunningIntelBuild(desktopRuntimeInfo)) {
		795	console.info(
		796	"[desktop-updater] Apple Silicon host detected while running Intel build; updates will switch to arm64 packages.",
		797	);
		798	}
		799
736	autoUpdater.on("checking-for-update", () => {	800	autoUpdater.on("checking-for-update", () => {
737	console.info("[desktop-updater] Looking for updates...");	801	console.info("[desktop-updater] Looking for updates...");
738	});	802	});
@@ -1033,23 +1097,13 @@ function registerIpcHandlers(): void { · 294 unmodified lines
1033		1097
1034	ipcMain.removeHandler(OPEN_EXTERNAL_CHANNEL);	1098	ipcMain.removeHandler(OPEN_EXTERNAL_CHANNEL);
1035	ipcMain.handle(OPEN_EXTERNAL_CHANNEL, async (_event, rawUrl: unknown) => {	1099	ipcMain.handle(OPEN_EXTERNAL_CHANNEL, async (_event, rawUrl: unknown) => {
1036	if (typeof rawUrl !== "string" \|\| rawUrl.length === 0) {	1100	const externalUrl = getSafeExternalUrl(rawUrl);
1037	return false;	1101	if (!externalUrl) {
1038	}
1039
1040	let parsedUrl: URL;
1041	try {
1042	parsedUrl = new URL(rawUrl);
1043	} catch {
1044	return false;
1045	}
1046
1047	if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") {
1048	return false;	1102	return false;
1049	}	1103	}
1050		1104
1051	try {	1105	try {
1052	await shell.openExternal(parsedUrl.toString());	1106	await shell.openExternal(externalUrl);
1053	return true;	1107	return true;
1054	} catch {	1108	} catch {
1055	return false;	1109	return false;
@@ -1114,7 +1168,42 @@ function createWindow(): BrowserWindow { · 58 unmodified lines
1114	},	1168	},
1115	});	1169	});
1116		1170
1117	window.webContents.setWindowOpenHandler(() => ({ action: "deny" }));	1171	window.webContents.on("context-menu", (event, params) => {
		1172	event.preventDefault();
		1173
		1174	const menuTemplate: MenuItemConstructorOptions[] = [];
		1175
		1176	if (params.misspelledWord) {
		1177	for (const suggestion of params.dictionarySuggestions.slice(0, 5)) {
		1178	menuTemplate.push({
		1179	label: suggestion,
		1180	click: () => window.webContents.replaceMisspelling(suggestion),
		1181	});
		1182	}
		1183	if (params.dictionarySuggestions.length === 0) {
		1184	menuTemplate.push({ label: "No suggestions", enabled: false });
		1185	}
		1186	menuTemplate.push({ type: "separator" });
		1187	}
		1188
		1189	menuTemplate.push(
		1190	{ role: "cut", enabled: params.editFlags.canCut },
		1191	{ role: "copy", enabled: params.editFlags.canCopy },
		1192	{ role: "paste", enabled: params.editFlags.canPaste },
		1193	{ role: "selectAll", enabled: params.editFlags.canSelectAll },
		1194	);
		1195
		1196	Menu.buildFromTemplate(menuTemplate).popup({ window });
		1197	});
		1198
		1199	window.webContents.setWindowOpenHandler(({ url }) => {
		1200	const externalUrl = getSafeExternalUrl(url);
		1201	if (externalUrl) {
		1202	void shell.openExternal(externalUrl);
		1203	}
		1204	return { action: "deny" };
		1205	});
		1206
1118	window.on("page-title-updated", (event) => {	1207	window.on("page-title-updated", (event) => {
1119	event.preventDefault();	1208	event.preventDefault();
1120	window.setTitle(APP_DISPLAY_NAME);	1209	window.setTitle(APP_DISPLAY_NAME);
@@ -1143,6 +1232,11 @@ function createWindow(): BrowserWindow { · 22 unmodified lines
1143	return window;	1232	return window;
1144	}	1233	}
1145		1234
		1235	// Override Electron's userData path before the `ready` event so that
		1236	// Chromium session data uses a filesystem-friendly directory name.
		1237	// Must be called synchronously at the top level — before `app.whenReady()`.
		1238	app.setPath("userData", resolveUserDataPath());
		1239
1146	configureAppIdentity();	1240	configureAppIdentity();
1147		1241
1148	async function bootstrap(): Promise<void> {	1242	async function bootstrap(): Promise<void> {

apps/desktop/src/runtimeArch.test.ts+49−0

@@ -0,0 +1,49 @@
	1	import { describe, expect, it } from "vitest";
	2
	3	import { isArm64HostRunningIntelBuild, resolveDesktopRuntimeInfo } from "./runtimeArch";
	4
	5	describe("resolveDesktopRuntimeInfo", () => {
	6	it("detects Rosetta-translated Intel builds on Apple Silicon", () => {
	7	const runtimeInfo = resolveDesktopRuntimeInfo({
	8	platform: "darwin",
	9	processArch: "x64",
	10	runningUnderArm64Translation: true,
	11	});
	12
	13	expect(runtimeInfo).toEqual({
	14	hostArch: "arm64",
	15	appArch: "x64",
	16	runningUnderArm64Translation: true,
	17	});
	18	expect(isArm64HostRunningIntelBuild(runtimeInfo)).toBe(true);
	19	});
	20
	21	it("detects native Apple Silicon builds", () => {
	22	const runtimeInfo = resolveDesktopRuntimeInfo({
	23	platform: "darwin",
	24	processArch: "arm64",
	25	runningUnderArm64Translation: false,
	26	});
	27
	28	expect(runtimeInfo).toEqual({
	29	hostArch: "arm64",
	30	appArch: "arm64",
	31	runningUnderArm64Translation: false,
	32	});
	33	expect(isArm64HostRunningIntelBuild(runtimeInfo)).toBe(false);
	34	});
	35
	36	it("passes through non-mac builds without translation", () => {
	37	const runtimeInfo = resolveDesktopRuntimeInfo({
	38	platform: "linux",
	39	processArch: "x64",
	40	runningUnderArm64Translation: true,
	41	});
	42
	43	expect(runtimeInfo).toEqual({
	44	hostArch: "x64",
	45	appArch: "x64",
	46	runningUnderArm64Translation: false,
	47	});
	48	});
	49	});

apps/desktop/src/runtimeArch.ts+40−0

@@ -0,0 +1,40 @@
	1	import type { DesktopRuntimeArch, DesktopRuntimeInfo } from "@t3tools/contracts";
	2
	3	interface ResolveDesktopRuntimeInfoInput {
	4	readonly platform: NodeJS.Platform;
	5	readonly processArch: string;
	6	readonly runningUnderArm64Translation: boolean;
	7	}
	8
	9	function normalizeDesktopArch(arch: string): DesktopRuntimeArch {
	10	if (arch === "arm64") return "arm64";
	11	if (arch === "x64") return "x64";
	12	return "other";
	13	}
	14
	15	export function resolveDesktopRuntimeInfo(
	16	input: ResolveDesktopRuntimeInfoInput,
	17	): DesktopRuntimeInfo {
	18	const appArch = normalizeDesktopArch(input.processArch);
	19
	20	if (input.platform !== "darwin") {
	21	return {
	22	hostArch: appArch,
	23	appArch,
	24	runningUnderArm64Translation: false,
	25	};
	26	}
	27
	28	const hostArch =
	29	appArch === "arm64" \|\| input.runningUnderArm64Translation ? "arm64" : appArch;
	30
	31	return {
	32	hostArch,
	33	appArch,
	34	runningUnderArm64Translation: input.runningUnderArm64Translation,
	35	};
	36	}
	37
	38	export function isArm64HostRunningIntelBuild(runtimeInfo: DesktopRuntimeInfo): boolean {
	39	return runtimeInfo.hostArch === "arm64" && runtimeInfo.appArch === "x64";
	40	}

apps/desktop/src/updateMachine.test.ts+12−6

   reduceDesktopUpdateStateOnUpdateAvailable,
 } from "./updateMachine";
+const runtimeInfo = {
+  hostArch: "x64",
+  appArch: "x64",
+  runningUnderArm64Translation: false,
+} as const;
 describe("updateMachine", () => {
   it("clears transient errors when a check starts", () => {
     const state = reduceDesktopUpdateStateOnCheckStart(
       {
-        ...createInitialDesktopUpdateState("1.0.0"),
+        ...createInitialDesktopUpdateState("1.0.0", runtimeInfo),
         enabled: true,
         status: "error",
         message: "network",
   it("records a check failure without exposing an action", () => {
     const state = reduceDesktopUpdateStateOnCheckFailure(
       {
-        ...createInitialDesktopUpdateState("1.0.0"),
+        ...createInitialDesktopUpdateState("1.0.0", runtimeInfo),
         enabled: true,
         status: "checking",
       },
   it("preserves available version on download failure for retry", () => {
     const state = reduceDesktopUpdateStateOnDownloadFailure(
       {
-        ...createInitialDesktopUpdateState("1.0.0"),
+        ...createInitialDesktopUpdateState("1.0.0", runtimeInfo),
         enabled: true,
         status: "downloading",
         availableVersion: "1.1.0",
   it("transitions to downloaded and then preserves install retry state", () => {
     const downloaded = reduceDesktopUpdateStateOnDownloadComplete(
       {
-        ...createInitialDesktopUpdateState("1.0.0"),
+        ...createInitialDesktopUpdateState("1.0.0", runtimeInfo),
         enabled: true,
         status: "downloading",
         availableVersion: "1.1.0",
   it("clears stale download state when no update is available", () => {
     const state = reduceDesktopUpdateStateOnNoUpdate(
       {
-        ...createInitialDesktopUpdateState("1.0.0"),
+        ...createInitialDesktopUpdateState("1.0.0", runtimeInfo),
         enabled: true,
         status: "error",
         availableVersion: "1.1.0",
   it("tracks available, download start, and progress cleanly", () => {
     const available = reduceDesktopUpdateStateOnUpdateAvailable(
       {
-        ...createInitialDesktopUpdateState("1.0.0"),
+        ...createInitialDesktopUpdateState("1.0.0", runtimeInfo),
         enabled: true,
         status: "checking",
       },

apps/desktop/src/updateMachine.ts+8−3

-import type { DesktopUpdateState } from "@t3tools/contracts";
+import type { DesktopRuntimeInfo, DesktopUpdateState } from "@t3tools/contracts";
 import { getCanRetryAfterDownloadFailure, nextStatusAfterDownloadFailure } from "./updateState";
-export function createInitialDesktopUpdateState(currentVersion: string): DesktopUpdateState {
+export function createInitialDesktopUpdateState(
+  currentVersion: string,
+  runtimeInfo: DesktopRuntimeInfo,
+): DesktopUpdateState {
   return {
     enabled: false,
     status: "disabled",
     currentVersion,
+    hostArch: runtimeInfo.hostArch,
+    appArch: runtimeInfo.appArch,
+    runningUnderArm64Translation: runtimeInfo.runningUnderArm64Translation,
     availableVersion: null,
     downloadedVersion: null,
     downloadPercent: null,
     canRetry: true,
   };
 }

apps/desktop/src/updateState.test.ts+3−0

   enabled: true,
   status: "idle",
   currentVersion: "1.0.0",
+  hostArch: "x64",
+  appArch: "x64",
+  runningUnderArm64Translation: false,
   availableVersion: null,
   downloadedVersion: null,
   downloadPercent: null,

apps/marketing/src/pages/index.astro+1−3

     const ua = navigator.userAgent;
     if (/Win/i.test(ua)) return { os: "win", label: "Download for Windows" };
     if (/Mac/i.test(ua)) {
-      const isArm =
-        /arm|aarch/i.test(navigator.platform ?? "") || ua.includes("ARM");
       return {
         os: "mac",
         label: `Download for macOS`,
-        arch: isArm ? "arm64" : "x64",
+        arch: "arm64",
       };
     }
     if (/Linux/i.test(ua)) return { os: "linux", label: "Download for Linux" };

apps/server/package.json+1−1

@@ -1,6 +1,6 @@
1	{	1	{
2	"name": "t3",	2	"name": "t3",
3	"version": "0.0.5",	3	"version": "0.0.9",
4	"repository": {	4	"repository": {
5	"type": "git",	5	"type": "git",
6	"url": "https://github.com/pingdotgg/t3code",	6	"url": "https://github.com/pingdotgg/t3code",

apps/server/scripts/cli.ts+2−0

           cwd: serverDir,
           stdout: config.verbose ? "inherit" : "ignore",
           stderr: "inherit",
+          // Windows needs shell mode to resolve .cmd shims (e.g. bun.cmd).
           shell: process.platform === "win32",
         })`bun tsdown`,
       );
                 cwd: serverDir,
                 stdout: config.verbose ? "inherit" : "ignore",
                 stderr: "inherit",
+                // Windows needs shell mode to resolve .cmd shims.
                 shell: process.platform === "win32",
               }),
             );

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

   type OrchestrationEvent,
   type ProviderModelOptions,
   type ProviderKind,
-  type ProviderServiceTier,
   type ProviderStartOptions,
   type OrchestrationSession,
   ThreadId,
       readonly provider?: ProviderKind;
       readonly model?: string;
       readonly modelOptions?: ProviderModelOptions;
-      readonly serviceTier?: ProviderServiceTier | null;
       readonly providerOptions?: ProviderStartOptions;
     },
   ) {
           : {}),
         ...(effectiveCwd ? { cwd: effectiveCwd } : {}),
         ...(desiredModel ? { model: desiredModel } : {}),
-        ...(options?.serviceTier !== undefined ? { serviceTier: options.serviceTier } : {}),
         ...(options?.modelOptions !== undefined ? { modelOptions: options.modelOptions } : {}),
         ...(options?.providerOptions !== undefined ? { providerOptions: options.providerOptions } : {}),
         ...(input?.resumeCursor !== undefined ? { resumeCursor: input.resumeCursor } : {}),
     readonly attachments?: ReadonlyArray<ChatAttachment>;
     readonly provider?: ProviderKind;
     readonly model?: string;
-    readonly serviceTier?: ProviderServiceTier | null;
     readonly modelOptions?: ProviderModelOptions;
     readonly providerOptions?: ProviderStartOptions;
     readonly interactionMode?: "default" | "plan";
     yield* ensureSessionForThread(input.threadId, input.createdAt, {
       ...(input.provider !== undefined ? { provider: input.provider } : {}),
       ...(input.model !== undefined ? { model: input.model } : {}),
-      ...(input.serviceTier !== undefined ? { serviceTier: input.serviceTier } : {}),
       ...(input.modelOptions !== undefined ? { modelOptions: input.modelOptions } : {}),
       ...(input.providerOptions !== undefined ? { providerOptions: input.providerOptions } : {}),
     });
       ...(normalizedInput ? { input: normalizedInput } : {}),
       ...(normalizedAttachments.length > 0 ? { attachments: normalizedAttachments } : {}),
       ...(modelForTurn !== undefined ? { model: modelForTurn } : {}),
-      ...(input.serviceTier !== undefined ? { serviceTier: input.serviceTier } : {}),
       ...(input.modelOptions !== undefined ? { modelOptions: input.modelOptions } : {}),
       ...(input.interactionMode !== undefined ? { interactionMode: input.interactionMode } : {}),
     });
       ...(message.attachments !== undefined ? { attachments: message.attachments } : {}),
       ...(event.payload.provider !== undefined ? { provider: event.payload.provider } : {}),
       ...(event.payload.model !== undefined ? { model: event.payload.model } : {}),
-      ...(event.payload.serviceTier !== undefined
-        ? { serviceTier: event.payload.serviceTier }
-        : {}),
       ...(event.payload.modelOptions !== undefined
         ? { modelOptions: event.payload.modelOptions }
         : {}),

apps/server/src/orchestration/decider.ts+0−1

@@ -301,7 +301,6 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" · 300 unmodified lines
301	messageId: command.message.messageId,	301	messageId: command.message.messageId,
302	...(command.provider !== undefined ? { provider: command.provider } : {}),	302	...(command.provider !== undefined ? { provider: command.provider } : {}),
303	...(command.model !== undefined ? { model: command.model } : {}),	303	...(command.model !== undefined ? { model: command.model } : {}),
304	...(command.serviceTier !== undefined ? { serviceTier: command.serviceTier } : {}),
305	...(command.modelOptions !== undefined ? { modelOptions: command.modelOptions } : {}),	304	...(command.modelOptions !== undefined ? { modelOptions: command.modelOptions } : {}),
306	...(command.providerOptions !== undefined ? { providerOptions: command.providerOptions } : {}),	305	...(command.providerOptions !== undefined ? { providerOptions: command.providerOptions } : {}),
307	assistantDeliveryMode: command.assistantDeliveryMode ?? DEFAULT_ASSISTANT_DELIVERY_MODE,	306	assistantDeliveryMode: command.assistantDeliveryMode ?? DEFAULT_ASSISTANT_DELIVERY_MODE,

apps/server/src/provider/Layers/CodexAdapter.ts+0−1

@@ -1354,7 +1354,6 @@ const makeCodexAdapter = (options?: CodexAdapterLiveOptions) => · 1353 unmodified lines
1354	threadId: input.threadId,	1354	threadId: input.threadId,
1355	...(input.input !== undefined ? { input: input.input } : {}),	1355	...(input.input !== undefined ? { input: input.input } : {}),
1356	...(input.model !== undefined ? { model: input.model } : {}),	1356	...(input.model !== undefined ? { model: input.model } : {}),
1357	...(input.serviceTier !== undefined ? { serviceTier: input.serviceTier } : {}),
1358	...(input.modelOptions?.codex?.reasoningEffort !== undefined	1357	...(input.modelOptions?.codex?.reasoningEffort !== undefined
1359	? { effort: input.modelOptions.codex.reasoningEffort }	1358	? { effort: input.modelOptions.codex.reasoningEffort }
1360	: {}),	1359	: {}),

apps/web/package.json+1−1

@@ -1,6 +1,6 @@
1	{	1	{
2	"name": "@t3tools/web",	2	"name": "@t3tools/web",
3	"version": "0.0.5",	3	"version": "0.0.9",
4	"private": true,	4	"private": true,
5	"type": "module",	5	"type": "module",
6	"scripts": {	6	"scripts": {

apps/web/src/appSettings.test.ts+0−21

@@ -4,8 +4,6 @@ import { · 3 unmodified lines
4	getAppModelOptions,	4	getAppModelOptions,
5	getSlashModelOptions,	5	getSlashModelOptions,
6	normalizeCustomModelSlugs,	6	normalizeCustomModelSlugs,
7	resolveAppServiceTier,
8	shouldShowFastTierIcon,
9	resolveAppModelSelection,	7	resolveAppModelSelection,
10	} from "./appSettings";	8	} from "./appSettings";
11		9
@@ -84,22 +82,3 @@ describe("getSlashModelOptions", () => { · 72 unmodified lines
84	expect(options.map((option) => option.slug)).toEqual(["openai/gpt-oss-120b"]);	82	expect(options.map((option) => option.slug)).toEqual(["openai/gpt-oss-120b"]);
85	});	83	});
86	});	84	});
87
88	describe("resolveAppServiceTier", () => {
89	it("maps automatic to no override", () => {
90	expect(resolveAppServiceTier("auto")).toBeNull();
91	});
92
93	it("preserves explicit service tier overrides", () => {
94	expect(resolveAppServiceTier("fast")).toBe("fast");
95	expect(resolveAppServiceTier("flex")).toBe("flex");
96	});
97	});
98
99	describe("shouldShowFastTierIcon", () => {
100	it("shows the fast-tier icon only for gpt-5.4 on fast tier", () => {
101	expect(shouldShowFastTierIcon("gpt-5.4", "fast")).toBe(true);
102	expect(shouldShowFastTierIcon("gpt-5.4", "auto")).toBe(false);
103	expect(shouldShowFastTierIcon("gpt-5.3-codex", "fast")).toBe(false);
104	});
105	});

apps/web/src/appSettings.ts+1−38

@@ -1,31 +1,11 @@
1	import { useCallback, useSyncExternalStore } from "react";	1	import { useCallback, useSyncExternalStore } from "react";
2	import { Option, Schema } from "effect";	2	import { Option, Schema } from "effect";
3	import { type ProviderKind, type ProviderServiceTier } from "@t3tools/contracts";	3	import { type ProviderKind } from "@t3tools/contracts";
4	import { getDefaultModel, getModelOptions, normalizeModelSlug } from "@t3tools/shared/model";	4	import { getDefaultModel, getModelOptions, normalizeModelSlug } from "@t3tools/shared/model";
5		5
6	const APP_SETTINGS_STORAGE_KEY = "t3code:app-settings:v1";	6	const APP_SETTINGS_STORAGE_KEY = "t3code:app-settings:v1";
7	const MAX_CUSTOM_MODEL_COUNT = 32;	7	const MAX_CUSTOM_MODEL_COUNT = 32;
8	export const MAX_CUSTOM_MODEL_LENGTH = 256;	8	export const MAX_CUSTOM_MODEL_LENGTH = 256;
9	export const APP_SERVICE_TIER_OPTIONS = [
10	{
11	value: "auto",
12	label: "Automatic",
13	description: "Use Codex defaults without forcing a service tier.",
14	},
15	{
16	value: "fast",
17	label: "Fast",
18	description: "Request the fast service tier when the model supports it.",
19	},
20	{
21	value: "flex",
22	label: "Flex",
23	description: "Request the flex service tier when the model supports it.",
24	},
25	] as const;
26	export type AppServiceTier = (typeof APP_SERVICE_TIER_OPTIONS)[number]["value"];
27	const AppServiceTierSchema = Schema.Literals(["auto", "fast", "flex"]);
28	const MODELS_WITH_FAST_SUPPORT = new Set(["gpt-5.4"]);
29	const BUILT_IN_MODEL_SLUGS_BY_PROVIDER: Record<ProviderKind, ReadonlySet<string>> = {	9	const BUILT_IN_MODEL_SLUGS_BY_PROVIDER: Record<ProviderKind, ReadonlySet<string>> = {
30	codex: new Set(getModelOptions("codex").map((option) => option.slug)),	10	codex: new Set(getModelOptions("codex").map((option) => option.slug)),
31	};	11	};
@@ -41,7 +21,6 @@ const AppSettingsSchema = Schema.Struct({ · 9 unmodified lines
41	enableAssistantStreaming: Schema.Boolean.pipe(	21	enableAssistantStreaming: Schema.Boolean.pipe(
42	Schema.withConstructorDefault(() => Option.some(false)),	22	Schema.withConstructorDefault(() => Option.some(false)),
43	),	23	),
44	codexServiceTier: AppServiceTierSchema.pipe(Schema.withConstructorDefault(() => Option.some("auto"))),
45	customCodexModels: Schema.Array(Schema.String).pipe(	24	customCodexModels: Schema.Array(Schema.String).pipe(
46	Schema.withConstructorDefault(() => Option.some([])),	25	Schema.withConstructorDefault(() => Option.some([])),
47	),	26	),
@@ -53,22 +32,6 @@ export interface AppModelOption { · 5 unmodified lines
53	isCustom: boolean;	32	isCustom: boolean;
54	}	33	}
55		34
56	export function resolveAppServiceTier(serviceTier: AppServiceTier): ProviderServiceTier \| null {
57	return serviceTier === "auto" ? null : serviceTier;
58	}
59
60	export function shouldShowFastTierIcon(
61	model: string \| null \| undefined,
62	serviceTier: AppServiceTier,
63	): boolean {
64	const normalizedModel = normalizeModelSlug(model);
65	return (
66	resolveAppServiceTier(serviceTier) === "fast" &&
67	normalizedModel !== null &&
68	MODELS_WITH_FAST_SUPPORT.has(normalizedModel)
69	);
70	}
71
72	const DEFAULT_APP_SETTINGS = AppSettingsSchema.makeUnsafe({});	35	const DEFAULT_APP_SETTINGS = AppSettingsSchema.makeUnsafe({});
73		36
74	let listeners: Array<() => void> = [];	37	let listeners: Array<() => void> = [];

apps/web/src/components/ChatView.tsx+270−112

   buildPlanImplementationThreadTitle,
   buildPlanImplementationPrompt,
   buildProposedPlanMarkdownFilename,
+  downloadPlanAsTextFile,
+  normalizePlanMarkdownForExport,
   proposedPlanTitle,
   resolvePlanFollowUpSubmission,
 } from "../proposedPlan";
   shortcutLabelForCommand,
 } from "../keybindings";
 import ChatMarkdown from "./ChatMarkdown";
+import PlanSidebar from "./PlanSidebar";
 import ThreadTerminalDrawer from "./ThreadTerminalDrawer";
-import { Alert, AlertDescription, AlertTitle } from "./ui/alert";
+import { Alert, AlertAction, AlertDescription, AlertTitle } from "./ui/alert";
 import {
   BotIcon,
   ChevronDownIcon,
   DiffIcon,
   EllipsisIcon,
   FolderClosedIcon,
+  ListTodoIcon,
   LockIcon,
   LockOpenIcon,
   Undo2Icon,
   XIcon,
   CopyIcon,
   CheckIcon,
-  ZapIcon,
 } from "lucide-react";
 import { Button } from "./ui/button";
 import { Input } from "./ui/input";
 import {
   getAppModelOptions,
   resolveAppModelSelection,
-  resolveAppServiceTier,
-  shouldShowFastTierIcon,
-  type AppServiceTier,
   useAppSettings,
 } from "../appSettings";
 import {
   return "text-muted-foreground/40";
 }
-function normalizePlanMarkdownForExport(planMarkdown: string): string {
-  return `${planMarkdown.trimEnd()}\n`;
-}
-function downloadTextFile(filename: string, contents: string): void {
-  const blob = new Blob([contents], { type: "text/markdown;charset=utf-8" });
-  const url = URL.createObjectURL(blob);
-  const anchor = document.createElement("a");
-  anchor.href = url;
-  anchor.download = filename;
-  anchor.click();
-  window.setTimeout(() => {
-    URL.revokeObjectURL(url);
-  }, 0);
-}
 interface ExpandedImageItem {
   src: string;
       model: ModelSlug;
       label: string;
       description: string;
-      showFastBadge: boolean;
     };
 type SendPhase = "idle" | "preparing-worktree" | "sending-turn";
         </Badge>
       ) : null}
       <span className="flex min-w-0 items-center gap-1.5 truncate">
-        {props.item.type === "model" && props.item.showFastBadge ? (
-          <ZapIcon className="size-3.5 shrink-0 text-amber-500" />
-        ) : null}
         <span className="truncate">{props.item.label}</span>
       </span>
       <span className="truncate text-muted-foreground/70 text-xs">{props.item.description}</span>
   const [pendingUserInputQuestionIndexByRequestId, setPendingUserInputQuestionIndexByRequestId] =
     useState<Record<string, number>>({});
   const [expandedWorkGroups, setExpandedWorkGroups] = useState<Record<string, boolean>>({});
+  const [planSidebarOpen, setPlanSidebarOpen] = useState(false);
+  // Tracks whether the user explicitly dismissed the sidebar for the active turn.
+  const planSidebarDismissedForTurnRef = useRef<string | null>(null);
+  // When set, the thread-change reset effect will open the sidebar instead of closing it.
+  // Used by "Implement in new thread" to carry the sidebar-open intent across navigation.
+  const planSidebarOpenOnNextThreadRef = useRef(false);
   const [nowTick, setNowTick] = useState(() => Date.now());
   const [terminalFocusRequestId, setTerminalFocusRequestId] = useState(0);
   const [composerHighlightedItemId, setComposerHighlightedItemId] = useState<string | null>(null);
     composerDraft.interactionMode ?? activeThread?.interactionMode ?? DEFAULT_INTERACTION_MODE;
   const isServerThread = serverThread !== undefined;
   const isLocalDraftThread = !isServerThread && localDraftThread !== undefined;
-  const diffSearch = useMemo(
+  const diffOpen = rawSearch.diff === "1";
-    () => parseDiffRouteSearch(rawSearch as Record<string, unknown>),
-    [rawSearch],
-  );
-  const diffOpen = diffSearch.diff === "1";
   const activeThreadId = activeThread?.id ?? null;
   const activeLatestTurn = activeThread?.latestTurn ?? null;
   const latestTurnSettled = isLatestTurnSettled(activeLatestTurn, activeThread?.session ?? null);
       activeThread.messages.length > 0 ||
       activeThread.session !== null),
   );
-  const selectedServiceTierSetting = settings.codexServiceTier;
-  const selectedServiceTier = resolveAppServiceTier(selectedServiceTierSetting);
   const lockedProvider: ProviderKind | null = hasThreadStarted
     ? (sessionProvider ?? selectedProviderByThreadId ?? null)
     : null;
         model: slug,
         label: name,
         description: `${providerLabel} · ${slug}`,
-        showFastBadge:
-          provider === "codex" && shouldShowFastTierIcon(slug, selectedServiceTierSetting),
       }));
-  }, [composerTrigger, searchableModelOptions, selectedServiceTierSetting, workspaceEntries]);
+  }, [composerTrigger, searchableModelOptions, workspaceEntries]);
   const composerMenuOpen = Boolean(composerTrigger);
   const activeComposerMenuItem = useMemo(
     () =>
     },
     [activeProject, persistProjectScripts],
   );
+  const deleteProjectScript = useCallback(
+    async (scriptId: string) => {
+      if (!activeProject) return;
+      const nextScripts = activeProject.scripts.filter((script) => script.id !== scriptId);
+      const deletedName = activeProject.scripts.find((s) => s.id === scriptId)?.name;
+      try {
+        await persistProjectScripts({
+          projectId: activeProject.id,
+          projectCwd: activeProject.cwd,
+          previousScripts: activeProject.scripts,
+          nextScripts,
+          keybinding: null,
+          keybindingCommand: commandForProjectScript(scriptId),
+        });
+        toastManager.add({
+          type: "success",
+          title: `Deleted action "${deletedName ?? "Unknown"}"`,
+        });
+      } catch (error) {
+        toastManager.add({
+          type: "error",
+          title: "Could not delete action",
+          description: error instanceof Error ? error.message : "An unexpected error occurred.",
+        });
+      }
+    },
+    [activeProject, persistProjectScripts],
+  );
   const handleRuntimeModeChange = useCallback(
     (mode: RuntimeMode) => {
         "button, summary, [role='button'], [data-scroll-anchor-target]",
       );
       if (!trigger || !scrollContainer.contains(trigger)) return;
+      if (trigger.closest("[data-scroll-anchor-ignore]")) return;
       pendingInteractionAnchorRef.current = {
         element: trigger,
   useEffect(() => {
     setExpandedWorkGroups({});
+    if (planSidebarOpenOnNextThreadRef.current) {
+      planSidebarOpenOnNextThreadRef.current = false;
+      setPlanSidebarOpen(true);
+    } else {
+      setPlanSidebarOpen(false);
+    }
+    planSidebarDismissedForTurnRef.current = null;
   }, [activeThread?.id]);
   useEffect(() => {
     if (!composerMenuOpen) {
       setComposerHighlightedItemId(null);
           attachments: turnAttachments,
         },
         model: selectedModel || undefined,
-        serviceTier: selectedServiceTier,
         ...(selectedModelOptionsForDispatch
           ? { modelOptions: selectedModelOptionsForDispatch }
           : {}),
           interactionMode: nextInteractionMode,
           createdAt: messageCreatedAt,
         });
+        // Optimistically open the plan sidebar when implementing (not refining).
+        // "default" mode here means the agent is executing the plan, which produces
+        // step-tracking activities that the sidebar will display.
+        if (nextInteractionMode === "default") {
+          planSidebarDismissedForTurnRef.current = null;
+          setPlanSidebarOpen(true);
+        }
         sendInFlightRef.current = false;
       } catch (err) {
         setOptimisticUserMessages((existing) =>
       .then(() => api.orchestration.getSnapshot())
       .then((snapshot) => {
         syncServerReadModel(snapshot);
+        // Signal that the plan sidebar should open on the new thread.
+        planSidebarOpenOnNextThreadRef.current = true;
         return navigate({
           to: "/$threadId",
           params: { threadId: nextThreadId },
           }}
           onAddProjectScript={saveProjectScript}
           onUpdateProjectScript={updateProjectScript}
+          onDeleteProjectScript={deleteProjectScript}
           onToggleDiff={onToggleDiff}
         />
       </header>
       {/* Error banner */}
       <ProviderHealthBanner status={activeProviderStatus} />
-      <ThreadErrorBanner error={activeThread.error} />
+      <ThreadErrorBanner
-      <PlanModePanel activePlan={activePlan} />
+        error={activeThread.error}
+        onDismiss={() => setThreadError(activeThread.id, null)}
+      />
+      {/* Main content area with optional plan sidebar */}
+      <div className="flex min-h-0 flex-1">
+        {/* Chat column */}
+        <div className="flex min-h-0 min-w-0 flex-1 flex-col">
       {/* Messages */}
       <div
                   answers={activePendingDraftAnswers}
                   questionIndex={activePendingQuestionIndex}
                   onSelectOption={onSelectActivePendingUserInputOption}
+                  onAdvance={onAdvanceActivePendingUserInput}
                 />
               </div>
             ) : showPlanFollowUpPrompt && activeProposedPlan ? (
                     model={selectedModelForPickerWithCustomFallback}
                     lockedProvider={lockedProvider}
                     modelOptionsByProvider={modelOptionsByProvider}
-                    serviceTierSetting={selectedServiceTierSetting}
                     onProviderModelChange={onProviderModelSelect}
                   />
                       {runtimeMode === "full-access" ? "Full access" : "Supervised"}
                     </span>
                   </Button>
+                  {/* Plan sidebar toggle */}
+                  {(activePlan || activeProposedPlan || planSidebarOpen) ? (
+                    <>
+                      <Separator orientation="vertical" className="mx-0.5 hidden h-4 sm:block" />
+                      <Button
+                        variant="ghost"
+                        className={cn(
+                          "shrink-0 whitespace-nowrap px-2 sm:px-3",
+                          planSidebarOpen
+                            ? "text-blue-400 hover:text-blue-300"
+                            : "text-muted-foreground/70 hover:text-foreground/80",
+                        )}
+                        size="sm"
+                        type="button"
+                        onClick={() => {
+                          setPlanSidebarOpen((open) => {
+                            if (open) {
+                              // Closing: track dismissal for current turn
+                              const turnKey = activePlan?.turnId ?? activeProposedPlan?.turnId ?? null;
+                              if (turnKey) {
+                                planSidebarDismissedForTurnRef.current = turnKey;
+                              }
+                            } else {
+                              // Re-opening: clear dismissal tracking
+                              planSidebarDismissedForTurnRef.current = null;
+                            }
+                            return !open;
+                          });
+                        }}
+                        title={planSidebarOpen ? "Hide plan sidebar" : "Show plan sidebar"}
+                      >
+                        <ListTodoIcon />
+                        <span className="sr-only sm:not-sr-only">Plan</span>
+                      </Button>
+                    </>
+                  ) : null}
                 </div>
                 {/* Right side: send / stop button */}
         </form>
       </div>
+        </div>{/* end chat column */}
+        {/* Plan sidebar */}
+        {planSidebarOpen ? (
+          <PlanSidebar
+            activePlan={activePlan}
+            activeProposedPlan={activeProposedPlan}
+            markdownCwd={gitCwd ?? undefined}
+            workspaceRoot={activeProject?.cwd ?? undefined}
+            onClose={() => {
+              setPlanSidebarOpen(false);
+              // Track that the user explicitly dismissed for this turn so auto-open won't fight them.
+              const turnKey = activePlan?.turnId ?? activeProposedPlan?.turnId ?? null;
+              if (turnKey) {
+                planSidebarDismissedForTurnRef.current = turnKey;
+              }
+            }}
+          />
+        ) : null}
+      </div>{/* end horizontal flex container */}
       {isGitRepo && (
         <BranchToolbar
           threadId={activeThread.id}
   onRunProjectScript: (script: ProjectScript) => void;
   onAddProjectScript: (input: NewProjectScriptInput) => Promise<void>;
   onUpdateProjectScript: (scriptId: string, input: NewProjectScriptInput) => Promise<void>;
+  onDeleteProjectScript: (scriptId: string) => Promise<void>;
   onToggleDiff: () => void;
 }
   onRunProjectScript,
   onAddProjectScript,
   onUpdateProjectScript,
+  onDeleteProjectScript,
   onToggleDiff,
 }: ChatHeaderProps) {
   return (
             onRunScript={onRunProjectScript}
             onAddScript={onAddProjectScript}
             onUpdateScript={onUpdateProjectScript}
+            onDeleteScript={onDeleteProjectScript}
           />
         )}
         {activeProjectName && (
   );
 });
-const ThreadErrorBanner = memo(function ThreadErrorBanner({ error }: { error: string | null }) {
+const ThreadErrorBanner = memo(function ThreadErrorBanner({
+  error,
+  onDismiss,
+}: {
+  error: string | null;
+  onDismiss?: () => void;
+}) {
   if (!error) return null;
   return (
     <div className="pt-3 mx-auto max-w-3xl">
         <AlertDescription className="line-clamp-3" title={error}>
           {error}
         </AlertDescription>
+        {onDismiss && (
+          <AlertAction>
+            <button
+              type="button"
+              aria-label="Dismiss error"
+              className="inline-flex size-6 items-center justify-center rounded-md text-destructive/60 transition-colors hover:text-destructive"
+              onClick={onDismiss}
+            >
+              <XIcon className="size-3.5" />
+            </button>
+          </AlertAction>
+        )}
       </Alert>
     </div>
   );
   );
 });
-interface PlanModePanelProps {
-  activePlan: ReturnType<typeof deriveActivePlanState>;
-}
-const PlanModePanel = memo(function PlanModePanel({ activePlan }: PlanModePanelProps) {
-  if (!activePlan) return null;
-  return (
-    <div className="pt-3 mx-auto max-w-3xl">
-      <div className="rounded-xl border border-border/70 bg-muted/30 p-4">
-        <div className="flex items-center gap-2">
-          <Badge variant="secondary">Plan</Badge>
-          <span className="text-xs text-muted-foreground">
-            Updated {formatTimestamp(activePlan.createdAt)}
-          </span>
-        </div>
-        {activePlan.explanation ? (
-          <p className="mt-2 text-sm text-muted-foreground">{activePlan.explanation}</p>
-        ) : null}
-        <div className="mt-3 space-y-2">
-          {activePlan.steps.map((step) => (
-            <div
-              key={`${step.status}:${step.step}`}
-              className="flex items-start gap-3 rounded-lg border border-border/60 bg-background/80 px-3 py-2"
-            >
-              <Badge
-                variant={
-                  step.status === "completed"
-                    ? "default"
-                    : step.status === "inProgress"
-                      ? "secondary"
-                      : "outline"
-                }
-              >
-                {step.status === "inProgress"
-                  ? "In progress"
-                  : step.status === "completed"
-                    ? "Done"
-                    : "Pending"}
-              </Badge>
-              <div className="min-w-0 flex-1 text-sm">{step.step}</div>
-            </div>
-          ))}
-        </div>
-      </div>
-    </div>
-  );
-});
 interface PendingUserInputPanelProps {
   pendingUserInputs: PendingUserInput[];
   respondingRequestIds: ApprovalRequestId[];
   answers: Record<string, PendingUserInputDraftAnswer>;
   questionIndex: number;
   onSelectOption: (questionId: string, optionLabel: string) => void;
+  onAdvance: () => void;
 }
 const ComposerPendingUserInputPanel = memo(function ComposerPendingUserInputPanel({
   answers,
   questionIndex,
   onSelectOption,
+  onAdvance,
 }: PendingUserInputPanelProps) {
   if (pendingUserInputs.length === 0) return null;
   const activePrompt = pendingUserInputs[0];
       answers={answers}
       questionIndex={questionIndex}
       onSelectOption={onSelectOption}
+      onAdvance={onAdvance}
     />
   );
 });
   answers,
   questionIndex,
   onSelectOption,
+  onAdvance,
 }: {
   prompt: PendingUserInput;
   isResponding: boolean;
   answers: Record<string, PendingUserInputDraftAnswer>;
   questionIndex: number;
   onSelectOption: (questionId: string, optionLabel: string) => void;
+  onAdvance: () => void;
 }) {
   const progress = derivePendingUserInputProgress(prompt.questions, answers, questionIndex);
   const activeQuestion = progress.activeQuestion;
+  const autoAdvanceTimerRef = useRef<number | null>(null);
+  // Clear auto-advance timer on unmount
+  useEffect(() => {
+    return () => {
+      if (autoAdvanceTimerRef.current !== null) {
+        window.clearTimeout(autoAdvanceTimerRef.current);
+      }
+    };
+  }, []);
+  const selectOptionAndAutoAdvance = useCallback(
+    (questionId: string, optionLabel: string) => {
+      onSelectOption(questionId, optionLabel);
+      if (autoAdvanceTimerRef.current !== null) {
+        window.clearTimeout(autoAdvanceTimerRef.current);
+      }
+      autoAdvanceTimerRef.current = window.setTimeout(() => {
+        autoAdvanceTimerRef.current = null;
+        onAdvance();
+      }, 200);
+    },
+    [onSelectOption, onAdvance],
+  );
+  // Keyboard shortcut: number keys 1-9 select corresponding option and auto-advance.
+  // Works even when the Lexical composer (contenteditable) has focus — the composer
+  // doubles as a custom-answer field during user input, and when it's empty the digit
+  // keys should pick options instead of typing into the editor.
+  useEffect(() => {
+    if (!activeQuestion || isResponding) return;
+    const handler = (event: globalThis.KeyboardEvent) => {
+      if (event.metaKey || event.ctrlKey || event.altKey) return;
+      const target = event.target;
+      if (
+        target instanceof HTMLInputElement ||
+        target instanceof HTMLTextAreaElement
+      ) {
+        return;
+      }
+      // If the user has started typing a custom answer in the contenteditable
+      // composer, let digit keys pass through so they can type numbers.
+      if (target instanceof HTMLElement && target.isContentEditable) {
+        const hasCustomText = progress.customAnswer.length > 0;
+        if (hasCustomText) return;
+      }
+      const digit = Number.parseInt(event.key, 10);
+      if (Number.isNaN(digit) || digit < 1 || digit > 9) return;
+      const optionIndex = digit - 1;
+      if (optionIndex >= activeQuestion.options.length) return;
+      const option = activeQuestion.options[optionIndex];
+      if (!option) return;
+      event.preventDefault();
+      selectOptionAndAutoAdvance(activeQuestion.id, option.label);
+    };
+    document.addEventListener("keydown", handler);
+    return () => document.removeEventListener("keydown", handler);
+  }, [activeQuestion, isResponding, selectOptionAndAutoAdvance, progress.customAnswer.length]);
   if (!activeQuestion) {
     return null;
   }
   return (
-    <div className="px-4 py-4 sm:px-5">
+    <div className="px-4 py-3 sm:px-5">
-      <div className="flex gap-2">
+      <div className="flex items-center gap-3">
-        <span className="uppercase text-sm tracking-[0.2em]">
+        <div className="flex items-center gap-2">
-          {questionIndex + 1}/{prompt.questions.length} {activeQuestion.header}
+          {prompt.questions.length > 1 ? (
-        </span>
+            <span className="flex h-5 items-center rounded-md bg-muted/60 px-1.5 text-[10px] font-medium tabular-nums text-muted-foreground/60">
-        <div className="text-sm font-medium">{activeQuestion.question}</div>
+              {questionIndex + 1}/{prompt.questions.length}
+            </span>
+          ) : null}
+          <span className="text-[11px] font-semibold tracking-widest text-muted-foreground/50 uppercase">
+            {activeQuestion.header}
+          </span>
+        </div>
       </div>
-      <div className="mt-3 flex flex-wrap gap-2">
+      <p className="mt-1.5 text-sm text-foreground/90">{activeQuestion.question}</p>
-        {activeQuestion.options.map((option) => {
+      <div className="mt-3 space-y-1">
+        {activeQuestion.options.map((option, index) => {
           const isSelected = progress.selectedOptionLabel === option.label;
+          const shortcutKey = index < 9 ? index + 1 : null;
           return (
-            <Button
+            <button
               key={`${activeQuestion.id}:${option.label}`}
-              size="sm"
+              type="button"
-              variant={isSelected ? "default" : "outline"}
               disabled={isResponding}
-              onClick={() => onSelectOption(activeQuestion.id, option.label)}
+              onClick={() => selectOptionAndAutoAdvance(activeQuestion.id, option.label)}
-              title={option.description}
+              className={cn(
+                "group flex w-full items-center gap-3 rounded-lg border px-3 py-2 text-left transition-all duration-150",
+                isSelected
+                  ? "border-blue-500/40 bg-blue-500/8 text-foreground"
+                  : "border-transparent bg-muted/20 text-foreground/80 hover:bg-muted/40 hover:border-border/40",
+                isResponding && "opacity-50 cursor-not-allowed",
+              )}
             >
-              {option.label}
+              {shortcutKey !== null ? (
-            </Button>
+                <kbd
+                  className={cn(
+                    "flex size-5 shrink-0 items-center justify-center rounded text-[11px] font-medium tabular-nums transition-colors duration-150",
+                    isSelected
+                      ? "bg-blue-500/20 text-blue-400"
+                      : "bg-muted/40 text-muted-foreground/50 group-hover:bg-muted/60 group-hover:text-muted-foreground/70",
+                  )}
+                >
+                  {shortcutKey}
+                </kbd>
+              ) : null}
+              <div className="min-w-0 flex-1">
+                <span className="text-sm font-medium">{option.label}</span>
+                {option.description && option.description !== option.label ? (
+                  <span className="ml-2 text-xs text-muted-foreground/50">{option.description}</span>
+                ) : null}
+              </div>
+              {isSelected ? (
+                <CheckIcon className="size-3.5 shrink-0 text-blue-400" />
+              ) : null}
+            </button>
           );
         })}
       </div>
   const saveContents = normalizePlanMarkdownForExport(planMarkdown);
   const handleDownload = () => {
-    downloadTextFile(downloadFilename, saveContents);
+    downloadPlanAsTextFile(downloadFilename, saveContents);
   };
   const openSaveDialog = () => {
         </div>
         {canCollapse ? (
           <div className="mt-4 flex justify-center">
-            <Button size="sm" variant="outline" onClick={() => setExpanded((value) => !value)}>
+            <Button
+              size="sm"
+              variant="outline"
+              data-scroll-anchor-ignore
+              onClick={() => setExpanded((value) => !value)}
+            >
               {expanded ? "Collapse plan" : "Expand plan"}
             </Button>
           </div>
   model: ModelSlug;
   lockedProvider: ProviderKind | null;
   modelOptionsByProvider: Record<ProviderKind, ReadonlyArray<{ slug: string; name: string }>>;
-  serviceTierSetting: AppServiceTier;
   disabled?: boolean;
   onProviderModelChange: (provider: ProviderKind, model: ModelSlug) => void;
 }) {
       >
         <span className="flex min-w-0 items-center gap-2">
           <ProviderIcon aria-hidden="true" className="size-4 shrink-0 text-muted-foreground/70" />
-          {props.provider === "codex" && shouldShowFastTierIcon(props.model, props.serviceTierSetting) ? (
-            <ZapIcon className="size-3.5 shrink-0 text-amber-500" />
-          ) : null}
           <span className="truncate">{selectedModelLabel}</span>
           <ChevronDownIcon aria-hidden="true" className="size-3 opacity-60" />
         </span>
                         value={modelOption.slug}
                         onClick={() => setIsMenuOpen(false)}
                       >
-                        {option.value === "codex" &&
-                        shouldShowFastTierIcon(modelOption.slug, props.serviceTierSetting) ? (
-                          <ZapIcon className="size-3.5 shrink-0 text-amber-500" />
-                        ) : null}
                         {modelOption.name}
                       </MenuRadioItem>
                     ))}

apps/web/src/components/PlanSidebar.tsx+267−0

@@ -0,0 +1,267 @@
	1	import { memo, useState, useCallback } from "react";
	2	import { Badge } from "./ui/badge";
	3	import { Button } from "./ui/button";
	4	import { ScrollArea } from "./ui/scroll-area";
	5	import ChatMarkdown from "./ChatMarkdown";
	6	import {
	7	CheckIcon,
	8	ChevronDownIcon,
	9	ChevronRightIcon,
	10	EllipsisIcon,
	11	LoaderIcon,
	12	PanelRightCloseIcon,
	13	} from "lucide-react";
	14	import { cn } from "~/lib/utils";
	15	import { formatTimestamp } from "../session-logic";
	16	import type { ActivePlanState } from "../session-logic";
	17	import type { LatestProposedPlanState } from "../session-logic";
	18	import {
	19	proposedPlanTitle,
	20	buildProposedPlanMarkdownFilename,
	21	normalizePlanMarkdownForExport,
	22	downloadPlanAsTextFile,
	23	} from "../proposedPlan";
	24	import { Menu, MenuItem, MenuPopup, MenuTrigger } from "./ui/menu";
	25	import { readNativeApi } from "~/nativeApi";
	26	import { toastManager } from "./ui/toast";
	27
	28	function stepStatusIcon(status: string): React.ReactNode {
	29	if (status === "completed") {
	30	return (
	31	<span className="flex size-5 shrink-0 items-center justify-center rounded-full bg-emerald-500/15 text-emerald-500">
	32	<CheckIcon className="size-3" />
	33	</span>
	34	);
	35	}
	36	if (status === "inProgress") {
	37	return (
	38	<span className="flex size-5 shrink-0 items-center justify-center rounded-full bg-blue-500/15 text-blue-400">
	39	<LoaderIcon className="size-3 animate-spin" />
	40	</span>
	41	);
	42	}
	43	return (
	44	<span className="flex size-5 shrink-0 items-center justify-center rounded-full border border-border/60 bg-muted/30">
	45	<span className="size-1.5 rounded-full bg-muted-foreground/30" />
	46	</span>
	47	);
	48	}
	49
	50	interface PlanSidebarProps {
	51	activePlan: ActivePlanState \| null;
	52	activeProposedPlan: LatestProposedPlanState \| null;
	53	markdownCwd: string \| undefined;
	54	workspaceRoot: string \| undefined;
	55	onClose: () => void;
	56	}
	57
	58	const PlanSidebar = memo(function PlanSidebar({
	59	activePlan,
	60	activeProposedPlan,
	61	markdownCwd,
	62	workspaceRoot,
	63	onClose,
	64	}: PlanSidebarProps) {
	65	const [proposedPlanExpanded, setProposedPlanExpanded] = useState(false);
	66	const [isSavingToWorkspace, setIsSavingToWorkspace] = useState(false);
	67	const [copied, setCopied] = useState(false);
	68
	69	const planMarkdown = activeProposedPlan?.planMarkdown ?? null;
	70	const planTitle = planMarkdown ? proposedPlanTitle(planMarkdown) : null;
	71
	72	const handleCopyPlan = useCallback(() => {
	73	if (!planMarkdown) return;
	74	void navigator.clipboard.writeText(planMarkdown);
	75	setCopied(true);
	76	setTimeout(() => setCopied(false), 2000);
	77	}, [planMarkdown]);
	78
	79	const handleDownload = useCallback(() => {
	80	if (!planMarkdown) return;
	81	const filename = buildProposedPlanMarkdownFilename(planMarkdown);
	82	downloadPlanAsTextFile(filename, normalizePlanMarkdownForExport(planMarkdown));
	83	}, [planMarkdown]);
	84
	85	const handleSaveToWorkspace = useCallback(() => {
	86	const api = readNativeApi();
	87	if (!api \|\| !workspaceRoot \|\| !planMarkdown) return;
	88	const filename = buildProposedPlanMarkdownFilename(planMarkdown);
	89	setIsSavingToWorkspace(true);
	90	void api.projects
	91	.writeFile({
	92	cwd: workspaceRoot,
	93	relativePath: filename,
	94	contents: normalizePlanMarkdownForExport(planMarkdown),
	95	})
	96	.then((result) => {
	97	toastManager.add({
	98	type: "success",
	99	title: "Plan saved",
	100	description: result.relativePath,
	101	});
	102	})
	103	.catch((error) => {
	104	toastManager.add({
	105	type: "error",
	106	title: "Could not save plan",
	107	description:
	108	error instanceof Error ? error.message : "An error occurred.",
	109	});
	110	})
	111	.then(
	112	() => setIsSavingToWorkspace(false),
	113	() => setIsSavingToWorkspace(false),
	114	);
	115	}, [planMarkdown, workspaceRoot]);
	116
	117	return (
	118	<div className="flex h-full w-[340px] shrink-0 flex-col border-l border-border/70 bg-card/50">
	119	{/* Header */}
	120	<div className="flex h-12 shrink-0 items-center justify-between border-b border-border/60 px-3">
	121	<div className="flex items-center gap-2">
	122	<Badge
	123	variant="secondary"
	124	className="rounded-md bg-blue-500/10 px-1.5 py-0 text-[10px] font-semibold tracking-wide text-blue-400 uppercase"
	125	>
	126	Plan
	127	</Badge>
	128	{activePlan ? (
	129	<span className="text-[11px] text-muted-foreground/60">
	130	{formatTimestamp(activePlan.createdAt)}
	131	</span>
	132	) : null}
	133	</div>
	134	<div className="flex items-center gap-1">
	135	{planMarkdown ? (
	136	<Menu>
	137	<MenuTrigger
	138	render={
	139	<Button
	140	size="icon-xs"
	141	variant="ghost"
	142	className="text-muted-foreground/50 hover:text-foreground/70"
	143	aria-label="Plan actions"
	144	/>
	145	}
	146	>
	147	<EllipsisIcon className="size-3.5" />
	148	</MenuTrigger>
	149	<MenuPopup align="end">
	150	<MenuItem onClick={handleCopyPlan}>
	151	{copied ? "Copied!" : "Copy to clipboard"}
	152	</MenuItem>
	153	<MenuItem onClick={handleDownload}>Download as markdown</MenuItem>
	154	<MenuItem
	155	onClick={handleSaveToWorkspace}
	156	disabled={!workspaceRoot \|\| isSavingToWorkspace}
	157	>
	158	Save to workspace
	159	</MenuItem>
	160	</MenuPopup>
	161	</Menu>
	162	) : null}
	163	<Button
	164	size="icon-xs"
	165	variant="ghost"
	166	onClick={onClose}
	167	aria-label="Close plan sidebar"
	168	className="text-muted-foreground/50 hover:text-foreground/70"
	169	>
	170	<PanelRightCloseIcon className="size-3.5" />
	171	</Button>
	172	</div>
	173	</div>
	174
	175	{/* Content */}
	176	<ScrollArea className="min-h-0 flex-1">
	177	<div className="p-3 space-y-4">
	178	{/* Explanation */}
	179	{activePlan?.explanation ? (
	180	<p className="text-[13px] leading-relaxed text-muted-foreground/80">
	181	{activePlan.explanation}
	182	</p>
	183	) : null}
	184
	185	{/* Plan Steps */}
	186	{activePlan && activePlan.steps.length > 0 ? (
	187	<div className="space-y-1">
	188	<p className="mb-2 text-[10px] font-semibold tracking-widest text-muted-foreground/40 uppercase">
	189	Steps
	190	</p>
	191	{activePlan.steps.map((step) => (
	192	<div
	193	key={`${step.status}:${step.step}`}
	194	className={cn(
	195	"flex items-start gap-2.5 rounded-lg px-2.5 py-2 transition-colors duration-200",
	196	step.status === "inProgress" && "bg-blue-500/5",
	197	step.status === "completed" && "bg-emerald-500/5",
	198	)}
	199	>
	200	<div className="mt-0.5">
	201	{stepStatusIcon(step.status)}
	202	</div>
	203	<p
	204	className={cn(
	205	"text-[13px] leading-snug",
	206	step.status === "completed"
	207	? "text-muted-foreground/50 line-through decoration-muted-foreground/20"
	208	: step.status === "inProgress"
	209	? "text-foreground/90"
	210	: "text-muted-foreground/70",
	211	)}
	212	>
	213	{step.step}
	214	</p>
	215	</div>
	216	))}
	217	</div>
	218	) : null}
	219
	220	{/* Proposed Plan Markdown */}
	221	{planMarkdown ? (
	222	<div className="space-y-2">
	223	<button
	224	type="button"
	225	className="group flex w-full items-center gap-1.5 text-left"
	226	onClick={() => setProposedPlanExpanded((v) => !v)}
	227	>
	228	{proposedPlanExpanded ? (
	229	<ChevronDownIcon className="size-3 shrink-0 text-muted-foreground/40 transition-transform" />
	230	) : (
	231	<ChevronRightIcon className="size-3 shrink-0 text-muted-foreground/40 transition-transform" />
	232	)}
	233	<span className="text-[10px] font-semibold tracking-widest text-muted-foreground/40 uppercase group-hover:text-muted-foreground/60">
	234	{planTitle ?? "Full Plan"}
	235	</span>
	236	</button>
	237	{proposedPlanExpanded ? (
	238	<div className="rounded-lg border border-border/50 bg-background/50 p-3">
	239	<ChatMarkdown
	240	text={planMarkdown}
	241	cwd={markdownCwd}
	242	isStreaming={false}
	243	/>
	244	</div>
	245	) : null}
	246	</div>
	247	) : null}
	248
	249	{/* Empty state */}
	250	{!activePlan && !planMarkdown ? (
	251	<div className="flex flex-col items-center justify-center py-12 text-center">
	252	<p className="text-[13px] text-muted-foreground/40">
	253	No active plan yet.
	254	</p>
	255	<p className="mt-1 text-[11px] text-muted-foreground/30">
	256	Plans will appear here when generated.
	257	</p>
	258	</div>
	259	) : null}
	260	</div>
	261	</ScrollArea>
	262	</div>
	263	);
	264	});
	265
	266	export default PlanSidebar;
	267	export type { PlanSidebarProps };

apps/web/src/components/ProjectScriptsControl.tsx+45−1

   SettingsIcon,
   WrenchIcon,
 } from "lucide-react";
-import React, { type FormEvent, type KeyboardEvent, useMemo, useState } from "react";
+import React, { type FormEvent, type KeyboardEvent, useCallback, useMemo, useState } from "react";
 import {
   keybindingValueForCommand,
 } from "~/projectScripts";
 import { shortcutLabelForCommand } from "~/keybindings";
 import { isMacPlatform } from "~/lib/utils";
+import {
+  AlertDialog,
+  AlertDialogClose,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogPopup,
+  AlertDialogTitle,
+} from "./ui/alert-dialog";
 import { Button } from "./ui/button";
 import {
   Dialog,
   onRunScript: (script: ProjectScript) => void;
   onAddScript: (input: NewProjectScriptInput) => Promise<void> | void;
   onUpdateScript: (scriptId: string, input: NewProjectScriptInput) => Promise<void> | void;
+  onDeleteScript: (scriptId: string) => Promise<void> | void;
 }
 function normalizeShortcutKeyToken(key: string): string | null {
   onRunScript,
   onAddScript,
   onUpdateScript,
+  onDeleteScript,
 }: ProjectScriptsControlProps) {
   const addScriptFormId = React.useId();
   const [editingScriptId, setEditingScriptId] = useState<string | null>(null);
   const [runOnWorktreeCreate, setRunOnWorktreeCreate] = useState(false);
   const [keybinding, setKeybinding] = useState("");
   const [validationError, setValidationError] = useState<string | null>(null);
+  const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
   const primaryScript = useMemo(() => {
     if (preferredScriptId) {
     setDialogOpen(true);
   };
+  const confirmDeleteScript = useCallback(() => {
+    if (!editingScriptId) return;
+    setDeleteConfirmOpen(false);
+    setDialogOpen(false);
+    void onDeleteScript(editingScriptId);
+  }, [editingScriptId, onDeleteScript]);
   return (
     <>
       {primaryScript ? (
             </form>
           </DialogPanel>
           <DialogFooter>
+            {isEditing && (
+              <Button
+                type="button"
+                variant="destructive-outline"
+                className="mr-auto"
+                onClick={() => setDeleteConfirmOpen(true)}
+              >
+                Delete
+              </Button>
+            )}
             <Button
               type="button"
               variant="outline"
           </DialogFooter>
         </DialogPopup>
       </Dialog>
+      <AlertDialog open={deleteConfirmOpen} onOpenChange={setDeleteConfirmOpen}>
+        <AlertDialogPopup>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Delete action "{name}"?</AlertDialogTitle>
+            <AlertDialogDescription>This action cannot be undone.</AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogClose render={<Button variant="outline" />}>Cancel</AlertDialogClose>
+            <Button variant="destructive" onClick={confirmDeleteScript}>
+              Delete action
+            </Button>
+          </AlertDialogFooter>
+        </AlertDialogPopup>
+      </AlertDialog>
     </>
   );
 }

apps/web/src/components/Sidebar.logic.test.ts+124−0

@@ -0,0 +1,124 @@
	1	import { describe, expect, it } from "vitest";
	2
	3	import { hasUnseenCompletion, resolveThreadStatusPill } from "./Sidebar.logic";
	4
	5	function makeLatestTurn(overrides?: {
	6	completedAt?: string \| null;
	7	startedAt?: string \| null;
	8	}): Parameters<typeof hasUnseenCompletion>[0]["latestTurn"] {
	9	return {
	10	turnId: "turn-1" as never,
	11	state: "completed",
	12	assistantMessageId: null,
	13	requestedAt: "2026-03-09T10:00:00.000Z",
	14	startedAt: overrides?.startedAt ?? "2026-03-09T10:00:00.000Z",
	15	completedAt: overrides?.completedAt ?? "2026-03-09T10:05:00.000Z",
	16	};
	17	}
	18
	19	describe("hasUnseenCompletion", () => {
	20	it("returns true when a thread completed after its last visit", () => {
	21	expect(
	22	hasUnseenCompletion({
	23	interactionMode: "default",
	24	latestTurn: makeLatestTurn(),
	25	lastVisitedAt: "2026-03-09T10:04:00.000Z",
	26	proposedPlans: [],
	27	session: null,
	28	}),
	29	).toBe(true);
	30	});
	31	});
	32
	33	describe("resolveThreadStatusPill", () => {
	34	const baseThread = {
	35	interactionMode: "plan" as const,
	36	latestTurn: null,
	37	lastVisitedAt: undefined,
	38	proposedPlans: [],
	39	session: {
	40	provider: "codex" as const,
	41	status: "running" as const,
	42	createdAt: "2026-03-09T10:00:00.000Z",
	43	updatedAt: "2026-03-09T10:00:00.000Z",
	44	orchestrationStatus: "running" as const,
	45	},
	46	};
	47
	48	it("shows pending approval before all other statuses", () => {
	49	expect(
	50	resolveThreadStatusPill({
	51	thread: baseThread,
	52	hasPendingApprovals: true,
	53	hasPendingUserInput: true,
	54	}),
	55	).toMatchObject({ label: "Pending Approval", pulse: false });
	56	});
	57
	58	it("shows awaiting input when plan mode is blocked on user answers", () => {
	59	expect(
	60	resolveThreadStatusPill({
	61	thread: baseThread,
	62	hasPendingApprovals: false,
	63	hasPendingUserInput: true,
	64	}),
	65	).toMatchObject({ label: "Awaiting Input", pulse: false });
	66	});
	67
	68	it("falls back to working when the thread is actively running without blockers", () => {
	69	expect(
	70	resolveThreadStatusPill({
	71	thread: baseThread,
	72	hasPendingApprovals: false,
	73	hasPendingUserInput: false,
	74	}),
	75	).toMatchObject({ label: "Working", pulse: true });
	76	});
	77
	78	it("shows plan ready when a settled plan turn has a proposed plan ready for follow-up", () => {
	79	expect(
	80	resolveThreadStatusPill({
	81	thread: {
	82	...baseThread,
	83	latestTurn: makeLatestTurn(),
	84	proposedPlans: [
	85	{
	86	id: "plan-1" as never,
	87	turnId: "turn-1" as never,
	88	createdAt: "2026-03-09T10:00:00.000Z",
	89	updatedAt: "2026-03-09T10:05:00.000Z",
	90	planMarkdown: "# Plan",
	91	},
	92	],
	93	session: {
	94	...baseThread.session,
	95	status: "ready",
	96	orchestrationStatus: "ready",
	97	},
	98	},
	99	hasPendingApprovals: false,
	100	hasPendingUserInput: false,
	101	}),
	102	).toMatchObject({ label: "Plan Ready", pulse: false });
	103	});
	104
	105	it("shows completed when there is an unseen completion and no active blocker", () => {
	106	expect(
	107	resolveThreadStatusPill({
	108	thread: {
	109	...baseThread,
	110	interactionMode: "default",
	111	latestTurn: makeLatestTurn(),
	112	lastVisitedAt: "2026-03-09T10:04:00.000Z",
	113	session: {
	114	...baseThread.session,
	115	status: "ready",
	116	orchestrationStatus: "ready",
	117	},
	118	},
	119	hasPendingApprovals: false,
	120	hasPendingUserInput: false,
	121	}),
	122	).toMatchObject({ label: "Completed", pulse: false });
	123	});
	124	});

apps/web/src/components/Sidebar.logic.ts+100−0

@@ -0,0 +1,100 @@
	1	import type { Thread } from "../types";
	2	import { findLatestProposedPlan, isLatestTurnSettled } from "../session-logic";
	3
	4	export interface ThreadStatusPill {
	5	label:
	6	\| "Working"
	7	\| "Connecting"
	8	\| "Completed"
	9	\| "Pending Approval"
	10	\| "Awaiting Input"
	11	\| "Plan Ready";
	12	colorClass: string;
	13	dotClass: string;
	14	pulse: boolean;
	15	}
	16
	17	type ThreadStatusInput = Pick<
	18	Thread,
	19	"interactionMode" \| "latestTurn" \| "lastVisitedAt" \| "proposedPlans" \| "session"
	20	>;
	21
	22	export function hasUnseenCompletion(thread: ThreadStatusInput): boolean {
	23	if (!thread.latestTurn?.completedAt) return false;
	24	const completedAt = Date.parse(thread.latestTurn.completedAt);
	25	if (Number.isNaN(completedAt)) return false;
	26	if (!thread.lastVisitedAt) return true;
	27
	28	const lastVisitedAt = Date.parse(thread.lastVisitedAt);
	29	if (Number.isNaN(lastVisitedAt)) return true;
	30	return completedAt > lastVisitedAt;
	31	}
	32
	33	export function resolveThreadStatusPill(input: {
	34	thread: ThreadStatusInput;
	35	hasPendingApprovals: boolean;
	36	hasPendingUserInput: boolean;
	37	}): ThreadStatusPill \| null {
	38	const { hasPendingApprovals, hasPendingUserInput, thread } = input;
	39
	40	if (hasPendingApprovals) {
	41	return {
	42	label: "Pending Approval",
	43	colorClass: "text-amber-600 dark:text-amber-300/90",
	44	dotClass: "bg-amber-500 dark:bg-amber-300/90",
	45	pulse: false,
	46	};
	47	}
	48
	49	if (hasPendingUserInput) {
	50	return {
	51	label: "Awaiting Input",
	52	colorClass: "text-indigo-600 dark:text-indigo-300/90",
	53	dotClass: "bg-indigo-500 dark:bg-indigo-300/90",
	54	pulse: false,
	55	};
	56	}
	57
	58	if (thread.session?.status === "running") {
	59	return {
	60	label: "Working",
	61	colorClass: "text-sky-600 dark:text-sky-300/80",
	62	dotClass: "bg-sky-500 dark:bg-sky-300/80",
	63	pulse: true,
	64	};
	65	}
	66
	67	if (thread.session?.status === "connecting") {
	68	return {
	69	label: "Connecting",
	70	colorClass: "text-sky-600 dark:text-sky-300/80",
	71	dotClass: "bg-sky-500 dark:bg-sky-300/80",
	72	pulse: true,
	73	};
	74	}
	75
	76	const hasPlanReadyPrompt =
	77	!hasPendingUserInput &&
	78	thread.interactionMode === "plan" &&
	79	isLatestTurnSettled(thread.latestTurn, thread.session) &&
	80	findLatestProposedPlan(thread.proposedPlans, thread.latestTurn?.turnId ?? null) !== null;
	81	if (hasPlanReadyPrompt) {
	82	return {
	83	label: "Plan Ready",
	84	colorClass: "text-violet-600 dark:text-violet-300/90",
	85	dotClass: "bg-violet-500 dark:bg-violet-300/90",
	86	pulse: false,
	87	};
	88	}
	89
	90	if (hasUnseenCompletion(thread)) {
	91	return {
	92	label: "Completed",
	93	colorClass: "text-emerald-600 dark:text-emerald-300/90",
	94	dotClass: "bg-emerald-500 dark:bg-emerald-300/90",
	95	pulse: false,
	96	};
	97	}
	98
	99	return null;
	100	}

apps/web/src/components/Sidebar.tsx+204−129

 import {
+  ArrowLeftIcon,
   ChevronRightIcon,
   FolderIcon,
   GitPullRequestIcon,
+  PlusIcon,
   RocketIcon,
+  SettingsIcon,
   SquarePenIcon,
   TerminalIcon,
+  TriangleAlertIcon,
 } from "lucide-react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   type ResolvedKeybindingsConfig,
 } from "@t3tools/contracts";
 import { useMutation, useQueries, useQuery, useQueryClient } from "@tanstack/react-query";
-import { useNavigate, useParams } from "@tanstack/react-router";
+import { useLocation, useNavigate, useParams } from "@tanstack/react-router";
 import { useAppSettings } from "../appSettings";
 import { isElectron } from "../env";
 import { APP_STAGE_LABEL } from "../branding";
 import { newCommandId, newProjectId, newThreadId } from "../lib/utils";
 import { useStore } from "../store";
 import { isChatNewLocalShortcut, isChatNewShortcut, shortcutLabelForCommand } from "../keybindings";
-import { type Thread } from "../types";
+import { derivePendingApprovals, derivePendingUserInputs } from "../session-logic";
-import { derivePendingApprovals } from "../session-logic";
 import { gitRemoveWorktreeMutationOptions, gitStatusQueryOptions } from "../lib/gitReactQuery";
 import { serverConfigQueryOptions } from "../lib/serverReactQuery";
 import { readNativeApi } from "../nativeApi";
 import { selectThreadTerminalState, useTerminalStateStore } from "../terminalStateStore";
 import { toastManager } from "./ui/toast";
 import {
+  getArm64IntelBuildWarningDescription,
   getDesktopUpdateActionError,
   getDesktopUpdateButtonTooltip,
   isDesktopUpdateButtonDisabled,
   resolveDesktopUpdateButtonAction,
+  shouldShowArm64IntelBuildWarning,
   shouldHighlightDesktopUpdateError,
   shouldShowDesktopUpdateButton,
   shouldToastDesktopUpdateActionResult,
 } from "./desktopUpdate.logic";
+import { Alert, AlertAction, AlertDescription, AlertTitle } from "./ui/alert";
+import { Button } from "./ui/button";
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "./ui/collapsible";
 import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip";
 import {
 } from "./ui/sidebar";
 import { formatWorktreePathForDisplay, getOrphanedWorktreePathForThread } from "../worktreeCleanup";
 import { isNonEmpty as isNonEmptyString } from "effect/String";
+import { resolveThreadStatusPill } from "./Sidebar.logic";
 const EMPTY_KEYBINDINGS: ResolvedKeybindingsConfig = [];
 const THREAD_PREVIEW_LIMIT = 6;
   return `${Math.floor(hours / 24)}d ago`;
 }
-interface ThreadStatusPill {
-  label: "Working" | "Connecting" | "Completed" | "Pending Approval";
-  colorClass: string;
-  dotClass: string;
-  pulse: boolean;
-}
 interface TerminalStatusIndicator {
   label: "Terminal process running";
   colorClass: string;
 type ThreadPr = GitStatusResult["pr"];
-function hasUnseenCompletion(thread: Thread): boolean {
-  if (!thread.latestTurn?.completedAt) return false;
-  const completedAt = Date.parse(thread.latestTurn.completedAt);
-  if (Number.isNaN(completedAt)) return false;
-  if (!thread.lastVisitedAt) return true;
-  const lastVisitedAt = Date.parse(thread.lastVisitedAt);
-  if (Number.isNaN(lastVisitedAt)) return true;
-  return completedAt > lastVisitedAt;
-}
-function threadStatusPill(thread: Thread, hasPendingApprovals: boolean): ThreadStatusPill | null {
-  if (hasPendingApprovals) {
-    return {
-      label: "Pending Approval",
-      colorClass: "text-amber-600 dark:text-amber-300/90",
-      dotClass: "bg-amber-500 dark:bg-amber-300/90",
-      pulse: false,
-    };
-  }
-  if (thread.session?.status === "running") {
-    return {
-      label: "Working",
-      colorClass: "text-sky-600 dark:text-sky-300/80",
-      dotClass: "bg-sky-500 dark:bg-sky-300/80",
-      pulse: true,
-    };
-  }
-  if (thread.session?.status === "connecting") {
-    return {
-      label: "Connecting",
-      colorClass: "text-sky-600 dark:text-sky-300/80",
-      dotClass: "bg-sky-500 dark:bg-sky-300/80",
-      pulse: true,
-    };
-  }
-  if (hasUnseenCompletion(thread)) {
-    return {
-      label: "Completed",
-      colorClass: "text-emerald-600 dark:text-emerald-300/90",
-      dotClass: "bg-emerald-500 dark:bg-emerald-300/90",
-      pulse: false,
-    };
-  }
-  return null;
-}
 function terminalStatusFromRunningIds(
   runningTerminalIds: string[],
 ): TerminalStatusIndicator | null {
     (store) => store.clearProjectDraftThreadById,
   );
   const navigate = useNavigate();
+  const isOnSettings = useLocation({ select: (loc) => loc.pathname === "/settings" });
   const { settings: appSettings } = useAppSettings();
   const routeThreadId = useParams({
     strict: false,
   const [newCwd, setNewCwd] = useState("");
   const [isPickingFolder, setIsPickingFolder] = useState(false);
   const [isAddingProject, setIsAddingProject] = useState(false);
+  const [addProjectError, setAddProjectError] = useState<string | null>(null);
+  const addProjectInputRef = useRef<HTMLInputElement | null>(null);
   const [renamingThreadId, setRenamingThreadId] = useState<ThreadId | null>(null);
   const [renamingTitle, setRenamingTitle] = useState("");
   const [expandedThreadListsByProject, setExpandedThreadListsByProject] = useState<
   const renamingCommittedRef = useRef(false);
   const renamingInputRef = useRef<HTMLInputElement | null>(null);
   const [desktopUpdateState, setDesktopUpdateState] = useState<DesktopUpdateState | null>(null);
+  const shouldBrowseForProjectImmediately = isElectron;
+  const shouldShowProjectPathEntry = addingProject && !shouldBrowseForProjectImmediately;
   const pendingApprovalByThreadId = useMemo(() => {
     const map = new Map<ThreadId, boolean>();
     for (const thread of threads) {
     }
     return map;
   }, [threads]);
+  const pendingUserInputByThreadId = useMemo(() => {
+    const map = new Map<ThreadId, boolean>();
+    for (const thread of threads) {
+      map.set(thread.id, derivePendingUserInputs(thread.activities).length > 0);
+    }
+    return map;
+  }, [threads]);
   const projectCwdById = useMemo(
     () => new Map(projects.map((project) => [project.id, project.cwd] as const)),
     [projects],
       const finishAddingProject = () => {
         setIsAddingProject(false);
         setNewCwd("");
+        setAddProjectError(null);
         setAddingProject(false);
       };
         });
         await handleNewThread(projectId).catch(() => undefined);
       } catch (error) {
+        const description =
+          error instanceof Error ? error.message : "An error occurred while adding the project.";
         setIsAddingProject(false);
-        toastManager.add({
+        if (shouldBrowseForProjectImmediately) {
-          type: "error",
+          toastManager.add({
-          title: "Unable to add project",
+            type: "error",
-          description:
+            title: "Failed to add project",
-            error instanceof Error ? error.message : "An error occurred while adding the project.",
+            description,
-        });
+          });
+        } else {
+          setAddProjectError(description);
+        }
         return;
       }
       finishAddingProject();
     },
-    [focusMostRecentThreadForProject, handleNewThread, isAddingProject, projects],
+    [
+      focusMostRecentThreadForProject,
+      handleNewThread,
+      isAddingProject,
+      projects,
+      shouldBrowseForProjectImmediately,
+    ],
   );
   const handleAddProject = () => {
     }
     if (pickedPath) {
       await addProjectFromPath(pickedPath);
+    } else if (!shouldBrowseForProjectImmediately) {
+      addProjectInputRef.current?.focus();
     }
     setIsPickingFolder(false);
   };
+  const handleStartAddProject = () => {
+    setAddProjectError(null);
+    if (shouldBrowseForProjectImmediately) {
+      void handlePickFolder();
+      return;
+    }
+    setAddingProject((prev) => !prev);
+  };
   const cancelRename = useCallback(() => {
     setRenamingThreadId(null);
     renamingInputRef.current = null;
   const desktopUpdateButtonAction = desktopUpdateState
     ? resolveDesktopUpdateButtonAction(desktopUpdateState)
     : "none";
+  const showArm64IntelBuildWarning =
+    isElectron && shouldShowArm64IntelBuildWarning(desktopUpdateState);
+  const arm64IntelBuildWarningDescription =
+    desktopUpdateState && showArm64IntelBuildWarning
+      ? getArm64IntelBuildWarningDescription(desktopUpdateState)
+      : null;
   const desktopUpdateButtonInteractivityClasses = desktopUpdateButtonDisabled
     ? "cursor-not-allowed opacity-60"
     : "hover:bg-accent hover:text-foreground";
   const wordmark = (
     <div className="flex items-center gap-2">
       <SidebarTrigger className="shrink-0 md:hidden" />
-      <div className="flex min-w-0 flex-1 items-center gap-1 mt-2 ml-1">
+      <div className="flex min-w-0 flex-1 items-center gap-1 mt-1.5 ml-1">
         <T3Wordmark />
         <span className="truncate text-sm font-medium tracking-tight text-muted-foreground">
           Code
     <>
       {isElectron ? (
         <>
-          <SidebarHeader className="drag-region h-[52px] flex-row items-center gap-2 px-4 py-0 pl-[82px]">
+          <SidebarHeader className="drag-region h-[52px] flex-row items-center gap-2 px-4 py-0 pl-[90px]">
             {wordmark}
             {showDesktopUpdateButton && (
               <Tooltip>
                       aria-label={desktopUpdateTooltip}
                       aria-disabled={desktopUpdateButtonDisabled || undefined}
                       disabled={desktopUpdateButtonDisabled}
-                      className={`inline-flex size-7 ml-auto mt-2 items-center justify-center rounded-md text-muted-foreground transition-colors ${desktopUpdateButtonInteractivityClasses} ${desktopUpdateButtonClasses}`}
+                      className={`inline-flex size-7 ml-auto mt-1.5 items-center justify-center rounded-md text-muted-foreground transition-colors ${desktopUpdateButtonInteractivityClasses} ${desktopUpdateButtonClasses}`}
                       onClick={handleDesktopUpdateButtonClick}
                     >
                       <RocketIcon className="size-3.5" />
       )}
       <SidebarContent className="gap-0">
+        {showArm64IntelBuildWarning && arm64IntelBuildWarningDescription ? (
+          <SidebarGroup className="px-2 pt-2 pb-0">
+            <Alert variant="warning" className="rounded-2xl border-warning/40 bg-warning/8">
+              <TriangleAlertIcon />
+              <AlertTitle>Intel build on Apple Silicon</AlertTitle>
+              <AlertDescription>{arm64IntelBuildWarningDescription}</AlertDescription>
+              {desktopUpdateButtonAction !== "none" ? (
+                <AlertAction>
+                  <Button
+                    size="xs"
+                    variant="outline"
+                    disabled={desktopUpdateButtonDisabled}
+                    onClick={handleDesktopUpdateButtonClick}
+                  >
+                    {desktopUpdateButtonAction === "download"
+                      ? "Download ARM build"
+                      : "Install ARM build"}
+                  </Button>
+                </AlertAction>
+              ) : null}
+            </Alert>
+          </SidebarGroup>
+        ) : null}
         <SidebarGroup className="px-2 py-2">
+          <div className="mb-1 flex items-center justify-between px-2">
+            <span className="text-[10px] font-medium uppercase tracking-wider text-muted-foreground/60">
+              Projects
+            </span>
+            <Tooltip>
+              <TooltipTrigger
+                render={
+                  <button
+                    type="button"
+                    aria-label="Add project"
+                    aria-pressed={shouldShowProjectPathEntry}
+                    className="inline-flex size-5 items-center justify-center rounded-md text-muted-foreground/60 transition-colors hover:bg-accent hover:text-foreground"
+                    onClick={handleStartAddProject}
+                  />
+                }
+              >
+                <PlusIcon
+                  className={`size-3.5 transition-transform duration-150 ${
+                    shouldShowProjectPathEntry ? "rotate-45" : "rotate-0"
+                  }`}
+                />
+              </TooltipTrigger>
+              <TooltipPopup side="right">Add project</TooltipPopup>
+            </Tooltip>
+          </div>
+          {shouldShowProjectPathEntry && (
+            <div className="mb-2 px-1">
+              {isElectron && (
+                <button
+                  type="button"
+                  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"
+                  onClick={() => void handlePickFolder()}
+                  disabled={isPickingFolder || isAddingProject}
+                >
+                  <FolderIcon className="size-3.5" />
+                  {isPickingFolder ? "Picking folder..." : "Browse for folder"}
+                </button>
+              )}
+              <div className="flex gap-1.5">
+                <input
+                  ref={addProjectInputRef}
+                  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 ${
+                    addProjectError
+                      ? "border-red-500/70 focus:border-red-500"
+                      : "border-border focus:border-ring"
+                  }`}
+                  placeholder="/path/to/project"
+                  value={newCwd}
+                  onChange={(event) => {
+                    setNewCwd(event.target.value);
+                    setAddProjectError(null);
+                  }}
+                  onKeyDown={(event) => {
+                    if (event.key === "Enter") handleAddProject();
+                    if (event.key === "Escape") {
+                      setAddingProject(false);
+                      setAddProjectError(null);
+                    }
+                  }}
+                  autoFocus
+                />
+                <button
+                  type="button"
+                  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"
+                  onClick={handleAddProject}
+                  disabled={isAddingProject}
+                >
+                  {isAddingProject ? "Adding..." : "Add"}
+                </button>
+              </div>
+              {addProjectError && (
+                <p className="mt-1 px-0.5 text-[11px] leading-tight text-red-400">
+                  {addProjectError}
+                </p>
+              )}
+              <div className="mt-1.5 px-0.5">
+                <button
+                  type="button"
+                  className="text-[11px] text-muted-foreground/50 transition-colors hover:text-muted-foreground"
+                  onClick={() => {
+                    setAddingProject(false);
+                    setAddProjectError(null);
+                  }}
+                >
+                  Cancel
+                </button>
+              </div>
+            </div>
+          )}
           <SidebarMenu>
             {projects.map((project) => {
               const projectThreads = threads
                       <SidebarMenuSub className="mx-1 my-0 w-full translate-x-0 gap-0 px-1.5 py-0">
                         {visibleThreads.map((thread) => {
                           const isActive = routeThreadId === thread.id;
-                          const threadStatus = threadStatusPill(
+                          const threadStatus = resolveThreadStatusPill({
                             thread,
-                            pendingApprovalByThreadId.get(thread.id) === true,
+                            hasPendingApprovals: pendingApprovalByThreadId.get(thread.id) === true,
-                          );
+                            hasPendingUserInput: pendingUserInputByThreadId.get(thread.id) === true,
+                          });
                           const prStatus = prStatusIndicator(prByThreadId.get(thread.id) ?? null);
                           const terminalStatus = terminalStatusFromRunningIds(
                             selectThreadTerminalState(terminalStateByThreadId, thread.id)
             })}
           </SidebarMenu>
-          {projects.length === 0 && !addingProject && (
+          {projects.length === 0 && !shouldShowProjectPathEntry && (
             <div className="px-2 pt-4 text-center text-xs text-muted-foreground/60">
-              No projects yet.
+              No projects yet
-              <br />
-              Add one to get started.
             </div>
           )}
         </SidebarGroup>
       </SidebarContent>
       <SidebarSeparator />
-      <SidebarFooter className="gap-0 p-3">
+      <SidebarFooter className="p-2">
-        {addingProject ? (
+        <SidebarMenu>
-          <>
+          <SidebarMenuItem>
-            <p className="mb-2 text-[10px] font-medium uppercase tracking-wider text-muted-foreground/70">
+            {isOnSettings ? (
-              Add project
+              <SidebarMenuButton
-            </p>
+                size="sm"
-            <input
+                className="gap-2 px-2 py-1.5 text-muted-foreground/70 hover:bg-accent hover:text-foreground"
-              className="mb-2 w-full rounded-md border border-border bg-secondary px-2 py-1.5 font-mono text-xs text-foreground placeholder:text-muted-foreground/40 focus:border-ring focus:outline-none"
+                onClick={() => window.history.back()}
-              placeholder="/path/to/project"
-              value={newCwd}
-              onChange={(event) => setNewCwd(event.target.value)}
-              onKeyDown={(event) => {
-                if (event.key === "Enter") handleAddProject();
-                if (event.key === "Escape") setAddingProject(false);
-              }}
-            />
-            {isElectron && (
-              <button
-                type="button"
-                className="mb-2 flex w-full items-center justify-center rounded-md border border-border px-2 py-1.5 text-xs text-muted-foreground transition-colors duration-150 hover:bg-secondary disabled:cursor-not-allowed disabled:opacity-60"
-                onClick={() => void handlePickFolder()}
-                disabled={isPickingFolder || isAddingProject}
               >
-                {isPickingFolder ? "Picking folder..." : "Browse for folder"}
+                <ArrowLeftIcon className="size-3.5" />
-              </button>
+                <span className="text-xs">Back</span>
-            )}
+              </SidebarMenuButton>
-            <div className="flex gap-2">
+            ) : (
-              <button
+              <SidebarMenuButton
-                type="button"
+                size="sm"
-                className="flex-1 rounded-md bg-primary px-2 py-1 text-xs font-medium text-primary-foreground transition-colors duration-150 hover:bg-primary/90"
+                className="gap-2 px-2 py-1.5 text-muted-foreground/70 hover:bg-accent hover:text-foreground"
-                onClick={handleAddProject}
+                onClick={() => void navigate({ to: "/settings" })}
-                disabled={isAddingProject}
-              >
-                {isAddingProject ? "Adding..." : "Add"}
-              </button>
-              <button
-                type="button"
-                className="flex-1 rounded-md border border-border px-2 py-1 text-xs text-muted-foreground/80 transition-colors duration-150 hover:bg-secondary"
-                onClick={() => setAddingProject(false)}
               >
-                Cancel
+                <SettingsIcon className="size-3.5" />
-              </button>
+                <span className="text-xs">Settings</span>
-            </div>
+              </SidebarMenuButton>
-          </>
+            )}
-        ) : (
+          </SidebarMenuItem>
-          <button
+        </SidebarMenu>
-            type="button"
-            className="flex w-full items-center justify-center gap-1 rounded-md border border-dashed border-border py-2 text-xs text-muted-foreground/70 transition-colors duration-150 hover:border-ring hover:text-muted-foreground"
-            onClick={() => setAddingProject(true)}
-          >
-            + Add project
-          </button>
-        )}
       </SidebarFooter>
     </>
   );

apps/web/src/components/desktopUpdate.logic.test.ts+31−0

@@ -2,11 +2,13 @@ import { describe, expect, it } from "vitest"; · 1 unmodified line
2	import type { DesktopUpdateActionResult, DesktopUpdateState } from "@t3tools/contracts";	2	import type { DesktopUpdateActionResult, DesktopUpdateState } from "@t3tools/contracts";
3		3
4	import {	4	import {
		5	getArm64IntelBuildWarningDescription,
5	getDesktopUpdateActionError,	6	getDesktopUpdateActionError,
6	getDesktopUpdateButtonTooltip,	7	getDesktopUpdateButtonTooltip,
7	isDesktopUpdateButtonDisabled,	8	isDesktopUpdateButtonDisabled,
8	resolveDesktopUpdateButtonAction,	9	resolveDesktopUpdateButtonAction,
9	shouldHighlightDesktopUpdateError,	10	shouldHighlightDesktopUpdateError,
		11	shouldShowArm64IntelBuildWarning,
10	shouldShowDesktopUpdateButton,	12	shouldShowDesktopUpdateButton,
11	shouldToastDesktopUpdateActionResult,	13	shouldToastDesktopUpdateActionResult,
12	} from "./desktopUpdate.logic";	14	} from "./desktopUpdate.logic";
@@ -15,6 +17,9 @@ const baseState: DesktopUpdateState = { · 2 unmodified lines
15	enabled: true,	17	enabled: true,
16	status: "idle",	18	status: "idle",
17	currentVersion: "1.0.0",	19	currentVersion: "1.0.0",
		20	hostArch: "x64",
		21	appArch: "x64",
		22	runningUnderArm64Translation: false,
18	availableVersion: null,	23	availableVersion: null,
19	downloadedVersion: null,	24	downloadedVersion: null,
20	downloadPercent: null,	25	downloadPercent: null,
@@ -171,4 +176,30 @@ describe("desktop update UI helpers", () => { · 150 unmodified lines
171	}),	176	}),
172	).toBe(false);	177	).toBe(false);
173	});	178	});
		179
		180	it("shows an Apple Silicon warning for Intel builds under Rosetta", () => {
		181	const state: DesktopUpdateState = {
		182	...baseState,
		183	hostArch: "arm64",
		184	appArch: "x64",
		185	runningUnderArm64Translation: true,
		186	};
		187
		188	expect(shouldShowArm64IntelBuildWarning(state)).toBe(true);
		189	expect(getArm64IntelBuildWarningDescription(state)).toContain("Apple Silicon");
		190	expect(getArm64IntelBuildWarningDescription(state)).toContain("Intel build");
		191	});
		192
		193	it("changes the warning copy when a native build update is ready to download", () => {
		194	const state: DesktopUpdateState = {
		195	...baseState,
		196	hostArch: "arm64",
		197	appArch: "x64",
		198	runningUnderArm64Translation: true,
		199	status: "available",
		200	availableVersion: "1.1.0",
		201	};
		202
		203	expect(getArm64IntelBuildWarningDescription(state)).toContain("Download the available update");
		204	});
174	});	205	});

apps/web/src/components/desktopUpdate.logic.ts+19−0

@@ -32,10 +32,29 @@ export function shouldShowDesktopUpdateButton(state: DesktopUpdateState \| null): · 31 unmodified lines
32	return resolveDesktopUpdateButtonAction(state) !== "none";	32	return resolveDesktopUpdateButtonAction(state) !== "none";
33	}	33	}
34		34
		35	export function shouldShowArm64IntelBuildWarning(state: DesktopUpdateState \| null): boolean {
		36	return state?.hostArch === "arm64" && state.appArch === "x64";
		37	}
		38
35	export function isDesktopUpdateButtonDisabled(state: DesktopUpdateState \| null): boolean {	39	export function isDesktopUpdateButtonDisabled(state: DesktopUpdateState \| null): boolean {
36	return state?.status === "downloading";	40	return state?.status === "downloading";
37	}	41	}
38		42
		43	export function getArm64IntelBuildWarningDescription(state: DesktopUpdateState): string {
		44	if (!shouldShowArm64IntelBuildWarning(state)) {
		45	return "This install is using the correct architecture.";
		46	}
		47
		48	const action = resolveDesktopUpdateButtonAction(state);
		49	if (action === "download") {
		50	return "This Mac has Apple Silicon, but T3 Code is still running the Intel build under Rosetta. Download the available update to switch to the native Apple Silicon build.";
		51	}
		52	if (action === "install") {
		53	return "This Mac has Apple Silicon, but T3 Code is still running the Intel build under Rosetta. Restart to install the downloaded Apple Silicon build.";
		54	}
		55	return "This Mac has Apple Silicon, but T3 Code is still running the Intel build under Rosetta. The next app update will replace it with the native Apple Silicon build.";
		56	}
		57
39	export function getDesktopUpdateButtonTooltip(state: DesktopUpdateState): string {	58	export function getDesktopUpdateButtonTooltip(state: DesktopUpdateState): string {
40	if (state.status === "available") {	59	if (state.status === "available") {
41	return `Update ${state.availableVersion ?? "available"} ready to download`;	60	return `Update ${state.availableVersion ?? "available"} ready to download`;

apps/web/src/components/ui/sidebar.tsx+2−1

     <button
       aria-label={railLabel}
       className={cn(
-        "-translate-x-1/2 group-data-[side=left]:-right-4 absolute inset-y-0 z-20 hidden w-4 transition-all ease-linear after:absolute after:inset-y-0 after:left-1/2 after:w-[2px] hover:after:bg-sidebar-border group-data-[side=right]:left-0 sm:flex",
+        /* disable pointer events only when offcanvas sidebar is collapsed, that's when the rail sits over the native scrollbar on windows and linux. icon mode stays fully clickable. */
+        "-translate-x-1/2 group-data-[side=left]:-right-4 absolute inset-y-0 z-20 hidden w-4 transition-all ease-linear after:absolute after:inset-y-0 after:left-1/2 after:w-[2px] hover:after:bg-sidebar-border group-data-[side=right]:left-0 sm:flex [[data-collapsible=offcanvas][data-state=collapsed]_&]:pointer-events-none",
         "in-data-[side=left]:cursor-w-resize in-data-[side=right]:cursor-e-resize",
         "[[data-side=left][data-state=collapsed]_&]:cursor-e-resize [[data-side=right][data-state=collapsed]_&]:cursor-w-resize",
         "group-data-[collapsible=offcanvas]:translate-x-0 hover:group-data-[collapsible=offcanvas]:bg-sidebar group-data-[collapsible=offcanvas]:after:left-full",

apps/web/src/components/ui/toast.logic.test.ts+40−1

@@ -1,5 +1,5 @@
1	import { assert, describe, it } from "vitest";	1	import { assert, describe, it } from "vitest";
2	import { shouldHideCollapsedToastContent } from "./toast.logic";	2	import { buildVisibleToastLayout, shouldHideCollapsedToastContent } from "./toast.logic";
3		3
4	describe("shouldHideCollapsedToastContent", () => {	4	describe("shouldHideCollapsedToastContent", () => {
5	it("keeps a single visible toast readable", () => {	5	it("keeps a single visible toast readable", () => {
@@ -14,3 +14,42 @@ describe("shouldHideCollapsedToastContent", () => { · 8 unmodified lines
14	assert.equal(shouldHideCollapsedToastContent(1, 3), true);	14	assert.equal(shouldHideCollapsedToastContent(1, 3), true);
15	});	15	});
16	});	16	});
		17
		18	describe("buildVisibleToastLayout", () => {
		19	it("computes indices and offsets from the visible subset", () => {
		20	const visibleToasts = [{ id: "a", height: 48 }, { id: "b", height: 72 }, { id: "c", height: 24 }];
		21
		22	const layout = buildVisibleToastLayout(visibleToasts);
		23
		24	assert.equal(layout.frontmostHeight, 48);
		25	assert.deepEqual(
		26	layout.items.map(({ toast, visibleIndex, offsetY }) => ({
		27	id: toast.id,
		28	visibleIndex,
		29	offsetY,
		30	})),
		31	[
		32	{ id: "a", visibleIndex: 0, offsetY: 0 },
		33	{ id: "b", visibleIndex: 1, offsetY: 48 },
		34	{ id: "c", visibleIndex: 2, offsetY: 120 },
		35	],
		36	);
		37	});
		38
		39	it("treats missing heights as zero", () => {
		40	const layout = buildVisibleToastLayout([{ id: "a" }, { id: "b", height: undefined }, { id: "c", height: 30 }]);
		41
		42	assert.equal(layout.frontmostHeight, 0);
		43	assert.deepEqual(
		44	layout.items.map(({ toast, offsetY }) => ({
		45	id: toast.id,
		46	offsetY,
		47	})),
		48	[
		49	{ id: "a", offsetY: 0 },
		50	{ id: "b", offsetY: 0 },
		51	{ id: "c", offsetY: 0 },
		52	],
		53	);
		54	});
		55	});

apps/web/src/components/ui/toast.logic.ts+37−0

@@ -7,3 +7,40 @@ export function shouldHideCollapsedToastContent( · 6 unmodified lines
7	if (visibleToastCount <= 1) return false;	7	if (visibleToastCount <= 1) return false;
8	return visibleToastIndex > 0;	8	return visibleToastIndex > 0;
9	}	9	}
		10
		11	type ToastWithHeight = {
		12	height?: number \| null \| undefined;
		13	};
		14
		15	type VisibleToastLayoutItem<TToast extends object> = {
		16	toast: TToast;
		17	visibleIndex: number;
		18	offsetY: number;
		19	};
		20
		21	export function buildVisibleToastLayout<TToast extends object>(
		22	visibleToasts: readonly (TToast & ToastWithHeight)[],
		23	): {
		24	frontmostHeight: number;
		25	items: VisibleToastLayoutItem<TToast & ToastWithHeight>[];
		26	} {
		27	let offsetY = 0;
		28
		29	return {
		30	frontmostHeight: normalizeToastHeight(visibleToasts[0]?.height),
		31	items: visibleToasts.map((toast, visibleIndex) => {
		32	const item = {
		33	toast,
		34	visibleIndex,
		35	offsetY,
		36	};
		37
		38	offsetY += normalizeToastHeight(toast.height);
		39	return item;
		40	}),
		41	};
		42	}
		43
		44	function normalizeToastHeight(height: number \| null \| undefined): number {
		45	return typeof height === "number" && Number.isFinite(height) && height > 0 ? height : 0;
		46	}

apps/web/src/components/ui/toast.tsx+16−4

 "use client";
 import { Toast } from "@base-ui/react/toast";
-import { useEffect } from "react";
+import { useEffect, type CSSProperties } from "react";
 import { useParams } from "@tanstack/react-router";
 import { ThreadId } from "@t3tools/contracts";
 import {
 import { cn } from "~/lib/utils";
 import { buttonVariants } from "~/components/ui/button";
-import { shouldHideCollapsedToastContent } from "./toast.logic";
+import { buildVisibleToastLayout, shouldHideCollapsedToastContent } from "./toast.logic";
 type ThreadToastData = {
   threadId?: ThreadId | null;
   const visibleToasts = toasts.filter((toast) =>
     shouldRenderForActiveThread(toast.data, activeThreadId),
   );
+  const visibleToastLayout = buildVisibleToastLayout(visibleToasts);
   useEffect(() => {
     const activeToastIds = new Set(toasts.map((toast) => toast.id));
         )}
         data-position={position}
         data-slot="toast-viewport"
+        style={
+          {
+            "--toast-frontmost-height": `${visibleToastLayout.frontmostHeight}px`,
+          } as CSSProperties
+        }
       >
-        {visibleToasts.map((toast, visibleIndex) => {
+        {visibleToastLayout.items.map(({ toast, visibleIndex, offsetY }) => {
           const Icon = toast.type ? TOAST_ICONS[toast.type as keyof typeof TOAST_ICONS] : null;
           const hideCollapsedContent = shouldHideCollapsedToastContent(
             visibleIndex,
-            visibleToasts.length,
+            visibleToastLayout.items.length,
           );
           return (
               )}
               data-position={position}
               key={toast.id}
+              style={
+                {
+                  "--toast-index": visibleIndex,
+                  "--toast-offset-y": `${offsetY}px`,
+                } as CSSProperties
+              }
               swipeDirection={
                 position.includes("center")
                   ? [isTop ? "up" : "down"]

apps/web/src/proposedPlan.ts+16−0

@@ -49,3 +49,19 @@ export function buildProposedPlanMarkdownFilename(planMarkdown: string): string · 48 unmodified lines
49	const title = proposedPlanTitle(planMarkdown);	49	const title = proposedPlanTitle(planMarkdown);
50	return `${sanitizePlanFileSegment(title ?? "plan")}.md`;	50	return `${sanitizePlanFileSegment(title ?? "plan")}.md`;
51	}	51	}
		52
		53	export function normalizePlanMarkdownForExport(planMarkdown: string): string {
		54	return `${planMarkdown.trimEnd()}\n`;
		55	}
		56
		57	export function downloadPlanAsTextFile(filename: string, contents: string): void {
		58	const blob = new Blob([contents], { type: "text/markdown;charset=utf-8" });
		59	const url = URL.createObjectURL(blob);
		60	const anchor = document.createElement("a");
		61	anchor.href = url;
		62	anchor.download = filename;
		63	anchor.click();
		64	window.setTimeout(() => {
		65	URL.revokeObjectURL(url);
		66	}, 0);
		67	}

apps/web/src/routes/_chat.settings.tsx+5−55

@@ -3,14 +3,8 @@ import { useQuery } from "@tanstack/react-query"; · 2 unmodified lines
3	import { useCallback, useState } from "react";	3	import { useCallback, useState } from "react";
4	import { type ProviderKind } from "@t3tools/contracts";	4	import { type ProviderKind } from "@t3tools/contracts";
5	import { getModelOptions, normalizeModelSlug } from "@t3tools/shared/model";	5	import { getModelOptions, normalizeModelSlug } from "@t3tools/shared/model";
6	import { ZapIcon } from "lucide-react";	6
7		7	import { MAX_CUSTOM_MODEL_LENGTH, useAppSettings } from "../appSettings";
8	import {
9	APP_SERVICE_TIER_OPTIONS,
10	MAX_CUSTOM_MODEL_LENGTH,
11	shouldShowFastTierIcon,
12	useAppSettings,
13	} from "../appSettings";
14	import { isElectron } from "../env";	8	import { isElectron } from "../env";
15	import { useTheme } from "../hooks/useTheme";	9	import { useTheme } from "../hooks/useTheme";
16	import { serverConfigQueryOptions } from "../lib/serverReactQuery";	10	import { serverConfigQueryOptions } from "../lib/serverReactQuery";
@@ -18,7 +12,6 @@ import { ensureNativeApi } from "../nativeApi"; · 1 unmodified line
18	import { preferredTerminalEditor } from "../terminal-links";	12	import { preferredTerminalEditor } from "../terminal-links";
19	import { Button } from "../components/ui/button";	13	import { Button } from "../components/ui/button";
20	import { Input } from "../components/ui/input";	14	import { Input } from "../components/ui/input";
21	import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../components/ui/select";
22	import { Switch } from "../components/ui/switch";	15	import { Switch } from "../components/ui/switch";
23	import { SidebarInset } from "~/components/ui/sidebar";	16	import { SidebarInset } from "~/components/ui/sidebar";
24		17
@@ -103,7 +96,6 @@ function SettingsRouteView() { · 78 unmodified lines
103		96
104	const codexBinaryPath = settings.codexBinaryPath;	97	const codexBinaryPath = settings.codexBinaryPath;
105	const codexHomePath = settings.codexHomePath;	98	const codexHomePath = settings.codexHomePath;
106	const codexServiceTier = settings.codexServiceTier;
107	const keybindingsConfigPath = serverConfigQuery.data?.keybindingsConfigPath ?? null;	99	const keybindingsConfigPath = serverConfigQuery.data?.keybindingsConfigPath ?? null;
108		100
109	const openKeybindingsFile = useCallback(() => {	101	const openKeybindingsFile = useCallback(() => {
@@ -310,43 +302,6 @@ function SettingsRouteView() { · 200 unmodified lines
310	</div>	302	</div>
311		303
312	<div className="space-y-5">	304	<div className="space-y-5">
313	<label className="block space-y-1">
314	<span className="text-xs font-medium text-foreground">Default service tier</span>
315	<Select
316	items={APP_SERVICE_TIER_OPTIONS.map((option) => ({
317	label: option.label,
318	value: option.value,
319	}))}
320	value={codexServiceTier}
321	onValueChange={(value) => {
322	if (!value) return;
323	updateSettings({ codexServiceTier: value });
324	}}
325	>
326	<SelectTrigger>
327	<SelectValue />
328	</SelectTrigger>
329	<SelectPopup alignItemWithTrigger={false}>
330	{APP_SERVICE_TIER_OPTIONS.map((option) => (
331	<SelectItem key={option.value} value={option.value}>
332	<div className="flex min-w-0 items-center gap-2">
333	{option.value === "fast" ? (
334	<ZapIcon className="size-3.5 text-amber-500" />
335	) : (
336	<span className="size-3.5 shrink-0" aria-hidden="true" />
337	)}
338	<span className="truncate">{option.label}</span>
339	</div>
340	</SelectItem>
341	))}
342	</SelectPopup>
343	</Select>
344	<span className="text-xs text-muted-foreground">
345	{APP_SERVICE_TIER_OPTIONS.find((option) => option.value === codexServiceTier)
346	?.description ?? "Use Codex defaults without forcing a service tier."}
347	</span>
348	</label>
349
350	{MODEL_PROVIDER_SETTINGS.map((providerSettings) => {	305	{MODEL_PROVIDER_SETTINGS.map((providerSettings) => {
351	const provider = providerSettings.provider;	306	const provider = providerSettings.provider;
352	const customModels = getCustomModelsForProvider(settings, provider);	307	const customModels = getCustomModelsForProvider(settings, provider);
@@ -445,14 +400,9 @@ function SettingsRouteView() { · 92 unmodified lines
445	key={`${provider}:${slug}`}	400	key={`${provider}:${slug}`}
446	className="flex items-center justify-between gap-3 rounded-lg border border-border bg-background px-3 py-2"	401	className="flex items-center justify-between gap-3 rounded-lg border border-border bg-background px-3 py-2"
447	>	402	>
448	<div className="flex min-w-0 flex-1 items-center gap-2">	403	<code className="min-w-0 flex-1 truncate text-xs text-foreground">
449	{provider === "codex" && shouldShowFastTierIcon(slug, codexServiceTier) ? (	404	{slug}
450	<ZapIcon className="size-3.5 shrink-0 text-amber-500" />	405	</code>
451	) : null}
452	<code className="min-w-0 flex-1 truncate text-xs text-foreground">
453	{slug}
454	</code>
455	</div>
456	<Button	406	<Button
457	size="xs"	407	size="xs"
458	variant="ghost"	408	variant="ghost"

apps/web/src/store.ts+1−0

@@ -25,6 +25,7 @@ export interface AppState { · 24 unmodified lines
25		25
26	const PERSISTED_STATE_KEY = "t3code:renderer-state:v8";	26	const PERSISTED_STATE_KEY = "t3code:renderer-state:v8";
27	const LEGACY_PERSISTED_STATE_KEYS = [	27	const LEGACY_PERSISTED_STATE_KEYS = [
		28	"t3code:renderer-state:v7",
28	"t3code:renderer-state:v6",	29	"t3code:renderer-state:v6",
29	"t3code:renderer-state:v5",	30	"t3code:renderer-state:v5",
30	"t3code:renderer-state:v4",	31	"t3code:renderer-state:v4",

apps/web/vite.config.ts+9−0

 import { defineConfig } from "vite";
 const port = Number(process.env.PORT ?? 5733);
+const sourcemapEnv = process.env.T3CODE_WEB_SOURCEMAP?.trim().toLowerCase();
+const buildSourcemap =
+  sourcemapEnv === "0" || sourcemapEnv === "false"
+    ? false
+    : sourcemapEnv === "hidden"
+      ? "hidden"
+      : true;
 export default defineConfig({
   plugins: [
   build: {
     outDir: "dist",
     emptyOutDir: true,
+    sourcemap: buildSourcemap,
   },
 });

bun.lock+4−4

@@ -14,7 +14,7 @@ · 13 unmodified lines
14	},	14	},
15	"apps/desktop": {	15	"apps/desktop": {
16	"name": "@t3tools/desktop",	16	"name": "@t3tools/desktop",
17	"version": "0.0.5",	17	"version": "0.0.9",
18	"dependencies": {	18	"dependencies": {
19	"effect": "catalog:",	19	"effect": "catalog:",
20	"electron": "40.6.0",	20	"electron": "40.6.0",
@@ -43,7 +43,7 @@ · 22 unmodified lines
43	},	43	},
44	"apps/server": {	44	"apps/server": {
45	"name": "t3",	45	"name": "t3",
46	"version": "0.0.5",	46	"version": "0.0.9",
47	"bin": {	47	"bin": {
48	"t3": "./dist/index.mjs",	48	"t3": "./dist/index.mjs",
49	},	49	},
@@ -72,7 +72,7 @@ · 22 unmodified lines
72	},	72	},
73	"apps/web": {	73	"apps/web": {
74	"name": "@t3tools/web",	74	"name": "@t3tools/web",
75	"version": "0.0.5",	75	"version": "0.0.9",
76	"dependencies": {	76	"dependencies": {
77	"@base-ui/react": "^1.2.0",	77	"@base-ui/react": "^1.2.0",
78	"@lexical/react": "^0.41.0",	78	"@lexical/react": "^0.41.0",
@@ -116,7 +116,7 @@ · 37 unmodified lines
116	},	116	},
117	"packages/contracts": {	117	"packages/contracts": {
118	"name": "@t3tools/contracts",	118	"name": "@t3tools/contracts",
119	"version": "0.0.5",	119	"version": "0.0.9",
120	"dependencies": {	120	"dependencies": {
121	"effect": "catalog:",	121	"effect": "catalog:",
122	},	122	},

package.json+1−0

@@ -45,6 +45,7 @@ · 44 unmodified lines
45	"dist:desktop:dmg:x64": "node scripts/build-desktop-artifact.ts --platform mac --target dmg --arch x64",	45	"dist:desktop:dmg:x64": "node scripts/build-desktop-artifact.ts --platform mac --target dmg --arch x64",
46	"dist:desktop:linux": "node scripts/build-desktop-artifact.ts --platform linux --target AppImage --arch x64",	46	"dist:desktop:linux": "node scripts/build-desktop-artifact.ts --platform linux --target AppImage --arch x64",
47	"dist:desktop:win": "node scripts/build-desktop-artifact.ts --platform win --target nsis --arch x64",	47	"dist:desktop:win": "node scripts/build-desktop-artifact.ts --platform win --target nsis --arch x64",
		48	"release:smoke": "node scripts/release-smoke.ts",
48	"clean": "rm -rf node_modules apps//node_modules packages//node_modules apps//dist apps//dist-electron packages//dist .turbo apps//.turbo packages/*/.turbo",	49	"clean": "rm -rf node_modules apps//node_modules packages//node_modules apps//dist apps//dist-electron packages//dist .turbo apps//.turbo packages/*/.turbo",
49	"sync:vscode-icons": "node scripts/sync-vscode-icons.mjs"	50	"sync:vscode-icons": "node scripts/sync-vscode-icons.mjs"
50	},	51	},

packages/contracts/package.json+1−1

@@ -1,6 +1,6 @@
1	{	1	{
2	"name": "@t3tools/contracts",	2	"name": "@t3tools/contracts",
3	"version": "0.0.5",	3	"version": "0.0.9",
4	"private": true,	4	"private": true,
5	"files": [	5	"files": [
6	"dist"	6	"dist"

packages/contracts/src/ipc.ts+11−0

@@ -58,10 +58,21 @@ export type DesktopUpdateStatus = · 57 unmodified lines
58	\| "downloaded"	58	\| "downloaded"
59	\| "error";	59	\| "error";
60		60
		61	export type DesktopRuntimeArch = "arm64" \| "x64" \| "other";
		62
		63	export interface DesktopRuntimeInfo {
		64	hostArch: DesktopRuntimeArch;
		65	appArch: DesktopRuntimeArch;
		66	runningUnderArm64Translation: boolean;
		67	}
		68
61	export interface DesktopUpdateState {	69	export interface DesktopUpdateState {
62	enabled: boolean;	70	enabled: boolean;
63	status: DesktopUpdateStatus;	71	status: DesktopUpdateStatus;
64	currentVersion: string;	72	currentVersion: string;
		73	hostArch: DesktopRuntimeArch;
		74	appArch: DesktopRuntimeArch;
		75	runningUnderArm64Translation: boolean;
65	availableVersion: string \| null;	76	availableVersion: string \| null;
66	downloadedVersion: string \| null;	77	downloadedVersion: string \| null;
67	downloadPercent: number \| null;	78	downloadPercent: number \| null;

packages/contracts/src/orchestration.ts+0−123

@@ -42,8 +42,6 @@ export const ProviderSandboxMode = Schema.Literals([ · 41 unmodified lines
42	"danger-full-access",	42	"danger-full-access",
43	]);	43	]);
44	export type ProviderSandboxMode = typeof ProviderSandboxMode.Type;	44	export type ProviderSandboxMode = typeof ProviderSandboxMode.Type;
45	export const ProviderServiceTier = Schema.Literals(["fast", "flex"]);
46	export type ProviderServiceTier = typeof ProviderServiceTier.Type;
47	export const DEFAULT_PROVIDER_KIND: ProviderKind = "codex";	45	export const DEFAULT_PROVIDER_KIND: ProviderKind = "codex";
48	const CodexProviderStartOptions = Schema.Struct({	46	const CodexProviderStartOptions = Schema.Struct({
49	binaryPath: Schema.optional(TrimmedNonEmptyString),	47	binaryPath: Schema.optional(TrimmedNonEmptyString),
@@ -371,7 +369,6 @@ export const ThreadTurnStartCommand = Schema.Struct({ · 321 unmodified lines
371	}),	369	}),
372	provider: Schema.optional(ProviderKind),	370	provider: Schema.optional(ProviderKind),
373	model: Schema.optional(TrimmedNonEmptyString),	371	model: Schema.optional(TrimmedNonEmptyString),
374	serviceTier: Schema.optional(Schema.NullOr(ProviderServiceTier)),
375	modelOptions: Schema.optional(ProviderModelOptions),	372	modelOptions: Schema.optional(ProviderModelOptions),
376	providerOptions: Schema.optional(ProviderStartOptions),	373	providerOptions: Schema.optional(ProviderStartOptions),
377	assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),	374	assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),
@@ -394,7 +391,6 @@ const ClientThreadTurnStartCommand = Schema.Struct({ · 16 unmodified lines
394	}),	391	}),
395	provider: Schema.optional(ProviderKind),	392	provider: Schema.optional(ProviderKind),
396	model: Schema.optional(TrimmedNonEmptyString),	393	model: Schema.optional(TrimmedNonEmptyString),
397	serviceTier: Schema.optional(Schema.NullOr(ProviderServiceTier)),
398	modelOptions: Schema.optional(ProviderModelOptions),	394	modelOptions: Schema.optional(ProviderModelOptions),
399	providerOptions: Schema.optional(ProviderStartOptions),	395	providerOptions: Schema.optional(ProviderStartOptions),
400	assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),	396	assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),
@@ -675,7 +671,6 @@ export const ThreadTurnStartRequestedPayload = Schema.Struct({ · 274 unmodified lines
675	messageId: MessageId,	671	messageId: MessageId,
676	provider: Schema.optional(ProviderKind),	672	provider: Schema.optional(ProviderKind),
677	model: Schema.optional(TrimmedNonEmptyString),	673	model: Schema.optional(TrimmedNonEmptyString),
678	serviceTier: Schema.optional(Schema.NullOr(ProviderServiceTier)),
679	modelOptions: Schema.optional(ProviderModelOptions),	674	modelOptions: Schema.optional(ProviderModelOptions),
680	providerOptions: Schema.optional(ProviderStartOptions),	675	providerOptions: Schema.optional(ProviderStartOptions),
681	assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),	676	assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),
@@ -769,20 +764,6 @@ const EventBaseFields = { · 87 unmodified lines
769	metadata: OrchestrationEventMetadata,	764	metadata: OrchestrationEventMetadata,
770	} as const;	765	} as const;
771		766
772	const PersistedEventBaseFields = {
773	sequence: NonNegativeInt,
774	eventId: EventId,
775	aggregateKind: OrchestrationAggregateKind,
776	streamId: Schema.Union([ProjectId, ThreadId]),
777	streamVersion: NonNegativeInt,
778	occurredAt: IsoDateTime,
779	commandId: Schema.NullOr(CommandId),
780	causationEventId: Schema.NullOr(EventId),
781	correlationId: Schema.NullOr(CommandId),
782	actorKind: OrchestrationActorKind,
783	metadata: OrchestrationEventMetadata,
784	} as const;
785
786	export const OrchestrationEvent = Schema.Union([	767	export const OrchestrationEvent = Schema.Union([
787	Schema.Struct({	768	Schema.Struct({
788	...EventBaseFields,	769	...EventBaseFields,
@@ -887,110 +868,6 @@ export const OrchestrationEvent = Schema.Union([ · 98 unmodified lines
887	]);	868	]);
888	export type OrchestrationEvent = typeof OrchestrationEvent.Type;	869	export type OrchestrationEvent = typeof OrchestrationEvent.Type;
889		870
890	export const OrchestrationPersistedEvent = Schema.Union([
891	Schema.Struct({
892	...PersistedEventBaseFields,
893	eventType: Schema.Literal("project.created"),
894	payload: ProjectCreatedPayload,
895	}),
896	Schema.Struct({
897	...PersistedEventBaseFields,
898	eventType: Schema.Literal("project.meta-updated"),
899	payload: ProjectMetaUpdatedPayload,
900	}),
901	Schema.Struct({
902	...PersistedEventBaseFields,
903	eventType: Schema.Literal("project.deleted"),
904	payload: ProjectDeletedPayload,
905	}),
906	Schema.Struct({
907	...PersistedEventBaseFields,
908	eventType: Schema.Literal("thread.created"),
909	payload: ThreadCreatedPayload,
910	}),
911	Schema.Struct({
912	...PersistedEventBaseFields,
913	eventType: Schema.Literal("thread.deleted"),
914	payload: ThreadDeletedPayload,
915	}),
916	Schema.Struct({
917	...PersistedEventBaseFields,
918	eventType: Schema.Literal("thread.meta-updated"),
919	payload: ThreadMetaUpdatedPayload,
920	}),
921	Schema.Struct({
922	...PersistedEventBaseFields,
923	eventType: Schema.Literal("thread.runtime-mode-set"),
924	payload: ThreadRuntimeModeSetPayload,
925	}),
926	Schema.Struct({
927	...PersistedEventBaseFields,
928	eventType: Schema.Literal("thread.interaction-mode-set"),
929	payload: ThreadInteractionModeSetPayload,
930	}),
931	Schema.Struct({
932	...PersistedEventBaseFields,
933	eventType: Schema.Literal("thread.message-sent"),
934	payload: ThreadMessageSentPayload,
935	}),
936	Schema.Struct({
937	...PersistedEventBaseFields,
938	eventType: Schema.Literal("thread.turn-start-requested"),
939	payload: ThreadTurnStartRequestedPayload,
940	}),
941	Schema.Struct({
942	...PersistedEventBaseFields,
943	eventType: Schema.Literal("thread.turn-interrupt-requested"),
944	payload: ThreadTurnInterruptRequestedPayload,
945	}),
946	Schema.Struct({
947	...PersistedEventBaseFields,
948	eventType: Schema.Literal("thread.approval-response-requested"),
949	payload: ThreadApprovalResponseRequestedPayload,
950	}),
951	Schema.Struct({
952	...PersistedEventBaseFields,
953	eventType: Schema.Literal("thread.user-input-response-requested"),
954	payload: ThreadUserInputResponseRequestedPayload,
955	}),
956	Schema.Struct({
957	...PersistedEventBaseFields,
958	eventType: Schema.Literal("thread.checkpoint-revert-requested"),
959	payload: ThreadCheckpointRevertRequestedPayload,
960	}),
961	Schema.Struct({
962	...PersistedEventBaseFields,
963	eventType: Schema.Literal("thread.reverted"),
964	payload: ThreadRevertedPayload,
965	}),
966	Schema.Struct({
967	...PersistedEventBaseFields,
968	eventType: Schema.Literal("thread.session-stop-requested"),
969	payload: ThreadSessionStopRequestedPayload,
970	}),
971	Schema.Struct({
972	...PersistedEventBaseFields,
973	eventType: Schema.Literal("thread.session-set"),
974	payload: ThreadSessionSetPayload,
975	}),
976	Schema.Struct({
977	...PersistedEventBaseFields,
978	eventType: Schema.Literal("thread.proposed-plan-upserted"),
979	payload: ThreadProposedPlanUpsertedPayload,
980	}),
981	Schema.Struct({
982	...PersistedEventBaseFields,
983	eventType: Schema.Literal("thread.turn-diff-completed"),
984	payload: ThreadTurnDiffCompletedPayload,
985	}),
986	Schema.Struct({
987	...PersistedEventBaseFields,
988	eventType: Schema.Literal("thread.activity-appended"),
989	payload: ThreadActivityAppendedPayload,
990	}),
991	]);
992	export type OrchestrationPersistedEvent = typeof OrchestrationPersistedEvent.Type;
993
994	export const OrchestrationCommandReceiptStatus = Schema.Literals(["accepted", "rejected"]);	871	export const OrchestrationCommandReceiptStatus = Schema.Literals(["accepted", "rejected"]);
995	export type OrchestrationCommandReceiptStatus = typeof OrchestrationCommandReceiptStatus.Type;	872	export type OrchestrationCommandReceiptStatus = typeof OrchestrationCommandReceiptStatus.Type;
996		873

packages/contracts/src/provider.ts+0−3

   ProviderKind,
   ProviderRequestKind,
   ProviderSandboxMode,
-  ProviderServiceTier,
   ProviderUserInputAnswers,
   RuntimeMode,
 } from "./orchestration";
   model: Schema.optional(TrimmedNonEmptyStringSchema),
   modelOptions: Schema.optional(ProviderModelOptions),
   resumeCursor: Schema.optional(Schema.Unknown),
-  serviceTier: Schema.optional(Schema.NullOr(ProviderServiceTier)),
   approvalPolicy: Schema.optional(ProviderApprovalPolicy),
   sandboxMode: Schema.optional(ProviderSandboxMode),
   providerOptions: Schema.optional(ProviderStartOptions),
     Schema.Array(ChatAttachment).check(Schema.isMaxLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS)),
   ),
   model: Schema.optional(TrimmedNonEmptyStringSchema),
-  serviceTier: Schema.optional(Schema.NullOr(ProviderServiceTier)),
   modelOptions: Schema.optional(ProviderModelOptions),
   interactionMode: Schema.optional(ProviderInteractionMode),
 });

scripts/build-desktop-artifact.ts+6−0

       ChildProcess.make({
         cwd: repoRoot,
         ...commandOutputOptions(options.verbose),
+        // Windows needs shell mode to resolve .cmd shims (e.g. bun.cmd).
+        shell: process.platform === "win32",
       })`bun run build:desktop`,
     );
   }
     ChildProcess.make({
       cwd: stageAppDir,
       ...commandOutputOptions(options.verbose),
+      // Windows needs shell mode to resolve .cmd shims (e.g. bun.cmd).
+      shell: process.platform === "win32",
     })`bun install --production`,
   );
       cwd: stageAppDir,
       env: buildEnv,
       ...commandOutputOptions(options.verbose),
+      // Windows needs shell mode to resolve .cmd shims.
+      shell: process.platform === "win32",
     })`bunx electron-builder ${platformConfig.cliFlag} --${options.arch} --publish never`,
   );

scripts/dev-runner.ts+2−0

         stderr: "inherit",
         env,
         extendEnv: false,
+        // Windows needs shell mode to resolve .cmd shims (e.g. bun.cmd).
+        shell: process.platform === "win32",
         // Keep turbo in the same process group so terminal signals (Ctrl+C)
         // reach it directly. Effect defaults to detached: true on non-Windows,
         // which would put turbo in a new group and require manual forwarding.

scripts/release-smoke.ts+113−0

@@ -0,0 +1,113 @@
	1	import { execFileSync } from "node:child_process";
	2	import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
	3	import { tmpdir } from "node:os";
	4	import { dirname, join, resolve } from "node:path";
	5	import { fileURLToPath } from "node:url";
	6
	7	const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
	8
	9	const workspaceFiles = [
	10	"package.json",
	11	"bun.lock",
	12	"apps/server/package.json",
	13	"apps/desktop/package.json",
	14	"apps/web/package.json",
	15	"apps/marketing/package.json",
	16	"packages/contracts/package.json",
	17	"packages/shared/package.json",
	18	"scripts/package.json",
	19	] as const;
	20
	21	function copyWorkspaceManifestFixture(targetRoot: string): void {
	22	for (const relativePath of workspaceFiles) {
	23	const sourcePath = resolve(repoRoot, relativePath);
	24	const destinationPath = resolve(targetRoot, relativePath);
	25	mkdirSync(dirname(destinationPath), { recursive: true });
	26	cpSync(sourcePath, destinationPath);
	27	}
	28	}
	29
	30	function writeMacManifestFixtures(targetRoot: string): { arm64Path: string; x64Path: string } {
	31	const assetDirectory = resolve(targetRoot, "release-assets");
	32	mkdirSync(assetDirectory, { recursive: true });
	33
	34	const arm64Path = resolve(assetDirectory, "latest-mac.yml");
	35	const x64Path = resolve(assetDirectory, "latest-mac-x64.yml");
	36
	37	writeFileSync(
	38	arm64Path,
	39	`version: 9.9.9-smoke.0
	40	files:
	41	- url: T3-Code-9.9.9-smoke.0-arm64.zip
	42	sha512: arm64zip
	43	size: 125621344
	44	- url: T3-Code-9.9.9-smoke.0-arm64.dmg
	45	sha512: arm64dmg
	46	size: 131754935
	47	path: T3-Code-9.9.9-smoke.0-arm64.zip
	48	sha512: arm64zip
	49	releaseDate: '2026-03-08T10:32:14.587Z'
	50	`,
	51	);
	52
	53	writeFileSync(
	54	x64Path,
	55	`version: 9.9.9-smoke.0
	56	files:
	57	- url: T3-Code-9.9.9-smoke.0-x64.zip
	58	sha512: x64zip
	59	size: 132000112
	60	- url: T3-Code-9.9.9-smoke.0-x64.dmg
	61	sha512: x64dmg
	62	size: 138148807
	63	path: T3-Code-9.9.9-smoke.0-x64.zip
	64	sha512: x64zip
	65	releaseDate: '2026-03-08T10:36:07.540Z'
	66	`,
	67	);
	68
	69	return { arm64Path, x64Path };
	70	}
	71
	72	function assertContains(haystack: string, needle: string, message: string): void {
	73	if (!haystack.includes(needle)) {
	74	throw new Error(message);
	75	}
	76	}
	77
	78	const tempRoot = mkdtempSync(join(tmpdir(), "t3-release-smoke-"));
	79
	80	try {
	81	copyWorkspaceManifestFixture(tempRoot);
	82
	83	execFileSync(
	84	process.execPath,
	85	[resolve(repoRoot, "scripts/update-release-package-versions.ts"), "9.9.9-smoke.0", "--root", tempRoot],
	86	{
	87	cwd: repoRoot,
	88	stdio: "inherit",
	89	},
	90	);
	91
	92	execFileSync("bun", ["install", "--lockfile-only", "--ignore-scripts"], {
	93	cwd: tempRoot,
	94	stdio: "inherit",
	95	});
	96
	97	const lockfile = readFileSync(resolve(tempRoot, "bun.lock"), "utf8");
	98	assertContains(lockfile, `"version": "9.9.9-smoke.0"`, "Expected bun.lock to contain the smoke version.");
	99
	100	const { arm64Path, x64Path } = writeMacManifestFixtures(tempRoot);
	101	execFileSync(process.execPath, [resolve(repoRoot, "scripts/merge-mac-update-manifests.ts"), arm64Path, x64Path], {
	102	cwd: repoRoot,
	103	stdio: "inherit",
	104	});
	105
	106	const mergedManifest = readFileSync(arm64Path, "utf8");
	107	assertContains(mergedManifest, "T3-Code-9.9.9-smoke.0-arm64.zip", "Merged manifest is missing the arm64 asset.");
	108	assertContains(mergedManifest, "T3-Code-9.9.9-smoke.0-x64.zip", "Merged manifest is missing the x64 asset.");
	109
	110	console.log("Release smoke checks passed.");
	111	} finally {
	112	rmSync(tempRoot, { recursive: true, force: true });
	113	}

scripts/update-release-package-versions.ts+111−0

@@ -0,0 +1,111 @@
	1	import { appendFileSync, readFileSync, writeFileSync } from "node:fs";
	2	import { resolve } from "node:path";
	3	import { fileURLToPath } from "node:url";
	4
	5	export const releasePackageFiles = [
	6	"apps/server/package.json",
	7	"apps/desktop/package.json",
	8	"apps/web/package.json",
	9	"packages/contracts/package.json",
	10	] as const;
	11
	12	interface UpdateReleasePackageVersionsOptions {
	13	readonly rootDir?: string;
	14	}
	15
	16	interface MutablePackageJson {
	17	version?: string;
	18	[key: string]: unknown;
	19	}
	20
	21	export function updateReleasePackageVersions(
	22	version: string,
	23	options: UpdateReleasePackageVersionsOptions = {},
	24	): { changed: boolean } {
	25	const rootDir = resolve(options.rootDir ?? process.cwd());
	26	let changed = false;
	27
	28	for (const relativePath of releasePackageFiles) {
	29	const filePath = resolve(rootDir, relativePath);
	30	const packageJson = JSON.parse(readFileSync(filePath, "utf8")) as MutablePackageJson;
	31	if (packageJson.version === version) {
	32	continue;
	33	}
	34
	35	packageJson.version = version;
	36	writeFileSync(filePath, `${JSON.stringify(packageJson, null, 2)}\n`);
	37	changed = true;
	38	}
	39
	40	return { changed };
	41	}
	42
	43	function parseArgs(argv: ReadonlyArray<string>): {
	44	version: string;
	45	rootDir: string \| undefined;
	46	writeGithubOutput: boolean;
	47	} {
	48	let version: string \| undefined;
	49	let rootDir: string \| undefined;
	50	let writeGithubOutput = false;
	51
	52	for (let index = 0; index < argv.length; index += 1) {
	53	const argument = argv[index];
	54	if (argument === undefined) {
	55	continue;
	56	}
	57
	58	if (argument === "--github-output") {
	59	writeGithubOutput = true;
	60	continue;
	61	}
	62
	63	if (argument === "--root") {
	64	rootDir = argv[index + 1];
	65	if (!rootDir) {
	66	throw new Error("Missing value for --root.");
	67	}
	68	index += 1;
	69	continue;
	70	}
	71
	72	if (argument.startsWith("--")) {
	73	throw new Error(`Unknown argument: ${argument}`);
	74	}
	75
	76	if (version !== undefined) {
	77	throw new Error("Only one release version can be provided.");
	78	}
	79	version = argument;
	80	}
	81
	82	if (!version) {
	83	throw new Error(
	84	"Usage: node scripts/update-release-package-versions.ts <version> [--root <path>] [--github-output]",
	85	);
	86	}
	87
	88	return { version, rootDir, writeGithubOutput };
	89	}
	90
	91	const isMain = process.argv[1] !== undefined && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
	92
	93	if (isMain) {
	94	const { version, rootDir, writeGithubOutput } = parseArgs(process.argv.slice(2));
	95	const { changed } = updateReleasePackageVersions(
	96	version,
	97	rootDir === undefined ? {} : { rootDir },
	98	);
	99
	100	if (!changed) {
	101	console.log("All package.json versions already match release version.");
	102	}
	103
	104	if (writeGithubOutput) {
	105	const githubOutputPath = process.env.GITHUB_OUTPUT;
	106	if (!githubOutputPath) {
	107	throw new Error("GITHUB_OUTPUT is required when --github-output is set.");
	108	}
	109	appendFileSync(githubOutputPath, `changed=${changed}\n`);
	110	}
	111	}