Commit e5542b7a880aa40ab5a4b5ad8012822c11643471 | the-knife

apps/server/src/checkpointing/Layers/CheckpointStore.ts+11-13

 @@ -78,7 +78,7 @@ const makeCheckpointStore = Effect.gen(function* () {
     git
       .execute({
         operation: "CheckpointStore.isGitRepository",
-        cwd: cwd.trim(),
+        cwd,
         args: ["rev-parse", "--is-inside-work-tree"],
         allowNonZeroExit: true,
       })
 @@ -90,8 +90,6 @@ const makeCheckpointStore = Effect.gen(function* () {
   const captureCheckpoint: CheckpointStoreShape["captureCheckpoint"] = (input) =>
     Effect.gen(function* () {
       const operation = "CheckpointStore.captureCheckpoint";
-      const normalizedCwd = input.cwd.trim();
-      const checkpointRef = input.checkpointRef.trim();
       yield* Effect.acquireUseRelease(
         fs.makeTempDirectory({ prefix: "t3-fs-checkpoint-" }),
 @@ -107,11 +105,11 @@ const makeCheckpointStore = Effect.gen(function* () {
               GIT_COMMITTER_EMAIL: "t3code@users.noreply.github.com",
             };
-            const headExists = yield* hasHeadCommit(normalizedCwd);
+            const headExists = yield* hasHeadCommit(input.cwd);
             if (headExists) {
               yield* git.execute({
                 operation,
-                cwd: normalizedCwd,
+                cwd: input.cwd,
                 args: ["read-tree", "HEAD"],
                 env: commitEnv,
               });
 @@ -119,14 +117,14 @@ const makeCheckpointStore = Effect.gen(function* () {
             yield* git.execute({
               operation,
-              cwd: normalizedCwd,
+              cwd: input.cwd,
               args: ["add", "-A", "--", "."],
               env: commitEnv,
             });
             const writeTreeResult = yield* git.execute({
               operation,
-              cwd: normalizedCwd,
+              cwd: input.cwd,
               args: ["write-tree"],
               env: commitEnv,
             });
 @@ -135,15 +133,15 @@ const makeCheckpointStore = Effect.gen(function* () {
               return yield* new GitCommandError({
                 operation,
                 command: "git write-tree",
-                cwd: normalizedCwd,
+                cwd: input.cwd,
                 detail: "git write-tree returned an empty tree oid.",
               });
             }
-            const message = `t3 checkpoint ref=${checkpointRef}`;
+            const message = `t3 checkpoint ref=${input.checkpointRef}`;
             const commitTreeResult = yield* git.execute({
               operation,
-              cwd: normalizedCwd,
+              cwd: input.cwd,
               args: ["commit-tree", treeOid, "-m", message],
               env: commitEnv,
             });
 @@ -152,15 +150,15 @@ const makeCheckpointStore = Effect.gen(function* () {
               return yield* new GitCommandError({
                 operation,
                 command: "git commit-tree",
-                cwd: normalizedCwd,
+                cwd: input.cwd,
                 detail: "git commit-tree returned an empty commit oid.",
               });
             }
             yield* git.execute({
               operation,
-              cwd: normalizedCwd,
+              cwd: input.cwd,
-              args: ["update-ref", checkpointRef, commitOid],
+              args: ["update-ref", input.checkpointRef, commitOid],
             });
           }),
         (tempDir) => fs.remove(tempDir, { recursive: true }),

apps/server/src/checkpointing/Utils.ts+2-10

 @@ -9,11 +9,6 @@ export function checkpointRefForThreadTurn(threadId: ThreadId, turnCount: number
   );
 }
-function trimToNonEmpty(value: string | null | undefined): string | undefined {
-  const normalized = value?.trim();
-  return normalized && normalized.length > 0 ? normalized : undefined;
-}
 export function resolveThreadWorkspaceCwd(input: {
   readonly thread: {
     readonly projectId: ProjectId;
 @@ -24,13 +19,10 @@ export function resolveThreadWorkspaceCwd(input: {
     readonly workspaceRoot: string;
   }>;
 }): string | undefined {
-  const worktreeCwd = trimToNonEmpty(input.thread.worktreePath);
+  const worktreeCwd = input.thread.worktreePath ?? undefined;
   if (worktreeCwd) {
     return worktreeCwd;
   }
-  const workspaceRoot = input.projects.find(
+  return input.projects.find((project) => project.id === input.thread.projectId)?.workspaceRoot;
-    (project) => project.id === input.thread.projectId,
-  )?.workspaceRoot;
-  return trimToNonEmpty(workspaceRoot);
 }

apps/server/src/codexAppServerManager.ts+2-2

...	@@ -169,8 +169,8 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve	...	@@ -169,8 +169,8 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
169	updatedAt: now,	169	updatedAt: now,
170	};	170	};
171		171
172	const codexBinaryPath = input.codexBinaryPath?.trim() \|\| "codex";	172	const codexBinaryPath = input.codexBinaryPath ?? "codex";
173	const codexHomePath = input.codexHomePath?.trim();	173	const codexHomePath = input.codexHomePath;
174	const child = spawn(codexBinaryPath, ["app-server"], {	174	const child = spawn(codexBinaryPath, ["app-server"], {
175	cwd: resolvedCwd,	175	cwd: resolvedCwd,
176	env: {	176	env: {

apps/server/src/git/Layers/GitService.ts-2

 @@ -71,10 +71,8 @@ const makeGitService = Effect.gen(function* () {
   const commandSpawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const execute: GitServiceShape["execute"] = Effect.fnUntraced(function* (input) {
-    const normalizedCwd = input.cwd.trim();
     const commandInput = {
       ...input,
-      cwd: normalizedCwd,
       args: [...input.args],
     } as const;
     const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;

apps/server/src/keybindings.ts+3-6

 @@ -265,14 +265,11 @@ function parseKeybindingWhenExpression(expression: string): KeybindingWhenNode |
 /** @internal - Exported for testing */
 export function compileResolvedKeybindingRule(rule: KeybindingRule): ResolvedKeybindingRule | null {
-  const key = rule.key.trim();
+  const shortcut = parseKeybindingShortcut(rule.key);
-  if (key.length === 0) return null;
-  const shortcut = parseKeybindingShortcut(key);
   if (!shortcut) return null;
-  const when = rule.when?.trim();
+  if (rule.when !== undefined) {
-  if (when && when.length > 0) {
+    const whenAst = parseKeybindingWhenExpression(rule.when);
-    const whenAst = parseKeybindingWhenExpression(when);
     if (!whenAst) return null;
     return {
       command: rule.command,

apps/server/src/orchestration/Layers/CheckpointReactor.ts+5-12

 @@ -33,13 +33,7 @@ type ReactorInput =
     };
 function toTurnId(value: string | undefined): TurnId | null {
-  const normalized = value?.trim();
+  return value === undefined ? null : TurnId.makeUnsafe(value);
-  return normalized && normalized.length > 0 ? TurnId.makeUnsafe(normalized) : null;
-}
-function trimToNonEmpty(value: string | null | undefined): string | undefined {
-  const normalized = value?.trim();
-  return normalized && normalized.length > 0 ? normalized : undefined;
 }
 function checkpointStatusFromRuntime(status: string | undefined): "ready" | "missing" | "error" {
 @@ -129,18 +123,17 @@ const make = Effect.gen(function* () {
     const readModel = yield* orchestrationEngine.getReadModel();
     const thread = readModel.threads.find((entry) => entry.id === threadId);
     const projectedSessionId = thread?.session?.providerSessionId ?? null;
-    const projectedProviderThreadId = trimToNonEmpty(thread?.session?.providerThreadId);
+    const projectedProviderThreadId = thread?.session?.providerThreadId ?? undefined;
     const sessions = yield* providerService.listSessions();
     const findSessionWithCwd = (
       session: (typeof sessions)[number] | undefined,
     ): Option.Option<{ readonly sessionId: ProviderSessionId; readonly cwd: string }> => {
-      const cwd = session?.cwd?.trim();
+      if (!session?.cwd) {
-      if (!session || !cwd) {
         return Option.none();
       }
-      return Option.some({ sessionId: session.sessionId, cwd });
+      return Option.some({ sessionId: session.sessionId, cwd: session.cwd });
     };
     if (projectedSessionId !== null) {
 @@ -153,7 +146,7 @@ const make = Effect.gen(function* () {
     if (projectedProviderThreadId) {
       const matchedSession = sessions.find(
-        (session) => session.threadId?.trim() === projectedProviderThreadId,
+        (session) => session.threadId === projectedProviderThreadId,
       );
       const fromProviderThread = findSessionWithCwd(matchedSession);
       if (Option.isSome(fromProviderThread)) {

apps/server/src/orchestration/Layers/ProviderCommandReactor.ts+7-10

 @@ -28,7 +28,7 @@ type ProviderIntentEvent = Extract<
   }
 >;
-function trimToNonEmptyOrUndefined(value: string | undefined): string | undefined {
+function toNonEmptyProviderInput(value: string | undefined): string | undefined {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : undefined;
 }
 @@ -43,15 +43,12 @@ function resolveEffectiveThreadCwd(input: {
     readonly workspaceRoot: string;
   }>;
 }): string | undefined {
-  const worktreeCwd = trimToNonEmptyOrUndefined(input.thread.worktreePath ?? undefined);
+  const worktreeCwd = input.thread.worktreePath ?? undefined;
   if (worktreeCwd) {
     return worktreeCwd;
   }
-  const workspaceRoot = input.projects.find(
+  return input.projects.find((project) => project.id === input.thread.projectId)?.workspaceRoot;
-    (project) => project.id === input.thread.projectId,
-  )?.workspaceRoot;
-  return trimToNonEmptyOrUndefined(workspaceRoot);
 }
 function mapProviderSessionStatusToOrchestrationStatus(
 @@ -158,7 +155,7 @@ const make = Effect.gen(function* () {
     const startedSession = yield* providerService.startSession({
       ...(preferredProvider ? { provider: preferredProvider } : {}),
       ...(effectiveCwd ? { cwd: effectiveCwd } : {}),
-      ...(trimToNonEmptyOrUndefined(thread.model) ? { model: thread.model } : {}),
+      ...(thread.model ? { model: thread.model } : {}),
     });
     yield* setThreadSession({
 @@ -193,15 +190,15 @@ const make = Effect.gen(function* () {
       return;
     }
     const sessionId = yield* ensureSessionForThread(input.threadId, input.createdAt);
-    const normalizedInput = trimToNonEmptyOrUndefined(input.messageText);
+    const normalizedInput = toNonEmptyProviderInput(input.messageText);
     const normalizedAttachments = input.attachments ?? [];
     yield* providerService.sendTurn({
       sessionId,
       ...(normalizedInput ? { input: normalizedInput } : {}),
       ...(normalizedAttachments.length > 0 ? { attachments: normalizedAttachments } : {}),
-      ...(trimToNonEmptyOrUndefined(input.model) ? { model: input.model } : {}),
+      ...(input.model !== undefined ? { model: input.model } : {}),
-      ...(trimToNonEmptyOrUndefined(input.effort) ? { effort: input.effort } : {}),
+      ...(input.effort !== undefined ? { effort: input.effort } : {}),
     });
   });

apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts+1-2

...	@@ -21,8 +21,7 @@ const providerCommandId = (event: ProviderRuntimeEvent, tag: string): CommandId	...	@@ -21,8 +21,7 @@ const providerCommandId = (event: ProviderRuntimeEvent, tag: string): CommandId
21	CommandId.makeUnsafe(`provider:${event.eventId}:${tag}:${crypto.randomUUID()}`);	21	CommandId.makeUnsafe(`provider:${event.eventId}:${tag}:${crypto.randomUUID()}`);
22		22
23	function toTurnId(value: string \| undefined): TurnId \| undefined {	23	function toTurnId(value: string \| undefined): TurnId \| undefined {
24	const normalized = value?.trim();	24	return value === undefined ? undefined : TurnId.makeUnsafe(value);
25	return normalized?.length ? TurnId.makeUnsafe(normalized) : undefined;
26	}	25	}
27		26
28	function truncateDetail(value: string, limit = 180): string {	27	function truncateDetail(value: string, limit = 180): string {

apps/server/src/provider/Layers/ProviderService.ts+2-1

 @@ -242,8 +242,9 @@ const makeProviderService = (options?: ProviderServiceLiveOptions) =>
       Effect.gen(function* () {
         const adapter = yield* registry.getByProvider(input.provider);
         const activeSessions = yield* adapter.listSessions();
+        const expectedProviderThreadId = asProviderThreadId(input.threadId);
         const existing = activeSessions.find(
-          (session) => session.threadId?.trim() === input.threadId.trim(),
+          (session) => session.threadId === expectedProviderThreadId,
         );
         if (existing) {
           const existingThreadId = yield* upsertSessionBinding(

apps/server/src/provider/Layers/ProviderSessionDirectory.test.ts+3-3

...	@@ -79,12 +79,12 @@ layer("ProviderSessionDirectoryLive", (it) => {	...	@@ -79,12 +79,12 @@ layer("ProviderSessionDirectoryLive", (it) => {
79	assertFailure(missingProvider, new ProviderSessionNotFoundError({ sessionId: "sess-1" }));	79	assertFailure(missingProvider, new ProviderSessionNotFoundError({ sessionId: "sess-1" }));
80	}));	80	}));
81		81
82	it("fails upsert for empty session id", () =>	82	it("fails upsert when thread id is unavailable", () =>
83	Effect.gen(function* () {	83	Effect.gen(function* () {
84	const directory = yield* ProviderSessionDirectory;	84	const directory = yield* ProviderSessionDirectory;
85	const result = yield* Effect.result(	85	const result = yield* Effect.result(
86	directory.upsert({	86	directory.upsert({
87	sessionId: sessionId(" "),	87	sessionId: sessionId("sess-no-thread"),
88	provider: "codex",	88	provider: "codex",
89	}),	89	}),
90	);	90	);
...	@@ -92,7 +92,7 @@ layer("ProviderSessionDirectoryLive", (it) => {	...	@@ -92,7 +92,7 @@ layer("ProviderSessionDirectoryLive", (it) => {
92	result,	92	result,
93	new ProviderValidationError({	93	new ProviderValidationError({
94	operation: "ProviderSessionDirectory.upsert",	94	operation: "ProviderSessionDirectory.upsert",
95	issue: "sessionId must be a non-empty string.",	95	issue: "threadId must be a non-empty string.",
96	}),	96	}),
97	);	97	);
98	}));	98	}));

apps/server/src/provider/Layers/ProviderSessionDirectory.ts+60-111

...	@@ -1,9 +1,4 @@	...	@@ -1,9 +1,4 @@
1	import {	1	import { ProviderSessionId, type ProviderKind } from "@t3tools/contracts";
2	ProviderSessionId,
3	ProviderThreadId,
4	ThreadId,
5	type ProviderKind,
6	} from "@t3tools/contracts";
7	import { Effect, Layer, Option } from "effect";	2	import { Effect, Layer, Option } from "effect";
8		3
9	import { ProviderSessionRuntimeRepository } from "../../persistence/Services/ProviderSessionRuntime.ts";	4	import { ProviderSessionRuntimeRepository } from "../../persistence/Services/ProviderSessionRuntime.ts";
...	@@ -27,31 +22,6 @@ function toPersistenceError(operation: string) {	...	@@ -27,31 +22,6 @@ function toPersistenceError(operation: string) {
27	});	22	});
28	}	23	}
29		24
30	function normalizeBinding(binding: ProviderSessionBinding): ProviderSessionBinding {
31	const sessionId = binding.sessionId.trim();
32	const threadId = binding.threadId?.trim();
33	const adapterKey = binding.adapterKey?.trim();
34	const providerThreadId =
35	binding.providerThreadId === null ? null : binding.providerThreadId?.trim();
36
37	return {
38	sessionId: ProviderSessionId.makeUnsafe(sessionId),
39	provider: binding.provider,
40	...(adapterKey !== undefined && adapterKey.length > 0 ? { adapterKey } : {}),
41	...(threadId !== undefined && threadId.length > 0
42	? { threadId: ThreadId.makeUnsafe(threadId) }
43	: {}),
44	...(providerThreadId === null
45	? { providerThreadId: null }
46	: providerThreadId !== undefined && providerThreadId.length > 0
47	? { providerThreadId: ProviderThreadId.makeUnsafe(providerThreadId) }
48	: {}),
49	...(binding.status !== undefined ? { status: binding.status } : {}),
50	...(binding.resumeCursor !== undefined ? { resumeCursor: binding.resumeCursor } : {}),
51	...(binding.runtimePayload !== undefined ? { runtimePayload: binding.runtimePayload } : {}),
52	};
53	}
54
55	function decodeProviderKind(	25	function decodeProviderKind(
56	providerName: string,	26	providerName: string,
57	operation: string,	27	operation: string,
...	@@ -90,54 +60,6 @@ function mergeRuntimePayload(	...	@@ -90,54 +60,6 @@ function mergeRuntimePayload(
90	const makeProviderSessionDirectory = Effect.gen(function* () {	60	const makeProviderSessionDirectory = Effect.gen(function* () {
91	const repository = yield* ProviderSessionRuntimeRepository;	61	const repository = yield* ProviderSessionRuntimeRepository;
92		62
93	const persistUpsert = (binding: ProviderSessionBinding) =>
94	Effect.gen(function* () {
95	const existing = yield* repository
96	.getBySessionId({
97	providerSessionId: binding.sessionId,
98	})
99	.pipe(
100	Effect.mapError(toPersistenceError("ProviderSessionDirectory.upsert:getBySessionId")),
101	);
102
103	const existingRuntime = Option.getOrUndefined(existing);
104	const resolvedThreadId = binding.threadId ?? existingRuntime?.threadId;
105	if (!resolvedThreadId) {
106	return yield* new ProviderValidationError({
107	operation: "ProviderSessionDirectory.upsert",
108	issue: "threadId must be a non-empty string.",
109	});
110	}
111
112	const now = new Date().toISOString();
113	yield* repository
114	.upsert({
115	providerSessionId: binding.sessionId,
116	threadId: resolvedThreadId,
117	providerName: binding.provider,
118	adapterKey: binding.adapterKey ?? existingRuntime?.adapterKey ?? binding.provider,
119	providerThreadId: binding.providerThreadId ?? existingRuntime?.providerThreadId ?? null,
120	status: binding.status ?? existingRuntime?.status ?? "running",
121	lastSeenAt: now,
122	resumeCursor:
123	binding.resumeCursor !== undefined
124	? binding.resumeCursor
125	: (existingRuntime?.resumeCursor ?? null),
126	runtimePayload: mergeRuntimePayload(
127	existingRuntime?.runtimePayload ?? null,
128	binding.runtimePayload,
129	),
130	})
131	.pipe(Effect.mapError(toPersistenceError("ProviderSessionDirectory.upsert:upsert")));
132	});
133
134	const persistDelete = (sessionId: ProviderSessionId) =>
135	repository
136	.deleteBySessionId({ providerSessionId: sessionId })
137	.pipe(
138	Effect.mapError(toPersistenceError("ProviderSessionDirectory.remove:deleteBySessionId")),
139	);
140
141	const getBinding = (sessionId: ProviderSessionId) =>	63	const getBinding = (sessionId: ProviderSessionId) =>
142	repository.getBySessionId({ providerSessionId: sessionId }).pipe(	64	repository.getBySessionId({ providerSessionId: sessionId }).pipe(
143	Effect.mapError(toPersistenceError("ProviderSessionDirectory.getBinding:getBySessionId")),	65	Effect.mapError(toPersistenceError("ProviderSessionDirectory.getBinding:getBySessionId")),
...	@@ -158,38 +80,43 @@ const makeProviderSessionDirectory = Effect.gen(function* () {	...	@@ -158,38 +80,43 @@ const makeProviderSessionDirectory = Effect.gen(function* () {
158	),	80	),
159	);	81	);
160		82
161	const listBindings = () =>	83	const upsert: ProviderSessionDirectoryShape["upsert"] = Effect.fn(function* (binding) {
162	repository.list().pipe(	84	const existing = yield* repository
163	Effect.mapError(toPersistenceError("ProviderSessionDirectory.listSessionIds:list")),	85	.getBySessionId({
164	Effect.flatMap((rows) =>	86	providerSessionId: binding.sessionId,
165	Effect.forEach(	87	})
166	rows,	88	.pipe(Effect.mapError(toPersistenceError("ProviderSessionDirectory.upsert:getBySessionId")));
167	(row) =>	89
168	decodeProviderKind(row.providerName, "ProviderSessionDirectory.listSessionIds").pipe(	90	const existingRuntime = Option.getOrUndefined(existing);
169	Effect.map((provider) => ({	91	const resolvedThreadId = binding.threadId ?? existingRuntime?.threadId;
170	sessionId: row.providerSessionId,	92	if (!resolvedThreadId) {
171	provider,	93	return yield* new ProviderValidationError({
172	threadId: row.threadId,	94	operation: "ProviderSessionDirectory.upsert",
173	})),	95	issue: "threadId must be a non-empty string.",
174	),	96	});
175	{ concurrency: "unbounded" },
176	),
177	),
178	);
179
180	const upsert: ProviderSessionDirectoryShape["upsert"] = (binding) => {
181	const normalized = normalizeBinding(binding);
182	if (normalized.sessionId.length === 0) {
183	return Effect.fail(
184	new ProviderValidationError({
185	operation: "ProviderSessionDirectory.upsert",
186	issue: "sessionId must be a non-empty string.",
187	}),
188	);
189	}	97	}
190		98
191	return persistUpsert(normalized);	99	const now = new Date().toISOString();
192	};	100	yield* repository
		101	.upsert({
		102	providerSessionId: binding.sessionId,
		103	threadId: resolvedThreadId,
		104	providerName: binding.provider,
		105	adapterKey: binding.adapterKey ?? existingRuntime?.adapterKey ?? binding.provider,
		106	providerThreadId: binding.providerThreadId ?? existingRuntime?.providerThreadId ?? null,
		107	status: binding.status ?? existingRuntime?.status ?? "running",
		108	lastSeenAt: now,
		109	resumeCursor:
		110	binding.resumeCursor !== undefined
		111	? binding.resumeCursor
		112	: (existingRuntime?.resumeCursor ?? null),
		113	runtimePayload: mergeRuntimePayload(
		114	existingRuntime?.runtimePayload ?? null,
		115	binding.runtimePayload,
		116	),
		117	})
		118	.pipe(Effect.mapError(toPersistenceError("ProviderSessionDirectory.upsert:upsert")));
		119	});
193		120
194	const getProvider: ProviderSessionDirectoryShape["getProvider"] = (sessionId) =>	121	const getProvider: ProviderSessionDirectoryShape["getProvider"] = (sessionId) =>
195	getBinding(sessionId).pipe(	122	getBinding(sessionId).pipe(
...	@@ -211,10 +138,32 @@ const makeProviderSessionDirectory = Effect.gen(function* () {	...	@@ -211,10 +138,32 @@ const makeProviderSessionDirectory = Effect.gen(function* () {
211	),	138	),
212	);	139	);
213		140
214	const remove: ProviderSessionDirectoryShape["remove"] = (sessionId) => persistDelete(sessionId);	141	const remove: ProviderSessionDirectoryShape["remove"] = (sessionId) =>
		142	repository
		143	.deleteBySessionId({ providerSessionId: sessionId })
		144	.pipe(
		145	Effect.mapError(toPersistenceError("ProviderSessionDirectory.remove:deleteBySessionId")),
		146	);
215		147
216	const listSessionIds: ProviderSessionDirectoryShape["listSessionIds"] = () =>	148	const listSessionIds: ProviderSessionDirectoryShape["listSessionIds"] = () =>
217	listBindings().pipe(Effect.map((bindings) => bindings.map((binding) => binding.sessionId)));	149	repository.list().pipe(
		150	Effect.mapError(toPersistenceError("ProviderSessionDirectory.listSessionIds:list")),
		151	Effect.flatMap((rows) =>
		152	Effect.forEach(
		153	rows,
		154	(row) =>
		155	decodeProviderKind(row.providerName, "ProviderSessionDirectory.listSessionIds").pipe(
		156	Effect.map((provider) => ({
		157	sessionId: row.providerSessionId,
		158	provider,
		159	threadId: row.threadId,
		160	})),
		161	),
		162	{ concurrency: "unbounded" },
		163	),
		164	),
		165	Effect.map((bindings) => bindings.map((binding) => binding.sessionId)),
		166	);
218		167
219	return {	168	return {
220	upsert,	169	upsert,

packages/contracts/src/baseSchemas.ts created+42

...	@@ -0,0 +1,42 @@
1	import { Schema } from "effect";
2
3	export const TrimmedString = Schema.Trim;
4	export const TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
5
6	export const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
7	export const PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
8
9	export const IsoDateTime = Schema.String;
10	export type IsoDateTime = typeof IsoDateTime.Type;
11
12	/**
13	* Construct a branded identifier. Enforces non-empty trimmed strings
14	*/
15	const makeEntityId = <Brand extends string>(brand: Brand) =>
16	TrimmedNonEmptyString.pipe(Schema.brand(brand));
17
18	export const ThreadId = makeEntityId("ThreadId");
19	export type ThreadId = typeof ThreadId.Type;
20	export const ProjectId = makeEntityId("ProjectId");
21	export type ProjectId = typeof ProjectId.Type;
22	export const CommandId = makeEntityId("CommandId");
23	export type CommandId = typeof CommandId.Type;
24	export const EventId = makeEntityId("EventId");
25	export type EventId = typeof EventId.Type;
26	export const MessageId = makeEntityId("MessageId");
27	export type MessageId = typeof MessageId.Type;
28	export const TurnId = makeEntityId("TurnId");
29	export type TurnId = typeof TurnId.Type;
30
31	export const ProviderSessionId = makeEntityId("ProviderSessionId");
32	export type ProviderSessionId = typeof ProviderSessionId.Type;
33	export const ProviderThreadId = makeEntityId("ProviderThreadId");
34	export type ProviderThreadId = typeof ProviderThreadId.Type;
35	export const ProviderTurnId = makeEntityId("ProviderTurnId");
36	export type ProviderTurnId = typeof ProviderTurnId.Type;
37	export const ProviderItemId = makeEntityId("ProviderItemId");
38	export type ProviderItemId = typeof ProviderItemId.Type;
39	export const ApprovalRequestId = makeEntityId("ApprovalRequestId");
40	export type ApprovalRequestId = typeof ApprovalRequestId.Type;
41	export const CheckpointRef = makeEntityId("CheckpointRef");
42	export type CheckpointRef = typeof CheckpointRef.Type;

packages/contracts/src/editor.ts+2-1

...	@@ -1,4 +1,5 @@	...	@@ -1,4 +1,5 @@
1	import { Schema } from "effect";	1	import { Schema } from "effect";
		2	import { TrimmedNonEmptyString } from "./baseSchemas";
2		3
3	export const EDITORS = [	4	export const EDITORS = [
4	{ id: "cursor", label: "Cursor", command: "cursor" },	5	{ id: "cursor", label: "Cursor", command: "cursor" },
...	@@ -9,7 +10,7 @@ export const EditorId = Schema.Literals(EDITORS.map((e) => e.id));	...	@@ -9,7 +10,7 @@ export const EditorId = Schema.Literals(EDITORS.map((e) => e.id));
9	export type EditorId = typeof EditorId.Type;	10	export type EditorId = typeof EditorId.Type;
10		11
11	export const OpenInEditorInput = Schema.Struct({	12	export const OpenInEditorInput = Schema.Struct({
12	cwd: Schema.String,	13	cwd: TrimmedNonEmptyString,
13	editor: EditorId,	14	editor: EditorId,
14	});	15	});
15	export type OpenInEditorInput = typeof OpenInEditorInput.Type;	16	export type OpenInEditorInput = typeof OpenInEditorInput.Type;

packages/contracts/src/git.ts+49-46

 @@ -1,6 +1,7 @@
 import { Schema } from "effect";
+import { NonNegativeInt, PositiveInt, TrimmedNonEmptyString } from "./baseSchemas";
-const TrimmedNonEmptyString = Schema.Trimmed.check(Schema.isNonEmpty());
+const TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
 // Domain Types
 @@ -19,101 +20,103 @@ export const GitPrStepStatus = Schema.Literals([
 ]);
 export const GitBranch = Schema.Struct({
-  name: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyStringSchema,
   current: Schema.Boolean,
   isDefault: Schema.Boolean,
-  worktreePath: TrimmedNonEmptyString.pipe(Schema.NullOr),
+  worktreePath: TrimmedNonEmptyStringSchema.pipe(Schema.NullOr),
 });
 export type GitBranch = typeof GitBranch.Type;
 export const GitWorktree = Schema.Struct({
-  path: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyStringSchema,
-  branch: TrimmedNonEmptyString,
+  branch: TrimmedNonEmptyStringSchema,
 });
 export type GitWorktree = typeof GitWorktree.Type;
 // RPC Inputs
 export const GitStatusInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
 });
 export type GitStatusInput = typeof GitStatusInput.Type;
 export const GitPullInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
 });
 export type GitPullInput = typeof GitPullInput.Type;
 export const GitRunStackedActionInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
   action: GitStackedAction,
-  commitMessage: Schema.optional(TrimmedNonEmptyString.check(Schema.isMaxLength(10_000))),
+  commitMessage: Schema.optional(TrimmedNonEmptyStringSchema.check(Schema.isMaxLength(10_000))),
 });
 export type GitRunStackedActionInput = typeof GitRunStackedActionInput.Type;
 export const GitListBranchesInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
 });
 export type GitListBranchesInput = typeof GitListBranchesInput.Type;
 export const GitCreateWorktreeInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
-  branch: TrimmedNonEmptyString,
+  branch: TrimmedNonEmptyStringSchema,
-  newBranch: TrimmedNonEmptyString,
+  newBranch: TrimmedNonEmptyStringSchema,
-  path: TrimmedNonEmptyString.pipe(Schema.NullOr),
+  path: Schema.NullOr(TrimmedNonEmptyStringSchema),
 });
 export type GitCreateWorktreeInput = typeof GitCreateWorktreeInput.Type;
 export const GitRemoveWorktreeInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
-  path: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyStringSchema,
   force: Schema.optional(Schema.Boolean),
 });
 export type GitRemoveWorktreeInput = typeof GitRemoveWorktreeInput.Type;
 export const GitCreateBranchInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
-  branch: TrimmedNonEmptyString,
+  branch: TrimmedNonEmptyStringSchema,
 });
 export type GitCreateBranchInput = typeof GitCreateBranchInput.Type;
 export const GitCheckoutInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
-  branch: TrimmedNonEmptyString,
+  branch: TrimmedNonEmptyStringSchema,
 });
 export type GitCheckoutInput = typeof GitCheckoutInput.Type;
 export const GitInitInput = Schema.Struct({
-  cwd: TrimmedNonEmptyString,
+  cwd: TrimmedNonEmptyStringSchema,
 });
 export type GitInitInput = typeof GitInitInput.Type;
 // RPC Results
 export const GitStatusResult = Schema.Struct({
-  branch: TrimmedNonEmptyString.pipe(Schema.NullOr),
+  branch: TrimmedNonEmptyStringSchema.pipe(Schema.NullOr),
   hasWorkingTreeChanges: Schema.Boolean,
   workingTree: Schema.Struct({
     files: Schema.Array(
       Schema.Struct({
-        path: TrimmedNonEmptyString,
+        path: TrimmedNonEmptyStringSchema,
-        insertions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+        insertions: NonNegativeInt,
-        deletions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+        deletions: NonNegativeInt,
       }),
     ),
-    insertions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    insertions: NonNegativeInt,
-    deletions: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    deletions: NonNegativeInt,
   }),
   hasUpstream: Schema.Boolean,
-  aheadCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  aheadCount: NonNegativeInt,
-  behindCount: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  behindCount: NonNegativeInt,
-  openPr: Schema.Struct({
+  openPr: Schema.NullOr(
-    number: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+    Schema.Struct({
-    title: TrimmedNonEmptyString,
+      number: PositiveInt,
-    url: Schema.String,
+      title: TrimmedNonEmptyStringSchema,
-    baseBranch: TrimmedNonEmptyString,
+      url: Schema.String,
-    headBranch: TrimmedNonEmptyString,
+      baseBranch: TrimmedNonEmptyStringSchema,
-  }).pipe(Schema.NullOr),
+      headBranch: TrimmedNonEmptyStringSchema,
+    }),
+  ),
 });
 export type GitStatusResult = typeof GitStatusResult.Type;
 @@ -132,29 +135,29 @@ export const GitRunStackedActionResult = Schema.Struct({
   action: GitStackedAction,
   commit: Schema.Struct({
     status: GitCommitStepStatus,
-    commitSha: Schema.optional(TrimmedNonEmptyString),
+    commitSha: Schema.optional(TrimmedNonEmptyStringSchema),
-    subject: Schema.optional(TrimmedNonEmptyString),
+    subject: Schema.optional(TrimmedNonEmptyStringSchema),
   }),
   push: Schema.Struct({
     status: GitPushStepStatus,
-    branch: Schema.optional(TrimmedNonEmptyString),
+    branch: Schema.optional(TrimmedNonEmptyStringSchema),
-    upstreamBranch: Schema.optional(TrimmedNonEmptyString),
+    upstreamBranch: Schema.optional(TrimmedNonEmptyStringSchema),
     setUpstream: Schema.optional(Schema.Boolean),
   }),
   pr: Schema.Struct({
     status: GitPrStepStatus,
     url: Schema.optional(Schema.String),
-    number: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+    number: Schema.optional(PositiveInt),
-    baseBranch: Schema.optional(TrimmedNonEmptyString),
+    baseBranch: Schema.optional(TrimmedNonEmptyStringSchema),
-    headBranch: Schema.optional(TrimmedNonEmptyString),
+    headBranch: Schema.optional(TrimmedNonEmptyStringSchema),
-    title: Schema.optional(TrimmedNonEmptyString),
+    title: Schema.optional(TrimmedNonEmptyStringSchema),
   }),
 });
 export type GitRunStackedActionResult = typeof GitRunStackedActionResult.Type;
 export const GitPullResult = Schema.Struct({
   status: Schema.Literals(["pulled", "skipped_up_to_date"]),
-  branch: TrimmedNonEmptyString,
+  branch: TrimmedNonEmptyStringSchema,
-  upstreamBranch: TrimmedNonEmptyString.pipe(Schema.NullOr),
+  upstreamBranch: TrimmedNonEmptyStringSchema.pipe(Schema.NullOr),
 });
 export type GitPullResult = typeof GitPullResult.Type;

packages/contracts/src/index.ts+1

...	@@ -1,3 +1,4 @@	...	@@ -1,3 +1,4 @@
		1	export * from "./baseSchemas";
1	export * from "./ipc";	2	export * from "./ipc";
2	export * from "./terminal";	3	export * from "./terminal";
3	export * from "./provider";	4	export * from "./provider";

packages/contracts/src/keybindings.ts+3-2

 @@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import { TrimmedString } from "./baseSchemas";
 export const MAX_KEYBINDING_COMMAND_LENGTH = 96;
 export const MAX_KEYBINDING_VALUE_LENGTH = 64;
 @@ -33,13 +34,13 @@ export const KeybindingCommand = Schema.Union([
 ]);
 export type KeybindingCommand = typeof KeybindingCommand.Type;
-export const KeybindingValue = Schema.Trim.check(
+export const KeybindingValue = TrimmedString.check(
   Schema.isMinLength(1),
   Schema.isMaxLength(MAX_KEYBINDING_VALUE_LENGTH),
 );
 export type KeybindingValue = typeof KeybindingValue.Type;
-export const KeybindingWhen = Schema.Trim.check(
+export const KeybindingWhen = TrimmedString.check(
   Schema.isMinLength(1),
   Schema.isMaxLength(MAX_KEYBINDING_WHEN_LENGTH),
 );

packages/contracts/src/orchestration.test.ts+41-1

...	@@ -1,10 +1,15 @@	...	@@ -1,10 +1,15 @@
1	import { assert, it } from "@effect/vitest";	1	import { assert, it } from "@effect/vitest";
2	import { Effect, Schema } from "effect";	2	import { Effect, Schema } from "effect";
3		3
4	import { OrchestrationGetTurnDiffInput, ThreadTurnDiff } from "./orchestration";	4	import {
		5	OrchestrationGetTurnDiffInput,
		6	ProjectCreateCommand,
		7	ThreadTurnDiff,
		8	} from "./orchestration";
5		9
6	const decodeTurnDiffInput = Schema.decodeUnknownEffect(OrchestrationGetTurnDiffInput);	10	const decodeTurnDiffInput = Schema.decodeUnknownEffect(OrchestrationGetTurnDiffInput);
7	const decodeThreadTurnDiff = Schema.decodeUnknownEffect(ThreadTurnDiff);	11	const decodeThreadTurnDiff = Schema.decodeUnknownEffect(ThreadTurnDiff);
		12	const decodeProjectCreateCommand = Schema.decodeUnknownEffect(ProjectCreateCommand);
8		13
9	it.effect("parses turn diff input when fromTurnCount <= toTurnCount", () =>	14	it.effect("parses turn diff input when fromTurnCount <= toTurnCount", () =>
10	Effect.gen(function* () {	15	Effect.gen(function* () {
...	@@ -44,3 +49,38 @@ it.effect("rejects thread turn diff when fromTurnCount > toTurnCount", () =>	...	@@ -44,3 +49,38 @@ it.effect("rejects thread turn diff when fromTurnCount > toTurnCount", () =>
44	assert.strictEqual(result._tag, "Failure");	49	assert.strictEqual(result._tag, "Failure");
45	}),	50	}),
46	);	51	);
		52
		53	it.effect("trims branded ids and command string fields at decode boundaries", () =>
		54	Effect.gen(function* () {
		55	const parsed = yield* decodeProjectCreateCommand({
		56	type: "project.create",
		57	commandId: " cmd-1 ",
		58	projectId: " project-1 ",
		59	title: " Project Title ",
		60	workspaceRoot: " /tmp/workspace ",
		61	defaultModel: " gpt-5.2 ",
		62	createdAt: "2026-01-01T00:00:00.000Z",
		63	});
		64	assert.strictEqual(parsed.commandId, "cmd-1");
		65	assert.strictEqual(parsed.projectId, "project-1");
		66	assert.strictEqual(parsed.title, "Project Title");
		67	assert.strictEqual(parsed.workspaceRoot, "/tmp/workspace");
		68	assert.strictEqual(parsed.defaultModel, "gpt-5.2");
		69	}),
		70	);
		71
		72	it.effect("rejects command fields that become empty after trim", () =>
		73	Effect.gen(function* () {
		74	const result = yield* Effect.exit(
		75	decodeProjectCreateCommand({
		76	type: "project.create",
		77	commandId: "cmd-1",
		78	projectId: "project-1",
		79	title: " ",
		80	workspaceRoot: "/tmp/workspace",
		81	createdAt: "2026-01-01T00:00:00.000Z",
		82	}),
		83	);
		84	assert.strictEqual(result._tag, "Failure");
		85	}),
		86	);

packages/contracts/src/orchestration.ts+69-90

 @@ -1,4 +1,21 @@
 import { Option, Schema, SchemaIssue, Struct } from "effect";
+import {
+  ApprovalRequestId,
+  CheckpointRef,
+  CommandId,
+  EventId,
+  IsoDateTime,
+  MessageId,
+  NonNegativeInt,
+  ProjectId,
+  ProviderItemId,
+  ProviderSessionId,
+  ProviderThreadId,
+  ProviderTurnId,
+  ThreadId,
+  TrimmedNonEmptyString,
+  TurnId,
+} from "./baseSchemas";
 export const ORCHESTRATION_WS_METHODS = {
   getSnapshot: "orchestration.getSnapshot",
 @@ -12,35 +29,6 @@ export const ORCHESTRATION_WS_CHANNELS = {
   domainEvent: "orchestration.domainEvent",
 } as const;
-export const IsoDateTime = Schema.String;
-export type IsoDateTime = typeof IsoDateTime.Type;
-export const ThreadId = Schema.String.pipe(Schema.brand("ThreadId"));
-export type ThreadId = typeof ThreadId.Type;
-export const ProjectId = Schema.String.pipe(Schema.brand("ProjectId"));
-export type ProjectId = typeof ProjectId.Type;
-export const CommandId = Schema.String.pipe(Schema.brand("CommandId"));
-export type CommandId = typeof CommandId.Type;
-export const EventId = Schema.String.pipe(Schema.brand("EventId"));
-export type EventId = typeof EventId.Type;
-export const MessageId = Schema.String.pipe(Schema.brand("MessageId"));
-export type MessageId = typeof MessageId.Type;
-export const TurnId = Schema.String.pipe(Schema.brand("TurnId"));
-export type TurnId = typeof TurnId.Type;
-export const ProviderSessionId = Schema.String.pipe(Schema.brand("ProviderSessionId"));
-export type ProviderSessionId = typeof ProviderSessionId.Type;
-export const ProviderThreadId = Schema.String.pipe(Schema.brand("ProviderThreadId"));
-export type ProviderThreadId = typeof ProviderThreadId.Type;
-export const ProviderTurnId = Schema.String.pipe(Schema.brand("ProviderTurnId"));
-export type ProviderTurnId = typeof ProviderTurnId.Type;
-export const ProviderItemId = Schema.String.pipe(Schema.brand("ProviderItemId"));
-export type ProviderItemId = typeof ProviderItemId.Type;
-export const ApprovalRequestId = Schema.String.pipe(Schema.brand("ApprovalRequestId"));
-export type ApprovalRequestId = typeof ApprovalRequestId.Type;
-export const CheckpointRef = Schema.String.pipe(Schema.brand("CheckpointRef"));
-export type CheckpointRef = typeof CheckpointRef.Type;
 export const ProviderKind = Schema.Literals(["codex", "claudeCode"]);
 export type ProviderKind = typeof ProviderKind.Type;
 export const ProviderApprovalPolicy = Schema.Literals([
 @@ -75,21 +63,12 @@ export const PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS = 14_000_000;
 export const CorrelationId = CommandId;
 export type CorrelationId = typeof CorrelationId.Type;
-export const NonNegativeInt = Schema.Number.check(Schema.isInt()).check(
-  Schema.isGreaterThanOrEqualTo(0),
-);
-const TrimmedNonEmptyStringSchema = Schema.Trimmed.check(Schema.isNonEmpty());
 export const ChatImageAttachment = Schema.Struct({
   type: Schema.Literal("image"),
-  name: TrimmedNonEmptyStringSchema.check(Schema.isMaxLength(255)),
+  name: TrimmedNonEmptyString.check(Schema.isMaxLength(255)),
-  mimeType: TrimmedNonEmptyStringSchema.check(
+  mimeType: TrimmedNonEmptyString.check(Schema.isMaxLength(100), Schema.isPattern(/^image\//i)),
-    Schema.isMaxLength(100),
-    Schema.isPattern(/^image\//i),
-  ),
   sizeBytes: NonNegativeInt.check(Schema.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
-  dataUrl: TrimmedNonEmptyStringSchema.check(
+  dataUrl: TrimmedNonEmptyString.check(
     Schema.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS),
   ),
 });
 @@ -109,9 +88,9 @@ export const ProjectScriptIcon = Schema.Literals([
 export type ProjectScriptIcon = typeof ProjectScriptIcon.Type;
 export const ProjectScript = Schema.Struct({
-  id: Schema.String,
+  id: TrimmedNonEmptyString,
-  name: Schema.String,
+  name: TrimmedNonEmptyString,
-  command: Schema.String,
+  command: TrimmedNonEmptyString,
   icon: ProjectScriptIcon,
   runOnWorktreeCreate: Schema.Boolean,
 });
 @@ -119,9 +98,9 @@ export type ProjectScript = typeof ProjectScript.Type;
 export const OrchestrationProject = Schema.Struct({
   id: ProjectId,
-  title: Schema.String,
+  title: TrimmedNonEmptyString,
-  workspaceRoot: Schema.String,
+  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema.NullOr(Schema.String),
+  defaultModel: Schema.NullOr(TrimmedNonEmptyString),
   scripts: Schema.Array(ProjectScript),
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime,
 @@ -158,18 +137,18 @@ export type OrchestrationSessionStatus = typeof OrchestrationSessionStatus.Type;
 export const OrchestrationSession = Schema.Struct({
   threadId: ThreadId,
   status: OrchestrationSessionStatus,
-  providerName: Schema.NullOr(Schema.String),
+  providerName: Schema.NullOr(TrimmedNonEmptyString),
   providerSessionId: Schema.NullOr(ProviderSessionId),
   providerThreadId: Schema.NullOr(ProviderThreadId),
   activeTurnId: Schema.NullOr(TurnId),
-  lastError: Schema.NullOr(Schema.String),
+  lastError: Schema.NullOr(TrimmedNonEmptyString),
   updatedAt: IsoDateTime,
 });
 export type OrchestrationSession = typeof OrchestrationSession.Type;
 export const OrchestrationCheckpointFile = Schema.Struct({
-  path: Schema.String,
+  path: TrimmedNonEmptyString,
-  kind: Schema.String,
+  kind: TrimmedNonEmptyString,
   additions: NonNegativeInt,
   deletions: NonNegativeInt,
 });
 @@ -200,8 +179,8 @@ export type OrchestrationThreadActivityTone = typeof OrchestrationThreadActivity
 export const OrchestrationThreadActivity = Schema.Struct({
   id: EventId,
   tone: OrchestrationThreadActivityTone,
-  kind: Schema.String,
+  kind: TrimmedNonEmptyString,
-  summary: Schema.String,
+  summary: TrimmedNonEmptyString,
   payload: Schema.Unknown,
   turnId: Schema.NullOr(TurnId),
   createdAt: IsoDateTime,
 @@ -211,10 +190,10 @@ export type OrchestrationThreadActivity = typeof OrchestrationThreadActivity.Typ
 export const OrchestrationThread = Schema.Struct({
   id: ThreadId,
   projectId: ProjectId,
-  title: Schema.String,
+  title: TrimmedNonEmptyString,
-  model: Schema.String,
+  model: TrimmedNonEmptyString,
-  branch: Schema.NullOr(Schema.String),
+  branch: Schema.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema.NullOr(Schema.String),
+  worktreePath: Schema.NullOr(TrimmedNonEmptyString),
   latestTurnId: Schema.NullOr(TurnId),
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime,
 @@ -238,9 +217,9 @@ export const ProjectCreateCommand = Schema.Struct({
   type: Schema.Literal("project.create"),
   commandId: CommandId,
   projectId: ProjectId,
-  title: Schema.String,
+  title: TrimmedNonEmptyString,
-  workspaceRoot: Schema.String,
+  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema.optional(Schema.String),
+  defaultModel: Schema.optional(TrimmedNonEmptyString),
   createdAt: IsoDateTime,
 });
 @@ -248,9 +227,9 @@ export const ProjectMetaUpdateCommand = Schema.Struct({
   type: Schema.Literal("project.meta.update"),
   commandId: CommandId,
   projectId: ProjectId,
-  title: Schema.optional(Schema.String),
+  title: Schema.optional(TrimmedNonEmptyString),
-  workspaceRoot: Schema.optional(Schema.String),
+  workspaceRoot: Schema.optional(TrimmedNonEmptyString),
-  defaultModel: Schema.optional(Schema.String),
+  defaultModel: Schema.optional(TrimmedNonEmptyString),
   scripts: Schema.optional(Schema.Array(ProjectScript)),
 });
 @@ -265,10 +244,10 @@ export const ThreadCreateCommand = Schema.Struct({
   commandId: CommandId,
   threadId: ThreadId,
   projectId: ProjectId,
-  title: Schema.String,
+  title: TrimmedNonEmptyString,
-  model: Schema.String,
+  model: TrimmedNonEmptyString,
-  branch: Schema.NullOr(Schema.String),
+  branch: Schema.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema.NullOr(Schema.String),
+  worktreePath: Schema.NullOr(TrimmedNonEmptyString),
   createdAt: IsoDateTime,
 });
 @@ -282,10 +261,10 @@ export const ThreadMetaUpdateCommand = Schema.Struct({
   type: Schema.Literal("thread.meta.update"),
   commandId: CommandId,
   threadId: ThreadId,
-  title: Schema.optional(Schema.String),
+  title: Schema.optional(TrimmedNonEmptyString),
-  model: Schema.optional(Schema.String),
+  model: Schema.optional(TrimmedNonEmptyString),
-  branch: Schema.optional(Schema.NullOr(Schema.String)),
+  branch: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
-  worktreePath: Schema.optional(Schema.NullOr(Schema.String)),
+  worktreePath: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
 });
 export const ThreadTurnStartCommand = Schema.Struct({
 @@ -298,8 +277,8 @@ export const ThreadTurnStartCommand = Schema.Struct({
     text: Schema.String,
     attachments: Schema.Array(ChatAttachment),
   }),
-  model: Schema.optional(Schema.String),
+  model: Schema.optional(TrimmedNonEmptyString),
-  effort: Schema.optional(Schema.String),
+  effort: Schema.optional(TrimmedNonEmptyString),
   createdAt: IsoDateTime,
 });
 @@ -449,9 +428,9 @@ export const OrchestrationActorKind = Schema.Literals(["client", "server", "prov
 export const ProjectCreatedPayload = Schema.Struct({
   projectId: ProjectId,
-  title: Schema.String,
+  title: TrimmedNonEmptyString,
-  workspaceRoot: Schema.String,
+  workspaceRoot: TrimmedNonEmptyString,
-  defaultModel: Schema.NullOr(Schema.String),
+  defaultModel: Schema.NullOr(TrimmedNonEmptyString),
   scripts: Schema.Array(ProjectScript),
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime,
 @@ -459,9 +438,9 @@ export const ProjectCreatedPayload = Schema.Struct({
 export const ProjectMetaUpdatedPayload = Schema.Struct({
   projectId: ProjectId,
-  title: Schema.optional(Schema.String),
+  title: Schema.optional(TrimmedNonEmptyString),
-  workspaceRoot: Schema.optional(Schema.String),
+  workspaceRoot: Schema.optional(TrimmedNonEmptyString),
-  defaultModel: Schema.optional(Schema.NullOr(Schema.String)),
+  defaultModel: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
   scripts: Schema.optional(Schema.Array(ProjectScript)),
   updatedAt: IsoDateTime,
 });
 @@ -474,10 +453,10 @@ export const ProjectDeletedPayload = Schema.Struct({
 export const ThreadCreatedPayload = Schema.Struct({
   threadId: ThreadId,
   projectId: ProjectId,
-  title: Schema.String,
+  title: TrimmedNonEmptyString,
-  model: Schema.String,
+  model: TrimmedNonEmptyString,
-  branch: Schema.NullOr(Schema.String),
+  branch: Schema.NullOr(TrimmedNonEmptyString),
-  worktreePath: Schema.NullOr(Schema.String),
+  worktreePath: Schema.NullOr(TrimmedNonEmptyString),
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime,
 });
 @@ -489,10 +468,10 @@ export const ThreadDeletedPayload = Schema.Struct({
 export const ThreadMetaUpdatedPayload = Schema.Struct({
   threadId: ThreadId,
-  title: Schema.optional(Schema.String),
+  title: Schema.optional(TrimmedNonEmptyString),
-  model: Schema.optional(Schema.String),
+  model: Schema.optional(TrimmedNonEmptyString),
-  branch: Schema.optional(Schema.NullOr(Schema.String)),
+  branch: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
-  worktreePath: Schema.optional(Schema.NullOr(Schema.String)),
+  worktreePath: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
   updatedAt: IsoDateTime,
 });
 @@ -511,8 +490,8 @@ export const ThreadMessageSentPayload = Schema.Struct({
 export const ThreadTurnStartRequestedPayload = Schema.Struct({
   threadId: ThreadId,
   messageId: MessageId,
-  model: Schema.optional(Schema.String),
+  model: Schema.optional(TrimmedNonEmptyString),
-  effort: Schema.optional(Schema.String),
+  effort: Schema.optional(TrimmedNonEmptyString),
   createdAt: IsoDateTime,
 });
 @@ -571,7 +550,7 @@ export const OrchestrationEventMetadata = Schema.Struct({
   providerThreadId: Schema.optional(ProviderThreadId),
   providerTurnId: Schema.optional(ProviderTurnId),
   providerItemId: Schema.optional(ProviderItemId),
-  adapterKey: Schema.optional(Schema.String),
+  adapterKey: Schema.optional(TrimmedNonEmptyString),
   requestId: Schema.optional(ApprovalRequestId),
   ingestedAt: Schema.optional(IsoDateTime),
 });

packages/contracts/src/project.ts+3-6

 @@ -1,15 +1,12 @@
 import { Schema } from "effect";
+import { PositiveInt, TrimmedNonEmptyString } from "./baseSchemas";
 export const PROJECT_SEARCH_ENTRIES_MAX_LIMIT = 200;
-const TrimmedNonEmptyString = Schema.Trimmed.check(Schema.isNonEmpty());
 export const ProjectSearchEntriesInput = Schema.Struct({
   cwd: TrimmedNonEmptyString,
-  query: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+  query: TrimmedNonEmptyString.check(Schema.isMaxLength(256)),
-  limit: Schema.Int.check(
+  limit: PositiveInt.check(Schema.isLessThanOrEqualTo(PROJECT_SEARCH_ENTRIES_MAX_LIMIT)),
-    Schema.isGreaterThanOrEqualTo(1),
-    Schema.isLessThanOrEqualTo(PROJECT_SEARCH_ENTRIES_MAX_LIMIT),
-  ),
 });
 export type ProjectSearchEntriesInput = typeof ProjectSearchEntriesInput.Type;

packages/contracts/src/provider.ts+10-8

...	@@ -1,27 +1,29 @@	...	@@ -1,27 +1,29 @@
1	import { Schema } from "effect";	1	import { Schema } from "effect";
2		2	import { TrimmedNonEmptyString } from "./baseSchemas";
3	import {	3	import {
4	ApprovalRequestId,	4	ApprovalRequestId,
5	ChatAttachment,
6	EventId,	5	EventId,
7	IsoDateTime,	6	IsoDateTime,
8	NonNegativeInt,	7	NonNegativeInt,
		8	ProviderItemId,
		9	ProviderSessionId,
		10	ProviderThreadId,
		11	ProviderTurnId,
		12	ThreadId,
		13	} from "./baseSchemas";
		14	import {
		15	ChatAttachment,
9	PROVIDER_SEND_TURN_MAX_ATTACHMENTS,	16	PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
10	PROVIDER_SEND_TURN_MAX_INPUT_CHARS,	17	PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
11	ProviderApprovalDecision,	18	ProviderApprovalDecision,
12	ProviderApprovalPolicy,	19	ProviderApprovalPolicy,
13	ProviderKind,	20	ProviderKind,
14	ProviderItemId,
15	ProviderRequestKind,	21	ProviderRequestKind,
16	ProviderSandboxMode,	22	ProviderSandboxMode,
17	ProviderSessionId,
18	ProviderThreadId,
19	ProviderTurnId,
20	ThreadId,
21	TurnCountRange,	23	TurnCountRange,
22	} from "./orchestration";	24	} from "./orchestration";
23		25
24	const TrimmedNonEmptyStringSchema = Schema.Trimmed.check(Schema.isNonEmpty());	26	const TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
25		27
26	export const ProviderSessionStatus = Schema.Literals([	28	export const ProviderSessionStatus = Schema.Literals([
27	"connecting",	29	"connecting",

packages/contracts/src/providerRuntime.ts+14-14

 @@ -1,21 +1,21 @@
 import { Schema } from "effect";
+import { TrimmedNonEmptyString } from "./baseSchemas";
 import {
   ApprovalRequestId,
   EventId,
-  IsoDateTime,
   NonNegativeInt,
-  ProviderApprovalDecision,
   ProviderItemId,
-  ProviderKind,
-  ProviderRequestKind,
   ProviderSessionId,
   ProviderThreadId,
   ProviderTurnId,
   ThreadId,
   TurnId,
-} from "./orchestration";
+  IsoDateTime,
+} from "./baseSchemas";
+import { ProviderApprovalDecision, ProviderKind, ProviderRequestKind } from "./orchestration";
+const TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
 const RuntimeThreadIdSchema = Schema.Union([ThreadId, ProviderThreadId]);
 const RuntimeTurnIdSchema = Schema.Union([TurnId, ProviderTurnId]);
 @@ -37,7 +37,7 @@ export const ProviderRuntimeSessionStartedEvent = Schema.Struct({
   sessionId: ProviderSessionId,
   createdAt: IsoDateTime,
   threadId: Schema.optional(RuntimeThreadIdSchema),
-  message: Schema.optional(Schema.String),
+  message: Schema.optional(TrimmedNonEmptyStringSchema),
 });
 export type ProviderRuntimeSessionStartedEvent = typeof ProviderRuntimeSessionStartedEvent.Type;
 @@ -48,7 +48,7 @@ export const ProviderRuntimeSessionExitedEvent = Schema.Struct({
   sessionId: ProviderSessionId,
   createdAt: IsoDateTime,
   threadId: Schema.optional(RuntimeThreadIdSchema),
-  message: Schema.optional(Schema.String),
+  message: Schema.optional(TrimmedNonEmptyStringSchema),
 });
 export type ProviderRuntimeSessionExitedEvent = typeof ProviderRuntimeSessionExitedEvent.Type;
 @@ -82,7 +82,7 @@ export const ProviderRuntimeTurnCompletedEvent = Schema.Struct({
   threadId: Schema.optional(RuntimeThreadIdSchema),
   turnId: Schema.optional(RuntimeTurnIdSchema),
   status: Schema.optional(ProviderRuntimeTurnStatus),
-  errorMessage: Schema.optional(Schema.String),
+  errorMessage: Schema.optional(TrimmedNonEmptyStringSchema),
 });
 export type ProviderRuntimeTurnCompletedEvent = typeof ProviderRuntimeTurnCompletedEvent.Type;
 @@ -121,8 +121,8 @@ export const ProviderRuntimeToolStartedEvent = Schema.Struct({
   turnId: Schema.optional(RuntimeTurnIdSchema),
   itemId: Schema.optional(ProviderItemId),
   toolKind: ProviderRuntimeToolKind,
-  title: Schema.String,
+  title: TrimmedNonEmptyStringSchema,
-  detail: Schema.optional(Schema.String),
+  detail: Schema.optional(TrimmedNonEmptyStringSchema),
 });
 export type ProviderRuntimeToolStartedEvent = typeof ProviderRuntimeToolStartedEvent.Type;
 @@ -136,8 +136,8 @@ export const ProviderRuntimeToolCompletedEvent = Schema.Struct({
   turnId: Schema.optional(RuntimeTurnIdSchema),
   itemId: Schema.optional(ProviderItemId),
   toolKind: ProviderRuntimeToolKind,
-  title: Schema.String,
+  title: TrimmedNonEmptyStringSchema,
-  detail: Schema.optional(Schema.String),
+  detail: Schema.optional(TrimmedNonEmptyStringSchema),
 });
 export type ProviderRuntimeToolCompletedEvent = typeof ProviderRuntimeToolCompletedEvent.Type;
 @@ -152,7 +152,7 @@ export const ProviderRuntimeApprovalRequestedEvent = Schema.Struct({
   itemId: Schema.optional(ProviderItemId),
   requestId: ApprovalRequestId,
   requestKind: ProviderRequestKind,
-  detail: Schema.optional(Schema.String),
+  detail: Schema.optional(TrimmedNonEmptyStringSchema),
 });
 export type ProviderRuntimeApprovalRequestedEvent =
   typeof ProviderRuntimeApprovalRequestedEvent.Type;
 @@ -195,7 +195,7 @@ export const ProviderRuntimeErrorEvent = Schema.Struct({
   threadId: Schema.optional(RuntimeThreadIdSchema),
   turnId: Schema.optional(RuntimeTurnIdSchema),
   itemId: Schema.optional(ProviderItemId),
-  message: Schema.String,
+  message: TrimmedNonEmptyStringSchema,
 });
 export type ProviderRuntimeErrorEvent = typeof ProviderRuntimeErrorEvent.Type;

packages/contracts/src/server.ts+2-1

 @@ -1,8 +1,9 @@
 import { Schema } from "effect";
+import { TrimmedNonEmptyString } from "./baseSchemas";
 import { KeybindingRule, ResolvedKeybindingsConfig } from "./keybindings";
 export const ServerConfig = Schema.Struct({
-  cwd: Schema.NonEmptyString,
+  cwd: TrimmedNonEmptyString,
   keybindings: ResolvedKeybindingsConfig,
 });
 export type ServerConfig = typeof ServerConfig.Type;

packages/contracts/src/terminal.ts+4-8

 @@ -1,26 +1,22 @@
 import { Schema } from "effect";
+import { TrimmedNonEmptyString } from "./baseSchemas";
 export const DEFAULT_TERMINAL_ID = "default";
-const TrimmedNonEmptyStringSchema = Schema.Trim.check(Schema.isNonEmpty());
+const TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
 const TerminalColsSchema = Schema.Int.check(Schema.isGreaterThanOrEqualTo(20)).check(
   Schema.isLessThanOrEqualTo(400),
 );
 const TerminalRowsSchema = Schema.Int.check(Schema.isGreaterThanOrEqualTo(5)).check(
   Schema.isLessThanOrEqualTo(200),
 );
-const TerminalIdSchema = Schema.Trim.check(Schema.isNonEmpty()).check(Schema.isMaxLength(128));
+const TerminalIdSchema = TrimmedNonEmptyStringSchema.check(Schema.isMaxLength(128));
 const TerminalEnvKeySchema = Schema.String.check(
   Schema.isPattern(/^[A-Za-z_][A-Za-z0-9_]*$/),
 ).check(Schema.isMaxLength(128));
 const TerminalEnvValueSchema = Schema.String.check(Schema.isMaxLength(8_192));
 const TerminalEnvSchema = Schema.Record(TerminalEnvKeySchema, TerminalEnvValueSchema).check(
-  Schema.makeFilter<Record<string, string>>((env) => {
+  Schema.isMaxProperties(128),
-    if (Object.keys(env).length > 128) {
-      return { path: [], message: "Too many terminal env vars" };
-    }
-    return true;
-  }),
 );
 const TerminalIdWithDefaultSchema = TerminalIdSchema.pipe(

packages/contracts/src/ws.test.ts+19

...	@@ -37,3 +37,22 @@ it.effect("rejects getTurnDiff requests when fromTurnCount > toTurnCount", () =>	...	@@ -37,3 +37,22 @@ it.effect("rejects getTurnDiff requests when fromTurnCount > toTurnCount", () =>
37	assert.strictEqual(result._tag, "Failure");	37	assert.strictEqual(result._tag, "Failure");
38	}),	38	}),
39	);	39	);
		40
		41	it.effect("trims websocket request id and nested orchestration ids", () =>
		42	Effect.gen(function* () {
		43	const parsed = yield* decodeWebSocketRequest({
		44	id: " req-1 ",
		45	body: {
		46	_tag: ORCHESTRATION_WS_METHODS.getTurnDiff,
		47	threadId: " thread-1 ",
		48	fromTurnCount: 0,
		49	toTurnCount: 0,
		50	},
		51	});
		52	assert.strictEqual(parsed.id, "req-1");
		53	assert.strictEqual(parsed.body._tag, ORCHESTRATION_WS_METHODS.getTurnDiff);
		54	if (parsed.body._tag === ORCHESTRATION_WS_METHODS.getTurnDiff) {
		55	assert.strictEqual(parsed.body.threadId, "thread-1");
		56	}
		57	}),
		58	);

packages/contracts/src/ws.ts+6-5

...	@@ -1,4 +1,5 @@	...	@@ -1,4 +1,5 @@
1	import { Schema, Struct } from "effect";	1	import { Schema, Struct } from "effect";
		2	import { TrimmedNonEmptyString } from "./baseSchemas";
2		3
3	import {	4	import {
4	ClientOrchestrationCommand,	5	ClientOrchestrationCommand,
...	@@ -128,13 +129,13 @@ export const WebSocketRequestBody = Schema.Union([	...	@@ -128,13 +129,13 @@ export const WebSocketRequestBody = Schema.Union([
128	]);	129	]);
129		130
130	export const WebSocketRequest = Schema.Struct({	131	export const WebSocketRequest = Schema.Struct({
131	id: Schema.String,	132	id: TrimmedNonEmptyString,
132	body: WebSocketRequestBody,	133	body: WebSocketRequestBody,
133	});	134	});
134	export type WebSocketRequest = typeof WebSocketRequest.Type;	135	export type WebSocketRequest = typeof WebSocketRequest.Type;
135		136
136	export const WebSocketResponse = Schema.Struct({	137	export const WebSocketResponse = Schema.Struct({
137	id: Schema.String,	138	id: TrimmedNonEmptyString,
138	result: Schema.optional(Schema.Unknown),	139	result: Schema.optional(Schema.Unknown),
139	error: Schema.optional(	140	error: Schema.optional(
140	Schema.Struct({	141	Schema.Struct({
...	@@ -146,7 +147,7 @@ export type WebSocketResponse = typeof WebSocketResponse.Type;	...	@@ -146,7 +147,7 @@ export type WebSocketResponse = typeof WebSocketResponse.Type;
146		147
147	export const WsPush = Schema.Struct({	148	export const WsPush = Schema.Struct({
148	type: Schema.Literal("push"),	149	type: Schema.Literal("push"),
149	channel: Schema.String,	150	channel: TrimmedNonEmptyString,
150	data: Schema.Unknown,	151	data: Schema.Unknown,
151	});	152	});
152	export type WsPush = typeof WsPush.Type;	153	export type WsPush = typeof WsPush.Type;
...	@@ -159,7 +160,7 @@ export type WsResponse = typeof WsResponse.Type;	...	@@ -159,7 +160,7 @@ export type WsResponse = typeof WsResponse.Type;
159	// ── Server welcome payload ───────────────────────────────────────────	160	// ── Server welcome payload ───────────────────────────────────────────
160		161
161	export const WsWelcomePayload = Schema.Struct({	162	export const WsWelcomePayload = Schema.Struct({
162	cwd: Schema.String,	163	cwd: TrimmedNonEmptyString,
163	projectName: Schema.String,	164	projectName: TrimmedNonEmptyString,
164	});	165	});
165	export type WsWelcomePayload = typeof WsWelcomePayload.Type;	166	export type WsWelcomePayload = typeof WsWelcomePayload.Type;

author	Julius Marminge <julius0216@outlook.com> 2026-02-25 22:50:17-08:00
committer	Julius Marminge <jmarminge@gmail.com> 2026-02-26 13:20:36-08:00
log	e5542b7a880aa40ab5a4b5ad8012822c11643471
tree	5095728ead2c41212ce5918ff55c1d2ebc43dcf7
parent	76208f79de4cb79146f1501feed6162eef71e24b

delegate trimming to schema