@cmmd-center/forge 0.11.0 → 0.11.1

package/dist/bin.cjs

@@ -15773,7 +15773,7 @@ const get$1 = (self) => modify$1(self, (current) => [current, current]);
 * })
 * ```
 */
-const set$1 = /* @__PURE__ */ require_Schema$1.dual(2, (self, value) => update$1(self, () => value));
+const set$2 = /* @__PURE__ */ require_Schema$1.dual(2, (self, value) => update$1(self, () => value));
 //#endregion
 //#region ../../node_modules/.bun/effect@4.0.0-beta.51/node_modules/effect/dist/TxChunk.js
 /**
@@ -15962,7 +15962,7 @@ const get = (self) => get$1(self.ref);
 * @since 4.0.0
 * @category combinators
 */
-const set = /* @__PURE__ */ require_Schema$1.dual(2, (self, chunk) => set$1(self.ref, chunk));
+const set$1 = /* @__PURE__ */ require_Schema$1.dual(2, (self, chunk) => set$2(self.ref, chunk));
 /**
 * Appends an element to the end of the `TxChunk`.
 *
@@ -16211,7 +16211,7 @@ const take = (self) => require_Schema$1.gen(function* () {
 	const head$3 = require_Schema$1.head(chunk);
 	if (require_Schema$1.isNone(head$3)) return yield* require_Schema$1.txRetry;
 	yield* drop(self.items, 1);
-	if (state._tag === "Closing" && (yield* isEmpty(self))) yield* set$1(self.stateRef, {
+	if (state._tag === "Closing" && (yield* isEmpty(self))) yield* set$2(self.stateRef, {
 		_tag: "Done",
 		cause: state.cause
 	});
@@ -16309,11 +16309,11 @@ const interrupt = (self) => require_Schema$1.withFiber((fiber) => failCause(self
 */
 const failCause = /* @__PURE__ */ require_Schema$1.dual(2, (self, cause) => require_Schema$1.gen(function* () {
 	if ((yield* get$1(self.stateRef))._tag !== "Open") return false;
-	if (yield* isEmpty(self)) yield* set$1(self.stateRef, {
+	if (yield* isEmpty(self)) yield* set$2(self.stateRef, {
 		_tag: "Done",
 		cause
 	});
-	else yield* set$1(self.stateRef, {
+	else yield* set$2(self.stateRef, {
 		_tag: "Closing",
 		cause
 	});
@@ -16355,7 +16355,7 @@ const clear = (self) => require_Schema$1.gen(function* () {
 		return yield* require_Schema$1.failCause(state.cause);
 	}
 	const chunk = yield* get(self.items);
-	yield* set(self.items, require_Schema$1.empty());
+	yield* set$1(self.items, require_Schema$1.empty());
 	return require_Schema$1.toArray(chunk);
 }).pipe(require_Schema$1.tx);
 /**
@@ -26678,6 +26678,29 @@ function encodeCmmdRuntimeThreadLifecycleMetadata(lifecycle) {
 	} };
 }
 //#endregion
+//#region ../../packages/contracts/src/cmmdRuntimeThreadWorkspace.ts
+function encodeCmmdRuntimeThreadWorkspaceMetadata(workspace) {
+	return { forgeWorkspace: {
+		schemaVersion: 1,
+		worktreePath: workspace.worktreePath
+	} };
+}
+//#endregion
+//#region ../../packages/contracts/src/cmmdRuntimeToolActivity.ts
+function isRecord$22(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function encodeCmmdRuntimeToolActivityPayload(kind, payload) {
+	return {
+		...isRecord$22(payload) ? payload : { sourcePayload: payload },
+		forgeToolActivity: {
+			schemaVersion: 1,
+			source: "native",
+			kind
+		}
+	};
+}
+//#endregion
 //#region ../../packages/contracts/src/cmmdProjectPatch.ts
 const CMMD_PROJECT_PATCH_FIELDS = {
 	title: "requiredText",
@@ -65775,7 +65798,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.11.0";
+var version$1 = "0.11.1";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -69563,6 +69586,17 @@ const browserApiCorsLayer = middleware(require_HttpServer.cors({
 	credentials: true,
 	maxAge: 600
 }), { global: true });
+/**
+* An /api path that reaches the static catch-all is not implemented by this
+* server: every real API route is registered ahead of it. Serving the web app's
+* index.html for those made API clients decode an HTML document as JSON, which
+* is how the phone's shell snapshot fetch failed with a JSON parse error on
+* every connect (FOR-36611). Callers can act on a 404; they cannot act on a
+* document that claims to be their payload.
+*/
+function isApiRequestPath(pathname) {
+	return pathname === "/api" || pathname.startsWith("/api/");
+}
 function resolveDevRedirectUrl(devUrl, requestUrl) {
 	const redirectUrl = new URL(devUrl.toString());
 	redirectUrl.pathname = requestUrl.pathname;
@@ -69687,6 +69721,10 @@ const staticAndDevRouteLayer = add$1("GET", "*", require_Schema$1.gen(function*
 	const request = yield* require_HttpServer.HttpServerRequest;
 	const url = require_HttpServer.toURL(request);
 	if (require_Schema$1.isNone(url)) return require_HttpServer.text("Bad Request", { status: 400 });
+	if (isApiRequestPath(url.value.pathname)) return require_HttpServer.jsonUnsafe({
+		error: "not_found",
+		message: `This server does not serve ${url.value.pathname}.`
+	}, { status: 404 });
 	const config = yield* ServerConfig;
 	if (config.devUrl && isLoopbackHostname(url.value.hostname)) return require_HttpServer.redirect(resolveDevRedirectUrl(config.devUrl, url.value), { status: 302 });
 	const staticDir = config.staticDir ?? (config.devUrl ? yield* resolveStaticDir() : void 0);
@@ -95993,10 +96031,13 @@ function serializeRuntimeInventory(snapshot, providerInventory) {
 			workerRole: thread.workerRole,
 			anchorKind: thread.anchorKind,
 			anchorCmmdId: thread.anchorCmmdId,
-			metadata: encodeCmmdRuntimeThreadLifecycleMetadata({
-				settledAt: thread.settledAt ?? null,
-				settledOverride: thread.settledOverride ?? null
-			})
+			metadata: {
+				...encodeCmmdRuntimeThreadLifecycleMetadata({
+					settledAt: thread.settledAt ?? null,
+					settledOverride: thread.settledOverride ?? null
+				}),
+				...encodeCmmdRuntimeThreadWorkspaceMetadata({ worktreePath: thread.worktreePath })
+			}
 		})),
 		metadata: {
 			source: "forge-server-projection",
@@ -96063,7 +96104,7 @@ function serializeNativeToolActivity(activity) {
 			kind: "tool_call",
 			summary,
 			status: activityStatus(activity),
-			...activity.payload === void 0 ? {} : { payload: activity.payload }
+			payload: encodeCmmdRuntimeToolActivityPayload(activity.kind, activity.payload)
 		}
 	};
 }
@@ -98633,413 +98674,23 @@ function browseDirectory(input) {
 	});
 }
 //#endregion
-//#region src/workspace/Services/WorkspaceEntries.ts
+//#region src/pathWithinRoot.ts
 /**
-* WorkspaceEntries - Effect service contract for cached workspace entry search.
+* True when `candidate` is `root` itself or lies below it, judged on the path
+* strings alone. The path from `root` to `candidate` is taken with
+* `path.relative` and normalised to forward slashes, and the candidate is
+* outside when that path climbs out (`..` or `../...`) or is absolute, which is
+* what `relative` returns across Windows drives. A child whose name only starts
+* with two dots, such as `..cache`, is inside. Symlinks are not followed, so a
+* caller that cares where a link points has to compare resolved paths.
 *
-* Owns indexed workspace entry search plus cache invalidation for workspace
-* roots when the underlying filesystem changes.
-*
-* @module WorkspaceEntries
-*/
-var WorkspaceEntriesError = class extends require_Schema$1.TaggedErrorClass()("WorkspaceEntriesError", {
-	cwd: require_Schema$1.String,
-	operation: require_Schema$1.String,
-	detail: require_Schema$1.String,
-	cause: require_Schema$1.optional(require_Schema$1.Defect)
-}) {};
-/**
-* WorkspaceEntries - Service tag for cached workspace entry search.
-*/
-var WorkspaceEntries = class extends require_Schema$1.Service()("forge/workspace/Services/WorkspaceEntries") {};
-//#endregion
-//#region src/workspace/Services/WorkspaceBulkTransfer.ts
-var WorkspaceBulkTransfer = class extends require_Schema$1.Service()("forge/workspace/Services/WorkspaceBulkTransfer") {};
-//#endregion
-//#region src/workspace/Layers/WorkspaceBulkTransfer.ts
-const TRANSFER_TTL_MS = 1440 * 60 * 1e3;
-const TRANSFER_LOCK_STRIPE_COUNT = 64;
-function transferError(input) {
-	return new BulkTransferError({
-		code: input.code,
-		message: input.message,
-		transferId: input.transferId ?? null,
-		retryable: input.retryable ?? false,
-		...input.cause === void 0 ? {} : { cause: input.cause }
-	});
-}
-function mapFailure(operation, transferId) {
-	return (cause) => require_Schema$1.is(BulkTransferError)(cause) ? cause : transferError({
-		code: "io_error",
-		message: `Workspace bulk transfer failed during ${operation}.`,
-		...transferId === void 0 ? {} : { transferId },
-		retryable: true,
-		cause
-	});
-}
-/**
-* Exported so the unary file read in `projectFile/readProjectFile.ts` uses this
-* containment check rather than a second copy of it. Two copies of a security
-* rule in one repo is how they drift, and the drift is silent.
+* Only a type import, so a module that has to stay free of Effect services can
+* use it without importing a Layer.
 */
 function isPathWithinRoot(path, root, candidate) {
 	const relative = path.relative(root, candidate).replaceAll("\\", "/");
 	return relative === "" || !relative.startsWith("../") && relative !== ".." && !path.isAbsolute(relative);
 }
-function transferLockStripe(transferId) {
-	let hash = 2166136261;
-	for (let index = 0; index < transferId.length; index += 1) hash = Math.imul(hash ^ transferId.charCodeAt(index), 16777619);
-	return (hash >>> 0) % TRANSFER_LOCK_STRIPE_COUNT;
-}
-const makeWorkspaceBulkTransfer = (options = {}) => require_Schema$1.gen(function* () {
-	const fileSystem = yield* require_Path.FileSystem;
-	const path = yield* require_Path.Path;
-	const sql = yield* require_SqlError.SqlClient;
-	const workspacePaths = yield* WorkspacePaths;
-	const workspaceEntries = yield* WorkspaceEntries;
-	const fault = options.fault ?? (() => require_Schema$1.void_);
-	const transferLocks = yield* require_Schema$1.forEach(Array.from({ length: TRANSFER_LOCK_STRIPE_COUNT }), () => require_Path.make$5(1));
-	const withTransferLock = (transferId, effect) => transferLocks[transferLockStripe(transferId)].withPermit(effect);
-	const findTransfer = (transferId) => sql`
-        SELECT transfer_id AS "transferId", workspace_root AS "workspaceRoot",
-          relative_path AS "relativePath", target_path AS "targetPath", temp_path AS "tempPath",
-          total_bytes AS "totalBytes", whole_sha256 AS "wholeSha256",
-          next_offset AS "nextOffset", state, expires_at AS "expiresAt"
-        FROM workspace_bulk_transfers WHERE transfer_id = ${transferId} LIMIT 1
-      `.pipe(require_Schema$1.map((rows) => rows[0] ?? null));
-	const requireTransfer = (transferId) => findTransfer(transferId).pipe(require_Schema$1.flatMap((row) => row === null ? require_Schema$1.fail(transferError({
-		code: "transfer_not_found",
-		message: "Bulk transfer does not exist.",
-		transferId
-	})) : require_Schema$1.succeed(row)));
-	const requireOpenTransfer = (transferId) => requireTransfer(transferId).pipe(require_Schema$1.flatMap((row) => {
-		if (row.state === "cancelled") return require_Schema$1.fail(transferError({
-			code: "transfer_cancelled",
-			message: "Bulk transfer was cancelled.",
-			transferId
-		}));
-		if (row.state === "expired" || Date.parse(row.expiresAt) <= Date.now()) return require_Schema$1.fail(transferError({
-			code: "transfer_expired",
-			message: "Bulk transfer expired.",
-			transferId
-		}));
-		return require_Schema$1.succeed(row);
-	}));
-	const resolveTarget = require_Schema$1.fn("WorkspaceBulkTransfer.resolveTarget")(function* (input) {
-		const workspaceRoot = yield* workspacePaths.normalizeWorkspaceRoot(input.cwd);
-		const resolved = yield* workspacePaths.resolveRelativePathWithinRoot({
-			workspaceRoot,
-			relativePath: input.relativePath
-		});
-		const canonicalRoot = yield* fileSystem.realPath(workspaceRoot);
-		const parentSegments = resolved.relativePath.split("/").slice(0, -1);
-		let canonicalParent = canonicalRoot;
-		for (const segment of parentSegments) {
-			const candidate = path.join(canonicalParent, segment);
-			const canonicalCandidate = yield* fileSystem.realPath(candidate).pipe(require_Schema$1.catch_(() => input.createParent ? fileSystem.makeDirectory(candidate).pipe(require_Schema$1.flatMap(() => fileSystem.realPath(candidate))) : fileSystem.realPath(candidate)));
-			if (!isPathWithinRoot(path, canonicalRoot, canonicalCandidate)) return yield* transferError({
-				code: "symlink_escape",
-				message: "Workspace file path resolves outside the project root."
-			});
-			canonicalParent = canonicalCandidate;
-		}
-		const targetPath = path.join(canonicalParent, path.basename(resolved.relativePath));
-		const targetRealPath = yield* fileSystem.realPath(targetPath).pipe(require_Schema$1.catch_(() => require_Schema$1.succeed(null)));
-		if (targetRealPath !== null && !isPathWithinRoot(path, canonicalRoot, targetRealPath)) return yield* transferError({
-			code: "symlink_escape",
-			message: "Workspace file target resolves outside the project root."
-		});
-		return {
-			workspaceRoot: canonicalRoot,
-			relativePath: resolved.relativePath,
-			targetPath,
-			canonicalParent
-		};
-	});
-	const readFile = (input) => require_Path.unwrap(require_Schema$1.gen(function* () {
-		const target = yield* resolveTarget({
-			...input,
-			createParent: false
-		});
-		const info = yield* fileSystem.stat(target.targetPath);
-		const maxBytes = input.maxBytes ?? 16777216;
-		if (Number(info.size) > maxBytes) return yield* transferError({
-			code: "size_limit_exceeded",
-			message: `Workspace file exceeds the ${maxBytes}-byte read limit.`
-		});
-		const bytes = yield* fileSystem.readFile(target.targetPath);
-		const transfer = yield* require_Schema$1.promise(() => chunkBulkTransfer(bytes));
-		const transferId = transfer.chunks[0]?.transferId ?? crypto.randomUUID().replaceAll("-", "_");
-		return require_Path.fromIterable([
-			{
-				kind: "started",
-				transferId,
-				totalBytes: transfer.totalBytes,
-				sha256: transfer.sha256
-			},
-			...transfer.chunks.map((chunk) => ({
-				...chunk,
-				transferId
-			})),
-			{
-				kind: "completed",
-				transferId,
-				totalBytes: transfer.totalBytes,
-				sha256: transfer.sha256
-			}
-		]);
-	}).pipe(require_Schema$1.mapError(mapFailure("read file"))));
-	const resumeWrite = require_Schema$1.fn("WorkspaceBulkTransfer.resumeWrite")(function* (input, existing) {
-		const target = yield* resolveTarget({
-			...input,
-			createParent: true
-		});
-		if (!(existing.workspaceRoot === target.workspaceRoot && existing.relativePath === target.relativePath && existing.totalBytes === input.totalBytes && existing.wholeSha256 === input.sha256)) return yield* transferError({
-			code: "transfer_identity_conflict",
-			message: "Bulk transfer ID is already bound to different content or a different path.",
-			transferId: input.transferId
-		});
-		if (existing.state === "cancelled") return yield* transferError({
-			code: "transfer_cancelled",
-			message: "Bulk transfer was cancelled.",
-			transferId: input.transferId
-		});
-		if (existing.state === "expired" || Date.parse(existing.expiresAt) <= Date.now()) return yield* transferError({
-			code: "transfer_expired",
-			message: "Bulk transfer expired.",
-			transferId: input.transferId
-		});
-		return {
-			transferId: input.transferId,
-			nextOffset: existing.nextOffset,
-			state: existing.state === "completed" ? "completed" : "open"
-		};
-	});
-	const createWrite = require_Schema$1.fn("WorkspaceBulkTransfer.createWrite")(function* (input) {
-		const target = yield* resolveTarget({
-			...input,
-			createParent: true
-		}).pipe(require_Schema$1.mapError((cause) => require_Schema$1.is(WorkspacePathOutsideRootError)(cause) ? transferError({
-			code: "path_outside_workspace",
-			message: "Workspace file path must stay within the project root.",
-			transferId: input.transferId,
-			cause
-		}) : cause));
-		const tempPath = path.join(target.canonicalParent, `.forge-transfer-${input.transferId}.part`);
-		yield* require_Schema$1.scoped(fileSystem.open(tempPath, {
-			flag: "wx",
-			mode: 384
-		}).pipe(require_Schema$1.flatMap((file) => file.sync), require_Schema$1.catch_(() => fileSystem.stat(tempPath).pipe(require_Schema$1.flatMap((stat) => Number(stat.size) === 0 ? require_Schema$1.void_ : require_Schema$1.fail(transferError({
-			code: "transfer_identity_conflict",
-			message: "Bulk transfer temporary path already contains data.",
-			transferId: input.transferId
-		})))))));
-		const now = /* @__PURE__ */ new Date();
-		yield* sql`
-        INSERT INTO workspace_bulk_transfers (
-          transfer_id, workspace_root, relative_path, target_path, temp_path, total_bytes,
-          whole_sha256, next_offset, state, expires_at, created_at, updated_at
-        ) VALUES (
-          ${input.transferId}, ${target.workspaceRoot}, ${target.relativePath}, ${target.targetPath},
-          ${tempPath}, ${input.totalBytes}, ${input.sha256}, 0, 'open',
-          ${new Date(now.getTime() + TRANSFER_TTL_MS).toISOString()}, ${now.toISOString()},
-          ${now.toISOString()}
-        )
-      `;
-		return {
-			transferId: input.transferId,
-			nextOffset: 0,
-			state: "open"
-		};
-	});
-	const beginWriteEffect = require_Schema$1.fn("WorkspaceBulkTransfer.beginWrite")(function* (input) {
-		const existing = yield* findTransfer(input.transferId);
-		return yield* existing === null ? createWrite(input) : resumeWrite(input, existing);
-	});
-	const beginWrite = (input) => withTransferLock(input.transferId, beginWriteEffect(input)).pipe(require_Schema$1.mapError(mapFailure("begin write", input.transferId)));
-	const acceptRetriedChunk = require_Schema$1.fn("WorkspaceBulkTransfer.acceptRetriedChunk")(function* (input, row) {
-		const accepted = (yield* sql`
-          SELECT chunk_offset AS "chunkOffset", chunk_bytes AS "chunkBytes",
-            chunk_sha256 AS "chunkSha256"
-          FROM workspace_bulk_transfer_chunks
-          WHERE transfer_id = ${input.transferId} AND chunk_offset = ${input.offset}
-          LIMIT 1
-        `)[0];
-		if (!(accepted !== void 0 && accepted.chunkBytes === input.bytes && accepted.chunkSha256 === input.sha256)) return yield* transferError({
-			code: "integrity_mismatch",
-			message: "Retried bulk transfer chunk differs from the accepted chunk.",
-			transferId: input.transferId
-		});
-		return {
-			transferId: input.transferId,
-			nextOffset: row.nextOffset,
-			duplicate: true
-		};
-	});
-	const validateChunkRange = require_Schema$1.fn("WorkspaceBulkTransfer.validateChunkRange")(function* (input, row, byteLength) {
-		if (input.offset !== row.nextOffset) return yield* transferError({
-			code: "offset_mismatch",
-			message: `Expected chunk offset ${row.nextOffset}, received ${input.offset}.`,
-			transferId: input.transferId,
-			retryable: true
-		});
-		const nextOffset = input.offset + byteLength;
-		if (nextOffset > row.totalBytes) return yield* transferError({
-			code: "size_limit_exceeded",
-			message: "Bulk transfer chunk exceeds the declared total byte count.",
-			transferId: input.transferId
-		});
-		return nextOffset;
-	});
-	const reconcileChunkBytes = require_Schema$1.fn("WorkspaceBulkTransfer.reconcileChunkBytes")(function* (input, row, bytes, nextOffset) {
-		const tempInfo = yield* fileSystem.stat(row.tempPath);
-		if (Number(tempInfo.size) > row.nextOffset) {
-			if (Number(tempInfo.size) !== nextOffset) return yield* transferError({
-				code: "integrity_mismatch",
-				message: "Bulk transfer temporary file cannot be reconciled with the next chunk.",
-				transferId: input.transferId
-			});
-			const recovered = (yield* fileSystem.readFile(row.tempPath)).slice(input.offset, nextOffset);
-			if ((yield* require_Schema$1.promise(() => sha256Hex(recovered))) !== input.sha256) return yield* transferError({
-				code: "integrity_mismatch",
-				message: "Bulk transfer temporary bytes differ from the retried chunk.",
-				transferId: input.transferId
-			});
-			return;
-		}
-		yield* fault("before-byte-write");
-		yield* require_Schema$1.scoped(fileSystem.open(row.tempPath, { flag: "r+" }).pipe(require_Schema$1.flatMap((file) => file.seek(input.offset, "start").pipe(require_Schema$1.flatMap(() => file.writeAll(bytes)), require_Schema$1.flatMap(() => file.sync)))));
-		yield* fault("after-byte-write-before-metadata");
-	});
-	const persistAcceptedChunk = require_Schema$1.fn("WorkspaceBulkTransfer.persistAcceptedChunk")(function* (input, nextOffset) {
-		const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		yield* sql.withTransaction(sql`
-          INSERT INTO workspace_bulk_transfer_chunks (
-            transfer_id, chunk_offset, chunk_bytes, chunk_sha256
-          ) VALUES (${input.transferId}, ${input.offset}, ${input.bytes}, ${input.sha256})
-          ON CONFLICT DO NOTHING
-        `.pipe(require_Schema$1.flatMap(() => sql`
-            UPDATE workspace_bulk_transfers
-            SET next_offset = ${nextOffset}, updated_at = ${updatedAt}
-            WHERE transfer_id = ${input.transferId} AND next_offset = ${input.offset} AND state = 'open'
-          `)));
-		yield* fault("after-metadata-advance");
-	});
-	const writeChunkEffect = require_Schema$1.fn("WorkspaceBulkTransfer.writeChunk")(function* (input) {
-		const bytes = yield* require_Schema$1.promise(() => verifyBulkTransferChunk({
-			...input,
-			kind: "chunk"
-		}));
-		const row = yield* requireOpenTransfer(input.transferId);
-		if (row.state === "completed") return yield* transferError({
-			code: "offset_mismatch",
-			message: "Bulk transfer is already complete.",
-			transferId: input.transferId
-		});
-		if (input.offset < row.nextOffset) return yield* acceptRetriedChunk(input, row);
-		const nextOffset = yield* validateChunkRange(input, row, bytes.byteLength);
-		yield* reconcileChunkBytes(input, row, bytes, nextOffset);
-		yield* persistAcceptedChunk(input, nextOffset);
-		return {
-			transferId: input.transferId,
-			nextOffset,
-			duplicate: false
-		};
-	});
-	const writeChunk = (input) => withTransferLock(input.transferId, writeChunkEffect(input)).pipe(require_Schema$1.mapError(mapFailure("write chunk", input.transferId)));
-	const commitWriteEffect = require_Schema$1.fn("WorkspaceBulkTransfer.commitWrite")(function* (input) {
-		const row = yield* requireOpenTransfer(input.transferId);
-		if (row.state === "completed") return {
-			transferId: row.transferId,
-			relativePath: row.relativePath,
-			totalBytes: row.totalBytes,
-			sha256: row.wholeSha256
-		};
-		if (row.nextOffset !== row.totalBytes) return yield* transferError({
-			code: "offset_mismatch",
-			message: `Bulk transfer is incomplete at byte ${row.nextOffset} of ${row.totalBytes}.`,
-			transferId: row.transferId,
-			retryable: true
-		});
-		if ((yield* resolveTarget({
-			cwd: row.workspaceRoot,
-			relativePath: row.relativePath,
-			createParent: false
-		})).targetPath !== row.targetPath) return yield* transferError({
-			code: "symlink_escape",
-			message: "Workspace file destination changed during transfer.",
-			transferId: row.transferId
-		});
-		const tempInfo = yield* fileSystem.stat(row.tempPath).pipe(require_Schema$1.catch_(() => require_Schema$1.succeed(null)));
-		const candidatePath = tempInfo === null ? row.targetPath : row.tempPath;
-		const candidate = yield* fileSystem.readFile(candidatePath);
-		if (candidate.byteLength !== row.totalBytes || (yield* require_Schema$1.promise(() => sha256Hex(candidate))) !== row.wholeSha256) return yield* transferError({
-			code: "integrity_mismatch",
-			message: "Bulk transfer payload does not match its declared size and digest.",
-			transferId: row.transferId
-		});
-		if (tempInfo !== null) {
-			yield* fileSystem.rename(row.tempPath, row.targetPath);
-			yield* fault("after-atomic-rename");
-		}
-		yield* sql`
-        UPDATE workspace_bulk_transfers SET state = 'completed', updated_at = ${(/* @__PURE__ */ new Date()).toISOString()}
-        WHERE transfer_id = ${row.transferId}
-      `;
-		yield* workspaceEntries.invalidate(row.workspaceRoot);
-		return {
-			transferId: row.transferId,
-			relativePath: row.relativePath,
-			totalBytes: row.totalBytes,
-			sha256: row.wholeSha256
-		};
-	});
-	const commitWrite = (input) => withTransferLock(input.transferId, commitWriteEffect(input)).pipe(require_Schema$1.mapError(mapFailure("commit write", input.transferId)));
-	const cancelWriteEffect = require_Schema$1.fn("WorkspaceBulkTransfer.cancelWrite")(function* (input) {
-		const row = yield* requireTransfer(input.transferId);
-		if (row.state !== "completed") {
-			yield* fileSystem.remove(row.tempPath, { force: true });
-			yield* sql`
-          UPDATE workspace_bulk_transfers SET state = 'cancelled', updated_at = ${(/* @__PURE__ */ new Date()).toISOString()}
-          WHERE transfer_id = ${input.transferId}
-        `;
-		}
-		return {
-			transferId: input.transferId,
-			state: row.state === "completed" ? "completed" : "cancelled"
-		};
-	});
-	const cancelWrite = (input) => withTransferLock(input.transferId, cancelWriteEffect(input)).pipe(require_Schema$1.mapError(mapFailure("cancel write", input.transferId)));
-	const cleanupExpiredEffect = require_Schema$1.fn("WorkspaceBulkTransfer.cleanupExpired")(function* () {
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		const rows = yield* sql`
-        SELECT transfer_id AS "transferId", temp_path AS "tempPath"
-        FROM workspace_bulk_transfers WHERE state = 'open' AND expires_at <= ${now}
-      `;
-		let expiredCount = 0;
-		for (const row of rows) if (yield* withTransferLock(row.transferId, require_Schema$1.gen(function* () {
-			const current = yield* findTransfer(row.transferId);
-			if (current === null || current.state !== "open" || Date.parse(current.expiresAt) > Date.parse(now)) return false;
-			yield* fileSystem.remove(current.tempPath, { force: true });
-			yield* sql`
-              UPDATE workspace_bulk_transfers SET state = 'expired', updated_at = ${now}
-              WHERE transfer_id = ${row.transferId} AND state = 'open' AND expires_at <= ${now}
-            `;
-			return true;
-		}))) expiredCount += 1;
-		return expiredCount;
-	});
-	const cleanupExpired = () => cleanupExpiredEffect().pipe(require_Schema$1.mapError(mapFailure("expiry cleanup")));
-	return {
-		readFile,
-		beginWrite,
-		writeChunk,
-		commitWrite,
-		cancelWrite,
-		cleanupExpired
-	};
-});
-const WorkspaceBulkTransferLive = require_Schema$1.effect(WorkspaceBulkTransfer, makeWorkspaceBulkTransfer());
 //#endregion
 //#region src/projectFile/readProjectFile.ts
 /**
@@ -99843,6 +99494,26 @@ const DevTunnelLive = require_Schema$1.effect(DevTunnel, require_Schema$1.gen(fu
 	};
 }));
 //#endregion
+//#region src/workspace/Services/WorkspaceEntries.ts
+/**
+* WorkspaceEntries - Effect service contract for cached workspace entry search.
+*
+* Owns indexed workspace entry search plus cache invalidation for workspace
+* roots when the underlying filesystem changes.
+*
+* @module WorkspaceEntries
+*/
+var WorkspaceEntriesError = class extends require_Schema$1.TaggedErrorClass()("WorkspaceEntriesError", {
+	cwd: require_Schema$1.String,
+	operation: require_Schema$1.String,
+	detail: require_Schema$1.String,
+	cause: require_Schema$1.optional(require_Schema$1.Defect)
+}) {};
+/**
+* WorkspaceEntries - Service tag for cached workspace entry search.
+*/
+var WorkspaceEntries = class extends require_Schema$1.Service()("forge/workspace/Services/WorkspaceEntries") {};
+//#endregion
 //#region src/workspace/Services/WorkspaceFileSystem.ts
 /**
 * WorkspaceFileSystem - Effect service contract for workspace file mutations.
@@ -99864,6 +99535,9 @@ var WorkspaceFileSystemError = class extends require_Schema$1.TaggedErrorClass()
 */
 var WorkspaceFileSystem = class extends require_Schema$1.Service()("forge/workspace/Services/WorkspaceFileSystem") {};
 //#endregion
+//#region src/workspace/Services/WorkspaceBulkTransfer.ts
+var WorkspaceBulkTransfer = class extends require_Schema$1.Service()("forge/workspace/Services/WorkspaceBulkTransfer") {};
+//#endregion
 //#region src/workspace/Services/WorkspaceReadinessState.ts
 var WorkspaceReadinessState = class extends require_Schema$1.Service()("forge/workspace/Services/WorkspaceReadinessState") {};
 //#endregion
@@ -211344,56 +211018,169 @@ function hasConfiguredApexCredential(profiles) {
 	}));
 }
 //#endregion
-//#region src/provider/claudeCredentialContainment.ts
+//#region src/provider/claudeCredentialDirectory.ts
 /**
-* Containment for provider credentials inherited by the Claude Agent SDK child.
+* Per-account credential directories for Claude turns.
 *
-* Pure and dependency-free on purpose: ClaudeAdapter pulls in Effect platform
-* services, the browser manager, and the server config, so a unit test that
-* imports it cannot run in a worktree. This rule is cost-critical and must stay
-* directly testable.
+* Claude Code keeps conversation transcripts under
+* `${CLAUDE_CONFIG_DIR}/projects/<cwd-slug>/<sessionId>.jsonl` and its login
+* under `.credentials.json`. `CLAUDE_SECURESTORAGE_CONFIG_DIR` moves only the
+* credential file, so each Provider Account can hold its own login while every
+* session file stays in one place and `--resume` keeps finding its target. See
+* `docs/adr/claude-accounts-split-credentials-not-sessions.md`.
 *
-* Audit finding S1 (2026-07-25). The Claude Agent SDK reads ANTHROPIC_API_KEY /
-* ANTHROPIC_AUTH_TOKEN from its own environment, and those TAKE PRECEDENCE over
-* the user's claude.ai OAuth login — that precedence is exactly what the
-* adapter relies on to redirect billing at the proxy.
+* That variable is not documented. Under
+* `docs/adr/unpublished-provider-surface-needs-a-fallback.md` the dependency is
+* only allowed because absence degrades to a named behaviour that already
+* works: a thread with no account runs on the Environment's own login. This
+* module sets the variable only when the resolved directory holds a credential
+* the CLI can use, because a missing file, or one whose access token a refusal
+* has blanked, makes the CLI report logged out and a live turn would fail.
 *
-* So on a plain Claude turn (no endpoint profile, no proxy credential), which
-* is supposed to run on the personal subscription, an ANTHROPIC_* key inherited
-* from the server's environment would send the turn straight to
-* api.anthropic.com on a metered account — never reaching
-* /api/provider-egress/*, leaving the fail-closed billing gate inert.
+* Nothing writes these directories yet. #3049 adds the writer and keys each
+* directory on the account identity CMMD writes on the delivery receipt it
+* signs (`docs/adr/provider-account-identity-is-issued-by-cmmd.md`). Until then
+* every runtime takes the `no-account` skip.
 *
-* Forge Cloud sprites were only incidentally safe (no Anthropic key present on
-* the box). This makes containment an enforced property rather than an
-* assumption about what the deployment environment happens to contain.
+* Free of Effect services on purpose, for the same reason as
+* `claudeCredentialContainment.ts`: ClaudeAdapter drags in Effect platform
+* services, the browser manager and the server config, so a unit test that
+* imports it cannot run in a worktree. This rule decides which account pays for
+* a turn, so it has to stay directly testable.
 */
-/** Credentials the Claude Agent SDK will prefer over the user's OAuth login. */
-const INHERITABLE_ANTHROPIC_CREDENTIAL_KEYS = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
+/** Repoints `.credentials.json` without moving the transcripts. */
+const CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV = "CLAUDE_SECURESTORAGE_CONFIG_DIR";
+/** The one file Claude Code writes into the credential directory. */
+const CLAUDE_CREDENTIAL_FILE_NAME = ".credentials.json";
 /**
-* Routing override the SDK would obey instead of the login's default endpoint.
-* A CMMD cloud runtime exports it to point at the workspace provider-egress
-* proxy; on a PERSONAL-Claude-in-VM runtime that must be dropped so the turn
-* spends the on-box ~/.claude subscription (card 1359 Phase 2). Stripped ONLY
-* when the runtime signals in-VM delivery — otherwise existing behavior (the
-* inherited base URL survives) is preserved exactly.
+* Runtime env var naming the Provider Account this runtime's Claude turns
+* belong to. Nothing in Forge or CMMD sets it, so no runtime names an account
+* and each keeps its one login.
+*
+* It is a bridge that will not get a writer. #3073 settled the key in
+* `docs/adr/provider-account-identity-is-issued-by-cmmd.md`: the directory name
+* comes from the identity CMMD issues and writes on the delivery receipt it
+* signs, and this variable goes away. #3049 makes that change. The credential
+* generation was ruled out as a key: it rotates on every reconnect, and CMMD
+* uses it as the primary account's id, so keying on it would strand every
+* thread pinned to that account on a directory that stops receiving deliveries.
+*
+* Tests reach the `credentialDirectory` parameter on
+* `ClaudeAdapter.buildClaudeQueryEnv` directly.
 */
-const ANTHROPIC_ENDPOINT_OVERRIDE_KEY = "ANTHROPIC_BASE_URL";
+const CLAUDE_PROVIDER_ACCOUNT_IDENTITY_ENV = "FORGE_CLAUDE_PROVIDER_ACCOUNT_IDENTITY";
+/** Directory under the server's base directory that holds one directory per account. */
+const CREDENTIAL_ROOT_DIRECTORY_NAME = "claude-credentials";
+const DEFAULT_CLAUDE_CONFIG_DIRECTORY_NAME = ".claude";
+const MAX_ACCOUNT_IDENTITY_LENGTH = 256;
+const DIRECTORY_NAME_HASH_LENGTH = 32;
 /**
-* Remove inherited Anthropic credentials so the child falls back to the user's
-* personal claude.ai login. Call this ONLY on the path where no base URL
-* resolved; when the adapter has a profile or proxy credential it sets these
-* variables deliberately, and that assignment must win.
+* Directory name for an account. A hash, so no email or display name reaches a
+* filesystem path and no path-illegal character can appear in one either.
+*/
+function claudeCredentialDirectoryName(accountIdentity) {
+	return `account-${(0, node_crypto.createHash)("sha256").update(accountIdentity, "utf8").digest("hex").slice(0, DIRECTORY_NAME_HASH_LENGTH)}`;
+}
+/** The account this runtime's Claude turns belong to, or null while the variable is unset. */
+function resolveClaudeProviderAccountIdentity(env) {
+	const identity = env[CLAUDE_PROVIDER_ACCOUNT_IDENTITY_ENV]?.trim();
+	if (!identity || identity.length > MAX_ACCOUNT_IDENTITY_LENGTH) return null;
+	return identity;
+}
+/**
+* Where per-account credential directories live: `claude-credentials` under the
+* server's base directory, `ServerConfig.baseDir`, which is `FORGE_HOME` or
+* `~/.forge`. A delivery writer gets the same `ServerConfig`, so reader and
+* writer cannot disagree about the root. Always outside `CLAUDE_CONFIG_DIR`, so
+* one of these can never be mistaken for the main credential store, and a stray
+* read of the config directory cannot walk into another account's login.
+*/
+function claudeCredentialDirectoryRoot(env, baseDir) {
+	if (!(0, node_path.isAbsolute)(baseDir)) return null;
+	const root = (0, node_path.resolve)(baseDir, CREDENTIAL_ROOT_DIRECTORY_NAME);
+	const configDirectory = claudeConfigDirectory(env);
+	if (configDirectory && isPathWithinRoot({
+		relative: node_path.relative,
+		isAbsolute: node_path.isAbsolute
+	}, configDirectory, root)) return null;
+	return root;
+}
+/** Absolute credential directory for one account, or null when either half is missing. */
+function resolveClaudeCredentialDirectory(input) {
+	if (!input.accountIdentity) return null;
+	const root = claudeCredentialDirectoryRoot(input.env, input.baseDir);
+	if (!root) return null;
+	return (0, node_path.join)(root, claudeCredentialDirectoryName(input.accountIdentity));
+}
+/**
+* Decide whether this turn may point at a per-account credential directory.
 *
-* `stripEndpointOverride` additionally drops ANTHROPIC_BASE_URL — pass it only on
-* a personal-Claude-in-VM runtime (gated), never by default, so existing turns
-* that rely on an inherited base URL are untouched.
+* The cheap checks run first and the capability probe runs last, so a runtime
+* with no usable credential never spawns the CLI. The probe's error channel is
+* empty, so nothing here catches.
+*
+* A skip is not a fallback onto the default account. With no account the turn
+* runs on the Environment's own login, unchanged. A thread pinned to an account
+* whose credential is missing is refused by name under
+* `docs/adr/provider-account-identity-is-issued-by-cmmd.md`, and #3049 turns
+* `no-usable-credential`, and `capability-not-supported` for a pinned account,
+* into those refusals. Until #3049 nothing names an account, so `no-account` is
+* the only skip a runtime sees.
+*/
+function decideClaudeCredentialDirectory(input) {
+	return require_Schema$1.gen(function* () {
+		if (!input.accountIdentity) return skip("no-account");
+		if (input.env["CLAUDE_SECURESTORAGE_CONFIG_DIR"]?.trim()) return skip("operator-override");
+		const directory = resolveClaudeCredentialDirectory(input);
+		if (!directory) return skip("no-root");
+		if (!holdsUsableCredential(directory)) return skip("no-usable-credential");
+		return (yield* input.probeSupport) === "supported" ? set(directory) : skip("capability-not-supported");
+	});
+}
+/**
+* True when `.credentials.json` parses and carries a non-empty access token.
+*
+* File presence is not readiness. A refused credential is rewritten in place
+* with `accessToken: ""`, so a file that exists can still leave the CLI logged
+* out. Only the token's length is checked. The value is never logged, returned
+* or kept.
 */
-function withoutInheritedAnthropicCredentials(env, options) {
-	const contained = { ...env };
-	for (const key of INHERITABLE_ANTHROPIC_CREDENTIAL_KEYS) delete contained[key];
-	if (options?.stripEndpointOverride) delete contained[ANTHROPIC_ENDPOINT_OVERRIDE_KEY];
-	return contained;
+function holdsUsableCredential(directory) {
+	const file = (0, node_path.join)(directory, CLAUDE_CREDENTIAL_FILE_NAME);
+	try {
+		if (!(0, node_fs.statSync)(file).isFile()) return false;
+		return hasAccessToken(JSON.parse((0, node_fs.readFileSync)(file, "utf8")));
+	} catch {
+		return false;
+	}
+}
+function hasAccessToken(credential) {
+	if (typeof credential !== "object" || credential === null) return false;
+	const oauth = credential.claudeAiOauth;
+	if (typeof oauth !== "object" || oauth === null) return false;
+	const token = oauth.accessToken;
+	return typeof token === "string" && token.length > 0;
+}
+function set(directory) {
+	return {
+		outcome: "set",
+		directory
+	};
+}
+function skip(reason) {
+	return {
+		outcome: "skipped",
+		reason
+	};
+}
+function claudeConfigDirectory(env) {
+	const configured = env.CLAUDE_CONFIG_DIR?.trim();
+	if (configured) return configured;
+	try {
+		return (0, node_path.join)((0, node_os.homedir)(), DEFAULT_CLAUDE_CONFIG_DIRECTORY_NAME);
+	} catch {
+		return null;
+	}
 }
 //#endregion
 //#region src/provider/personalClaudeInVm.ts
@@ -211463,160 +211250,76 @@ function personalClaudeGenerationHash(env = process.env) {
 	}
 }
 //#endregion
-//#region src/provider/claudeCredentialDirectory.ts
+//#region src/provider/claudeCredentialContainment.ts
 /**
-* Per-account credential directories for Claude turns.
-*
-* Claude Code keeps conversation transcripts under
-* `${CLAUDE_CONFIG_DIR}/projects/<cwd-slug>/<sessionId>.jsonl` and its login
-* under `.credentials.json`. `CLAUDE_SECURESTORAGE_CONFIG_DIR` moves only the
-* credential file, so each Provider Account can hold its own login while every
-* session file stays in one place and `--resume` keeps finding its target. See
-* `docs/adr/claude-accounts-split-credentials-not-sessions.md`.
+* Containment for provider credentials inherited by the Claude Agent SDK child.
 *
-* That variable is not documented. Under
-* `docs/adr/unpublished-provider-surface-needs-a-fallback.md` the dependency is
-* only allowed because absence degrades to a named behaviour that already
-* works: one account per Environment, exactly what runs today. This module is
-* the gate that keeps the degrade honest. It sets the variable only when a
-* readable `.credentials.json` is already sitting in the resolved directory,
-* because a missing or empty directory makes the CLI report logged out and a
-* live turn would fail. Nothing writes these directories yet, so every runtime
-* today takes the skip path.
+* Free of Effect services on purpose: ClaudeAdapter pulls in Effect platform
+* services, the browser manager, and the server config, so a unit test that
+* imports it cannot run in a worktree. This rule is cost-critical and must stay
+* directly testable.
 *
-* Pure and dependency-free on purpose, for the same reason as
-* `claudeCredentialContainment.ts`: ClaudeAdapter drags in Effect platform
-* services, the browser manager and the server config, so a unit test that
-* imports it cannot run in a worktree. This rule decides which account pays for
-* a turn, so it has to stay directly testable.
-*/
-/** Repoints `.credentials.json` without moving the transcripts. */
-const CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV = "CLAUDE_SECURESTORAGE_CONFIG_DIR";
-/** The one file Claude Code writes into the credential directory. */
-const CLAUDE_CREDENTIAL_FILE_NAME = ".credentials.json";
-/**
-* Runtime env var naming the Provider Account this runtime's Claude turns
-* belong to.
+* Audit finding S1 (2026-07-25). The Claude Agent SDK reads ANTHROPIC_API_KEY /
+* ANTHROPIC_AUTH_TOKEN from its own environment, and those TAKE PRECEDENCE over
+* the user's claude.ai OAuth login — that precedence is exactly what the
+* adapter relies on to redirect billing at the proxy.
 *
-* NOTHING SETS THIS. It has no writer anywhere in Forge or CMMD, so as shipped
-* the per-account lane can never turn on and every runtime keeps today's single
-* account. The writer waits on issue 3073, which decides which identity keys
-* the directory. That has to be settled first: the credential generation
-* rotates on every re-delivery, so keying on it would give a new directory
-* each time and defeat the point.
+* So on a plain Claude turn (no endpoint profile, no proxy credential), which
+* is supposed to run on the personal subscription, an ANTHROPIC_* key inherited
+* from the server's environment would send the turn straight to
+* api.anthropic.com on a metered account — never reaching
+* /api/provider-egress/*, leaving the fail-closed billing gate inert.
 *
-* It is also not the seam. The seam is the `credentialDirectory` parameter on
-* `ClaudeAdapter.buildClaudeQueryEnv`, which is what tests and callers drive.
-* This variable is one bridge into that parameter, and the delivery step is
-* free to replace it with something better rather than adopt it.
+* Forge Cloud sprites were only incidentally safe (no Anthropic key present on
+* the box). This makes containment an enforced property rather than an
+* assumption about what the deployment environment happens to contain.
 */
-const CLAUDE_PROVIDER_ACCOUNT_IDENTITY_ENV = "FORGE_CLAUDE_PROVIDER_ACCOUNT_IDENTITY";
-/** Operator escape hatch for the directory root, mostly for local debugging. */
-const CLAUDE_CREDENTIAL_ROOT_ENV = "FORGE_CLAUDE_CREDENTIAL_ROOT";
-const CREDENTIAL_ROOT_DIRECTORY_NAME = "claude-credentials";
-const FALLBACK_ROOT_DIRECTORY_NAME = ".forge-claude-credentials";
-const DEFAULT_CLAUDE_CONFIG_DIRECTORY_NAME = ".claude";
-const MAX_ACCOUNT_IDENTITY_LENGTH = 256;
-const DIRECTORY_NAME_HASH_LENGTH = 32;
+/** Credentials the Claude Agent SDK will prefer over the user's OAuth login. */
+const INHERITABLE_ANTHROPIC_CREDENTIAL_KEYS = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
 /**
-* Directory name for an account. A hash, so no email or display name reaches a
-* filesystem path and no path-illegal character can appear in one either.
+* Routing override the SDK would obey instead of the login's default endpoint.
+* A CMMD cloud runtime exports it to point at the workspace provider-egress
+* proxy; on a PERSONAL-Claude-in-VM runtime that must be dropped so the turn
+* spends the on-box ~/.claude subscription (card 1359 Phase 2). Stripped ONLY
+* when the runtime signals in-VM delivery — otherwise existing behavior (the
+* inherited base URL survives) is preserved exactly.
 */
-function claudeCredentialDirectoryName(accountIdentity) {
-	return `account-${(0, node_crypto.createHash)("sha256").update(accountIdentity, "utf8").digest("hex").slice(0, DIRECTORY_NAME_HASH_LENGTH)}`;
-}
-/** The account this runtime's Claude turns belong to, or null on every runtime today. */
-function resolveClaudeProviderAccountIdentity(env) {
-	const identity = env[CLAUDE_PROVIDER_ACCOUNT_IDENTITY_ENV]?.trim();
-	if (!identity || identity.length > MAX_ACCOUNT_IDENTITY_LENGTH) return null;
-	return identity;
-}
+const ANTHROPIC_ENDPOINT_OVERRIDE_KEY = "ANTHROPIC_BASE_URL";
 /**
-* Where per-account credential directories live. Always outside
-* `CLAUDE_CONFIG_DIR`, so one of them can never be mistaken for the main
-* credential store, and so a stray read of the config directory cannot walk
-* into another account's login.
+* Remove inherited Anthropic credentials so the child falls back to the user's
+* personal claude.ai login. Call this ONLY on the path where no base URL
+* resolved; when the adapter has a profile or proxy credential it sets these
+* variables deliberately, and that assignment must win.
+*
+* `stripEndpointOverride` additionally drops ANTHROPIC_BASE_URL — pass it only on
+* a personal-Claude-in-VM runtime (gated), never by default, so existing turns
+* that rely on an inherited base URL are untouched.
 */
-function claudeCredentialDirectoryRoot(env) {
-	const root = credentialRootCandidate(env);
-	if (!root || !(0, node_path.isAbsolute)(root)) return null;
-	return isInside(root, claudeConfigDirectory(env)) ? null : (0, node_path.resolve)(root);
-}
-/** Absolute credential directory for one account, or null when either half is missing. */
-function resolveClaudeCredentialDirectory(input) {
-	if (!input.accountIdentity) return null;
-	const root = claudeCredentialDirectoryRoot(input.env);
-	if (!root) return null;
-	return (0, node_path.join)(root, claudeCredentialDirectoryName(input.accountIdentity));
+function withoutInheritedAnthropicCredentials(env, options) {
+	const contained = { ...env };
+	for (const key of INHERITABLE_ANTHROPIC_CREDENTIAL_KEYS) delete contained[key];
+	if (options?.stripEndpointOverride) delete contained[ANTHROPIC_ENDPOINT_OVERRIDE_KEY];
+	return contained;
 }
 /**
-* Decide whether this turn may point at a per-account credential directory.
+* The environment a Claude child gets when it runs on the personal
+* subscription. Server-only secrets are scrubbed, inherited Anthropic keys are
+* removed so they cannot outrank the login, and the credential directory is set
+* only when one was decided. The turn's personal-subscription branch and the
+* capability probe both build their environment here, so the probe asks about
+* the setup the turn will run with.
 *
-* The cheap checks run first and the capability probe runs last, so a runtime
-* with no delivered credential never spawns the CLI. Any failure is a skip, so
-* the worst outcome is today's behaviour.
-*/
-async function decideClaudeCredentialDirectory(input) {
-	if (!input.accountIdentity) return skip("no-account");
-	if (input.env["CLAUDE_SECURESTORAGE_CONFIG_DIR"]?.trim()) return skip("operator-override");
-	const directory = resolveClaudeCredentialDirectory(input);
-	if (!directory) return skip("no-root");
-	if (!(input.credentialFilePresent ?? hasReadableCredentialFile)(directory)) return skip("no-credential-file");
-	return await probeSupportSafely(input.probeSupport) === "supported" ? {
-		outcome: "set",
-		directory
-	} : skip("capability-not-supported");
-}
-/** True when `.credentials.json` is in the directory and readable right now. */
-function hasReadableCredentialFile(directory) {
-	const file = (0, node_path.join)(directory, CLAUDE_CREDENTIAL_FILE_NAME);
-	try {
-		if (!(0, node_fs.statSync)(file).isFile()) return false;
-		(0, node_fs.accessSync)(file, node_fs.constants.R_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function skip(reason) {
+* The endpoint override goes only when `personalClaudeInVmEnabled` says this
+* runtime is on the personal Claude lane. That check also reads the activation
+* marker CMMD writes on disk (#3081), so a Sprite switched on in place, which
+* has the marker and no env var until it restarts, drops the override too.
+*/
+function claudeSubscriptionChildEnv(processEnv, credentialDirectory) {
 	return {
-		outcome: "skipped",
-		reason
+		...withoutInheritedAnthropicCredentials(scrubForgeProviderChildEnvSecrets(processEnv), { stripEndpointOverride: personalClaudeInVmEnabled(processEnv) }),
+		...credentialDirectory ? { [CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV]: credentialDirectory } : {}
 	};
 }
-/** `inconclusive` is treated as `unsupported`, and so is a probe that throws. */
-async function probeSupportSafely(probeSupport) {
-	try {
-		return await probeSupport();
-	} catch {
-		return "inconclusive";
-	}
-}
-function credentialRootCandidate(env) {
-	const explicit = env[CLAUDE_CREDENTIAL_ROOT_ENV]?.trim();
-	if (explicit) return explicit;
-	const forgeHome = env.FORGE_HOME?.trim();
-	if (forgeHome) return (0, node_path.join)(forgeHome, CREDENTIAL_ROOT_DIRECTORY_NAME);
-	try {
-		return (0, node_path.join)((0, node_os.homedir)(), FALLBACK_ROOT_DIRECTORY_NAME);
-	} catch {
-		return null;
-	}
-}
-function claudeConfigDirectory(env) {
-	const configured = env.CLAUDE_CONFIG_DIR?.trim();
-	if (configured) return configured;
-	try {
-		return (0, node_path.join)((0, node_os.homedir)(), DEFAULT_CLAUDE_CONFIG_DIRECTORY_NAME);
-	} catch {
-		return null;
-	}
-}
-function isInside(candidate, parent) {
-	if (!parent) return false;
-	const step = (0, node_path.relative)((0, node_path.resolve)(parent), (0, node_path.resolve)(candidate));
-	return step === "" || !step.startsWith("..") && !(0, node_path.isAbsolute)(step);
-}
 //#endregion
 //#region src/provider/claudeCredentialDirectoryProbe.ts
 /**
@@ -211629,6 +211332,11 @@ function isInside(candidate, parent) {
 * A runtime with no credential at all is logged out either way and cannot
 * discriminate, which is `inconclusive`, and callers read that as unsupported.
 *
+* An answer only counts for the binary and environment the turn will use. The
+* probe spawns the `binaryPath` the turn hands the SDK, and builds its
+* environment with `claudeSubscriptionChildEnv`, the same builder as the turn's
+* personal-subscription branch.
+*
 * `claude auth status` is a pure read. It sends no prompt and leaves
 * `.credentials.json` byte-identical, so probing spends no subscription usage.
 * It prints JSON on stdout and exits 1 when logged out, so the exit code is not
@@ -211644,38 +211352,62 @@ const VERSION_ARGS = ["--version"];
 * hung or unkillable process costs a few seconds and an `inconclusive`.
 */
 const PROBE_TIMEOUT_MS = 5e3;
+const PROBE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
 const PROBE_DIRECTORY_PREFIX = "forge-claude-capability-";
 const VERSION_PATTERN = /\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/;
 function makeClaudeCredentialDirectoryProbe(deps) {
 	const answers = /* @__PURE__ */ new Map();
-	return { support: async () => {
+	const answer = async () => {
 		const version = await readVersionSafely(deps);
 		if (version === null) return runProbe(deps);
 		const cached = answers.get(version);
 		if (cached) return cached;
 		const pending = runProbe(deps);
 		answers.set(version, pending);
+		const forget = () => {
+			if (answers.get(version) === pending) answers.delete(version);
+		};
+		pending.then((result) => {
+			if (result === "inconclusive") forget();
+		}, forget);
 		return pending;
-	} };
+	};
+	return { support: require_Schema$1.tryPromise(answer).pipe(require_Schema$1.orElseSucceed(() => "inconclusive")) };
 }
 /**
-* One probe per binary path for the life of the process. The probe spawns the
-* CLI twice, and every Claude session start would otherwise pay for it.
+* One probe per binary path for the life of the process. A conclusive answer is
+* cached per binary version, so the two `auth status` spawns run once per path
+* and version. `claude --version` still spawns on every call, which is how an
+* in-place CLI upgrade gets a fresh answer.
 */
 const probesByBinaryPath = /* @__PURE__ */ new Map();
+const INCONCLUSIVE_PROBE = { support: require_Schema$1.succeed("inconclusive") };
+/**
+* The probe for the binary a turn with this `binaryPath` setting runs.
+*
+* `buildClaudeQueryOptions` hands the setting to the SDK as
+* `pathToClaudeCodeExecutable`, and the SDK spawns it as given, so the default
+* `claude` goes through PATH for the probe exactly as for the turn. The SDK
+* picks a bundled build of its own only when the path is empty, and the
+* settings schema turns an empty value into `claude`. Should one arrive empty
+* anyway, the answer is `inconclusive` rather than an answer about another
+* binary.
+*/
 function claudeCredentialDirectoryProbeFor(binaryPath) {
-	const binary = binaryPath?.trim() || "claude";
-	const existing = probesByBinaryPath.get(binary);
+	if (!binaryPath) return INCONCLUSIVE_PROBE;
+	const existing = probesByBinaryPath.get(binaryPath);
 	if (existing) return existing;
-	const probe = makeClaudeCredentialDirectoryProbe(claudeCredentialDirectoryProbeDeps(binary));
-	probesByBinaryPath.set(binary, probe);
+	const probe = makeClaudeCredentialDirectoryProbe(claudeCredentialDirectoryProbeDeps(binaryPath));
+	probesByBinaryPath.set(binaryPath, probe);
 	return probe;
 }
-function claudeCredentialDirectoryProbeDeps(binaryPath) {
+const spawnClaude = (file, args, options) => execFileAsync$3(file, [...args], { ...options });
+function claudeCredentialDirectoryProbeDeps(binaryPath, options = {}) {
+	const run = (args, credentialDirectory) => runClaudeCommand$1(options.execFile ?? spawnClaude, binaryPath, args, claudeSubscriptionChildEnv(options.baseEnv ?? process.env, credentialDirectory));
 	return {
-		runAuthStatus: ({ credentialDirectory }) => runClaudeCommand$1(binaryPath, AUTH_STATUS_ARGS, credentialDirectory),
+		runAuthStatus: ({ credentialDirectory }) => run(AUTH_STATUS_ARGS, credentialDirectory),
 		readBinaryVersion: async () => {
-			const { stdout } = await runClaudeCommand$1(binaryPath, VERSION_ARGS, null);
+			const { stdout } = await run(VERSION_ARGS, null);
 			return VERSION_PATTERN.exec(stdout)?.[0] ?? null;
 		},
 		makeProbeDirectory: () => (0, node_fs_promises.mkdtemp)((0, node_path.join)((0, node_os.tmpdir)(), PROBE_DIRECTORY_PREFIX)),
@@ -211685,6 +211417,7 @@ function claudeCredentialDirectoryProbeDeps(binaryPath) {
 		})
 	};
 }
+/** Rejects when the probe could not tell. `support` turns that into `inconclusive`. */
 async function runProbe(deps) {
 	let probeDirectory = null;
 	try {
@@ -211694,8 +211427,6 @@ async function runProbe(deps) {
 		const redirected = parseLoggedIn(await runBounded(deps, () => deps.runAuthStatus({ credentialDirectory: directory })));
 		if (redirected === false) return "supported";
 		return redirected === true ? "unsupported" : "inconclusive";
-	} catch {
-		return "inconclusive";
 	} finally {
 		if (probeDirectory !== null) await deps.removeProbeDirectory(probeDirectory).catch(() => void 0);
 	}
@@ -211717,15 +211448,15 @@ async function runBounded(deps, operation) {
 	let timer;
 	try {
 		return await Promise.race([operation(), new Promise((_resolve, reject) => {
-			timer = setTimeout(() => reject(/* @__PURE__ */ new Error("claude auth status timed out")), timeoutMs);
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error("claude probe call timed out")), timeoutMs);
 		})]);
 	} finally {
 		if (timer !== void 0) clearTimeout(timer);
 	}
 }
 /** The `loggedIn` field, or null when the output does not carry one. */
-function parseLoggedIn(run) {
-	const parsed = parseJsonObject$1(run.stdout);
+function parseLoggedIn(output) {
+	const parsed = parseJsonObject$1(output.stdout);
 	return typeof parsed?.loggedIn === "boolean" ? parsed.loggedIn : null;
 }
 function parseJsonObject$1(output) {
@@ -211740,27 +211471,18 @@ function parseJsonObject$1(output) {
 		return null;
 	}
 }
-async function runClaudeCommand$1(binaryPath, args, credentialDirectory) {
+async function runClaudeCommand$1(execFileImpl, binaryPath, args, env) {
 	try {
-		const { stdout } = await execFileAsync$3(binaryPath, [...args], {
-			env: {
-				...process.env,
-				...credentialDirectory ? { [CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV]: credentialDirectory } : {}
-			},
-			maxBuffer: 1024 * 1024,
+		const { stdout } = await execFileImpl(binaryPath, args, {
+			env,
+			maxBuffer: PROBE_OUTPUT_LIMIT_BYTES,
 			timeout: PROBE_TIMEOUT_MS
 		});
-		return {
-			stdout,
-			exitCode: 0
-		};
+		return { stdout };
 	} catch (cause) {
 		const failure = cause;
 		if (typeof failure.stdout !== "string") throw cause;
-		return {
-			stdout: failure.stdout,
-			exitCode: typeof failure.code === "number" ? failure.code : null
-		};
+		return { stdout: failure.stdout };
 	}
 }
 //#endregion
@@ -213277,10 +212999,12 @@ function claudeForgeAttributionPrompt() {
 * `credentialDirectory` points this turn at one Provider Account's own
 * `.credentials.json` without moving the transcripts, which is what lets an
 * account switch keep `--resume` working
-* (`docs/adr/claude-accounts-split-credentials-not-sessions.md`). It is null on
-* every runtime today: `decideClaudeCredentialDirectory` only hands back a
-* directory that already holds a readable credential file, and nothing writes
-* one yet, so the environment stays byte-for-byte what it was.
+* (`docs/adr/claude-accounts-split-credentials-not-sessions.md`). It stays null
+* until #3049 gives the directories a writer, keyed on the account identity on
+* the delivery receipt CMMD signs. `decideClaudeCredentialDirectory` only hands
+* back a directory that already holds a usable credential, and while none
+* exists the environment is byte-for-byte what it would be without this
+* parameter.
 *
 * It applies to the personal-subscription branch below and to nothing else. On
 * the profile / proxy branch the credential file is not what authenticates the
@@ -213290,10 +213014,7 @@ function claudeForgeAttributionPrompt() {
 function buildClaudeQueryEnv(baseProcessEnv, endpointProfile, claudeSettings, providerProxyCredential, credentialDirectory) {
 	const baseEnv = scrubForgeProviderChildEnvSecrets(baseProcessEnv);
 	const effectiveBaseUrl = resolveClaudeQueryBaseUrl(endpointProfile, claudeSettings, providerProxyCredential);
-	if (!effectiveBaseUrl) return {
-		...withoutInheritedAnthropicCredentials(baseEnv, { stripEndpointOverride: personalClaudeInVmEnabled(baseProcessEnv) }),
-		...credentialDirectory ? { [CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV]: credentialDirectory } : {}
-	};
+	if (!effectiveBaseUrl) return claudeSubscriptionChildEnv(baseProcessEnv, credentialDirectory);
 	const effectiveApiKey = resolveClaudeQueryApiKey(endpointProfile, claudeSettings, providerProxyCredential?.token ?? null);
 	return {
 		...baseEnv,
@@ -215562,11 +215283,17 @@ const makeClaudeAdapter = require_Schema$1.fn("makeClaudeAdapter")(function* (op
 		})));
 		const claudeSettings = serverSettings.providers.claudeAgent;
 		const claudeBinaryPath = claudeSettings.binaryPath;
-		const claudeCredentialDirectory = yield* require_Schema$1.tryPromise(() => decideClaudeCredentialDirectory({
+		const credentialDirectoryDecision = yield* decideClaudeCredentialDirectory({
 			env: process.env,
+			baseDir: serverConfig.baseDir,
 			accountIdentity: resolveClaudeProviderAccountIdentity(process.env),
-			probeSupport: () => claudeCredentialDirectoryProbeFor(claudeBinaryPath).support()
-		})).pipe(require_Schema$1.map((decision) => decision.outcome === "set" ? decision.directory : null), require_Schema$1.orElseSucceed(() => null));
+			probeSupport: claudeCredentialDirectoryProbeFor(claudeBinaryPath).support
+		});
+		if (credentialDirectoryDecision.outcome === "skipped") {
+			const skipLine = `Claude credential directory skipped: ${credentialDirectoryDecision.reason}`;
+			yield* credentialDirectoryDecision.reason === "no-account" ? require_Schema$1.logDebug(skipLine) : require_Schema$1.logWarning(skipLine);
+		}
+		const claudeCredentialDirectory = credentialDirectoryDecision.outcome === "set" ? credentialDirectoryDecision.directory : null;
 		const modelConfig = resolveClaudeSessionModelConfig(input.modelSelection, claudeSettings.endpointProfiles);
 		const providerProxyCredential = yield* issueClaudeProviderProxyCredential(modelConfig.endpointProfile, modelConfig.modelSlug ?? modelConfig.effectiveApiModelId ?? "unknown", threadId);
 		const permissionMode = permissionModeForRuntimeMode(input.runtimeMode);
@@ -293213,6 +292940,382 @@ const makeWorkspaceFileSystem = require_Schema$1.gen(function* () {
 });
 const WorkspaceFileSystemLive = require_Schema$1.effect(WorkspaceFileSystem, makeWorkspaceFileSystem);
 //#endregion
+//#region src/workspace/Layers/WorkspaceBulkTransfer.ts
+const TRANSFER_TTL_MS = 1440 * 60 * 1e3;
+const TRANSFER_LOCK_STRIPE_COUNT = 64;
+function transferError(input) {
+	return new BulkTransferError({
+		code: input.code,
+		message: input.message,
+		transferId: input.transferId ?? null,
+		retryable: input.retryable ?? false,
+		...input.cause === void 0 ? {} : { cause: input.cause }
+	});
+}
+function mapFailure(operation, transferId) {
+	return (cause) => require_Schema$1.is(BulkTransferError)(cause) ? cause : transferError({
+		code: "io_error",
+		message: `Workspace bulk transfer failed during ${operation}.`,
+		...transferId === void 0 ? {} : { transferId },
+		retryable: true,
+		cause
+	});
+}
+function transferLockStripe(transferId) {
+	let hash = 2166136261;
+	for (let index = 0; index < transferId.length; index += 1) hash = Math.imul(hash ^ transferId.charCodeAt(index), 16777619);
+	return (hash >>> 0) % TRANSFER_LOCK_STRIPE_COUNT;
+}
+const makeWorkspaceBulkTransfer = (options = {}) => require_Schema$1.gen(function* () {
+	const fileSystem = yield* require_Path.FileSystem;
+	const path = yield* require_Path.Path;
+	const sql = yield* require_SqlError.SqlClient;
+	const workspacePaths = yield* WorkspacePaths;
+	const workspaceEntries = yield* WorkspaceEntries;
+	const fault = options.fault ?? (() => require_Schema$1.void_);
+	const transferLocks = yield* require_Schema$1.forEach(Array.from({ length: TRANSFER_LOCK_STRIPE_COUNT }), () => require_Path.make$5(1));
+	const withTransferLock = (transferId, effect) => transferLocks[transferLockStripe(transferId)].withPermit(effect);
+	const findTransfer = (transferId) => sql`
+        SELECT transfer_id AS "transferId", workspace_root AS "workspaceRoot",
+          relative_path AS "relativePath", target_path AS "targetPath", temp_path AS "tempPath",
+          total_bytes AS "totalBytes", whole_sha256 AS "wholeSha256",
+          next_offset AS "nextOffset", state, expires_at AS "expiresAt"
+        FROM workspace_bulk_transfers WHERE transfer_id = ${transferId} LIMIT 1
+      `.pipe(require_Schema$1.map((rows) => rows[0] ?? null));
+	const requireTransfer = (transferId) => findTransfer(transferId).pipe(require_Schema$1.flatMap((row) => row === null ? require_Schema$1.fail(transferError({
+		code: "transfer_not_found",
+		message: "Bulk transfer does not exist.",
+		transferId
+	})) : require_Schema$1.succeed(row)));
+	const requireOpenTransfer = (transferId) => requireTransfer(transferId).pipe(require_Schema$1.flatMap((row) => {
+		if (row.state === "cancelled") return require_Schema$1.fail(transferError({
+			code: "transfer_cancelled",
+			message: "Bulk transfer was cancelled.",
+			transferId
+		}));
+		if (row.state === "expired" || Date.parse(row.expiresAt) <= Date.now()) return require_Schema$1.fail(transferError({
+			code: "transfer_expired",
+			message: "Bulk transfer expired.",
+			transferId
+		}));
+		return require_Schema$1.succeed(row);
+	}));
+	const resolveTarget = require_Schema$1.fn("WorkspaceBulkTransfer.resolveTarget")(function* (input) {
+		const workspaceRoot = yield* workspacePaths.normalizeWorkspaceRoot(input.cwd);
+		const resolved = yield* workspacePaths.resolveRelativePathWithinRoot({
+			workspaceRoot,
+			relativePath: input.relativePath
+		});
+		const canonicalRoot = yield* fileSystem.realPath(workspaceRoot);
+		const parentSegments = resolved.relativePath.split("/").slice(0, -1);
+		let canonicalParent = canonicalRoot;
+		for (const segment of parentSegments) {
+			const candidate = path.join(canonicalParent, segment);
+			const canonicalCandidate = yield* fileSystem.realPath(candidate).pipe(require_Schema$1.catch_(() => input.createParent ? fileSystem.makeDirectory(candidate).pipe(require_Schema$1.flatMap(() => fileSystem.realPath(candidate))) : fileSystem.realPath(candidate)));
+			if (!isPathWithinRoot(path, canonicalRoot, canonicalCandidate)) return yield* transferError({
+				code: "symlink_escape",
+				message: "Workspace file path resolves outside the project root."
+			});
+			canonicalParent = canonicalCandidate;
+		}
+		const targetPath = path.join(canonicalParent, path.basename(resolved.relativePath));
+		const targetRealPath = yield* fileSystem.realPath(targetPath).pipe(require_Schema$1.catch_(() => require_Schema$1.succeed(null)));
+		if (targetRealPath !== null && !isPathWithinRoot(path, canonicalRoot, targetRealPath)) return yield* transferError({
+			code: "symlink_escape",
+			message: "Workspace file target resolves outside the project root."
+		});
+		return {
+			workspaceRoot: canonicalRoot,
+			relativePath: resolved.relativePath,
+			targetPath,
+			canonicalParent
+		};
+	});
+	const readFile = (input) => require_Path.unwrap(require_Schema$1.gen(function* () {
+		const target = yield* resolveTarget({
+			...input,
+			createParent: false
+		});
+		const info = yield* fileSystem.stat(target.targetPath);
+		const maxBytes = input.maxBytes ?? 16777216;
+		if (Number(info.size) > maxBytes) return yield* transferError({
+			code: "size_limit_exceeded",
+			message: `Workspace file exceeds the ${maxBytes}-byte read limit.`
+		});
+		const bytes = yield* fileSystem.readFile(target.targetPath);
+		const transfer = yield* require_Schema$1.promise(() => chunkBulkTransfer(bytes));
+		const transferId = transfer.chunks[0]?.transferId ?? crypto.randomUUID().replaceAll("-", "_");
+		return require_Path.fromIterable([
+			{
+				kind: "started",
+				transferId,
+				totalBytes: transfer.totalBytes,
+				sha256: transfer.sha256
+			},
+			...transfer.chunks.map((chunk) => ({
+				...chunk,
+				transferId
+			})),
+			{
+				kind: "completed",
+				transferId,
+				totalBytes: transfer.totalBytes,
+				sha256: transfer.sha256
+			}
+		]);
+	}).pipe(require_Schema$1.mapError(mapFailure("read file"))));
+	const resumeWrite = require_Schema$1.fn("WorkspaceBulkTransfer.resumeWrite")(function* (input, existing) {
+		const target = yield* resolveTarget({
+			...input,
+			createParent: true
+		});
+		if (!(existing.workspaceRoot === target.workspaceRoot && existing.relativePath === target.relativePath && existing.totalBytes === input.totalBytes && existing.wholeSha256 === input.sha256)) return yield* transferError({
+			code: "transfer_identity_conflict",
+			message: "Bulk transfer ID is already bound to different content or a different path.",
+			transferId: input.transferId
+		});
+		if (existing.state === "cancelled") return yield* transferError({
+			code: "transfer_cancelled",
+			message: "Bulk transfer was cancelled.",
+			transferId: input.transferId
+		});
+		if (existing.state === "expired" || Date.parse(existing.expiresAt) <= Date.now()) return yield* transferError({
+			code: "transfer_expired",
+			message: "Bulk transfer expired.",
+			transferId: input.transferId
+		});
+		return {
+			transferId: input.transferId,
+			nextOffset: existing.nextOffset,
+			state: existing.state === "completed" ? "completed" : "open"
+		};
+	});
+	const createWrite = require_Schema$1.fn("WorkspaceBulkTransfer.createWrite")(function* (input) {
+		const target = yield* resolveTarget({
+			...input,
+			createParent: true
+		}).pipe(require_Schema$1.mapError((cause) => require_Schema$1.is(WorkspacePathOutsideRootError)(cause) ? transferError({
+			code: "path_outside_workspace",
+			message: "Workspace file path must stay within the project root.",
+			transferId: input.transferId,
+			cause
+		}) : cause));
+		const tempPath = path.join(target.canonicalParent, `.forge-transfer-${input.transferId}.part`);
+		yield* require_Schema$1.scoped(fileSystem.open(tempPath, {
+			flag: "wx",
+			mode: 384
+		}).pipe(require_Schema$1.flatMap((file) => file.sync), require_Schema$1.catch_(() => fileSystem.stat(tempPath).pipe(require_Schema$1.flatMap((stat) => Number(stat.size) === 0 ? require_Schema$1.void_ : require_Schema$1.fail(transferError({
+			code: "transfer_identity_conflict",
+			message: "Bulk transfer temporary path already contains data.",
+			transferId: input.transferId
+		})))))));
+		const now = /* @__PURE__ */ new Date();
+		yield* sql`
+        INSERT INTO workspace_bulk_transfers (
+          transfer_id, workspace_root, relative_path, target_path, temp_path, total_bytes,
+          whole_sha256, next_offset, state, expires_at, created_at, updated_at
+        ) VALUES (
+          ${input.transferId}, ${target.workspaceRoot}, ${target.relativePath}, ${target.targetPath},
+          ${tempPath}, ${input.totalBytes}, ${input.sha256}, 0, 'open',
+          ${new Date(now.getTime() + TRANSFER_TTL_MS).toISOString()}, ${now.toISOString()},
+          ${now.toISOString()}
+        )
+      `;
+		return {
+			transferId: input.transferId,
+			nextOffset: 0,
+			state: "open"
+		};
+	});
+	const beginWriteEffect = require_Schema$1.fn("WorkspaceBulkTransfer.beginWrite")(function* (input) {
+		const existing = yield* findTransfer(input.transferId);
+		return yield* existing === null ? createWrite(input) : resumeWrite(input, existing);
+	});
+	const beginWrite = (input) => withTransferLock(input.transferId, beginWriteEffect(input)).pipe(require_Schema$1.mapError(mapFailure("begin write", input.transferId)));
+	const acceptRetriedChunk = require_Schema$1.fn("WorkspaceBulkTransfer.acceptRetriedChunk")(function* (input, row) {
+		const accepted = (yield* sql`
+          SELECT chunk_offset AS "chunkOffset", chunk_bytes AS "chunkBytes",
+            chunk_sha256 AS "chunkSha256"
+          FROM workspace_bulk_transfer_chunks
+          WHERE transfer_id = ${input.transferId} AND chunk_offset = ${input.offset}
+          LIMIT 1
+        `)[0];
+		if (!(accepted !== void 0 && accepted.chunkBytes === input.bytes && accepted.chunkSha256 === input.sha256)) return yield* transferError({
+			code: "integrity_mismatch",
+			message: "Retried bulk transfer chunk differs from the accepted chunk.",
+			transferId: input.transferId
+		});
+		return {
+			transferId: input.transferId,
+			nextOffset: row.nextOffset,
+			duplicate: true
+		};
+	});
+	const validateChunkRange = require_Schema$1.fn("WorkspaceBulkTransfer.validateChunkRange")(function* (input, row, byteLength) {
+		if (input.offset !== row.nextOffset) return yield* transferError({
+			code: "offset_mismatch",
+			message: `Expected chunk offset ${row.nextOffset}, received ${input.offset}.`,
+			transferId: input.transferId,
+			retryable: true
+		});
+		const nextOffset = input.offset + byteLength;
+		if (nextOffset > row.totalBytes) return yield* transferError({
+			code: "size_limit_exceeded",
+			message: "Bulk transfer chunk exceeds the declared total byte count.",
+			transferId: input.transferId
+		});
+		return nextOffset;
+	});
+	const reconcileChunkBytes = require_Schema$1.fn("WorkspaceBulkTransfer.reconcileChunkBytes")(function* (input, row, bytes, nextOffset) {
+		const tempInfo = yield* fileSystem.stat(row.tempPath);
+		if (Number(tempInfo.size) > row.nextOffset) {
+			if (Number(tempInfo.size) !== nextOffset) return yield* transferError({
+				code: "integrity_mismatch",
+				message: "Bulk transfer temporary file cannot be reconciled with the next chunk.",
+				transferId: input.transferId
+			});
+			const recovered = (yield* fileSystem.readFile(row.tempPath)).slice(input.offset, nextOffset);
+			if ((yield* require_Schema$1.promise(() => sha256Hex(recovered))) !== input.sha256) return yield* transferError({
+				code: "integrity_mismatch",
+				message: "Bulk transfer temporary bytes differ from the retried chunk.",
+				transferId: input.transferId
+			});
+			return;
+		}
+		yield* fault("before-byte-write");
+		yield* require_Schema$1.scoped(fileSystem.open(row.tempPath, { flag: "r+" }).pipe(require_Schema$1.flatMap((file) => file.seek(input.offset, "start").pipe(require_Schema$1.flatMap(() => file.writeAll(bytes)), require_Schema$1.flatMap(() => file.sync)))));
+		yield* fault("after-byte-write-before-metadata");
+	});
+	const persistAcceptedChunk = require_Schema$1.fn("WorkspaceBulkTransfer.persistAcceptedChunk")(function* (input, nextOffset) {
+		const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		yield* sql.withTransaction(sql`
+          INSERT INTO workspace_bulk_transfer_chunks (
+            transfer_id, chunk_offset, chunk_bytes, chunk_sha256
+          ) VALUES (${input.transferId}, ${input.offset}, ${input.bytes}, ${input.sha256})
+          ON CONFLICT DO NOTHING
+        `.pipe(require_Schema$1.flatMap(() => sql`
+            UPDATE workspace_bulk_transfers
+            SET next_offset = ${nextOffset}, updated_at = ${updatedAt}
+            WHERE transfer_id = ${input.transferId} AND next_offset = ${input.offset} AND state = 'open'
+          `)));
+		yield* fault("after-metadata-advance");
+	});
+	const writeChunkEffect = require_Schema$1.fn("WorkspaceBulkTransfer.writeChunk")(function* (input) {
+		const bytes = yield* require_Schema$1.promise(() => verifyBulkTransferChunk({
+			...input,
+			kind: "chunk"
+		}));
+		const row = yield* requireOpenTransfer(input.transferId);
+		if (row.state === "completed") return yield* transferError({
+			code: "offset_mismatch",
+			message: "Bulk transfer is already complete.",
+			transferId: input.transferId
+		});
+		if (input.offset < row.nextOffset) return yield* acceptRetriedChunk(input, row);
+		const nextOffset = yield* validateChunkRange(input, row, bytes.byteLength);
+		yield* reconcileChunkBytes(input, row, bytes, nextOffset);
+		yield* persistAcceptedChunk(input, nextOffset);
+		return {
+			transferId: input.transferId,
+			nextOffset,
+			duplicate: false
+		};
+	});
+	const writeChunk = (input) => withTransferLock(input.transferId, writeChunkEffect(input)).pipe(require_Schema$1.mapError(mapFailure("write chunk", input.transferId)));
+	const commitWriteEffect = require_Schema$1.fn("WorkspaceBulkTransfer.commitWrite")(function* (input) {
+		const row = yield* requireOpenTransfer(input.transferId);
+		if (row.state === "completed") return {
+			transferId: row.transferId,
+			relativePath: row.relativePath,
+			totalBytes: row.totalBytes,
+			sha256: row.wholeSha256
+		};
+		if (row.nextOffset !== row.totalBytes) return yield* transferError({
+			code: "offset_mismatch",
+			message: `Bulk transfer is incomplete at byte ${row.nextOffset} of ${row.totalBytes}.`,
+			transferId: row.transferId,
+			retryable: true
+		});
+		if ((yield* resolveTarget({
+			cwd: row.workspaceRoot,
+			relativePath: row.relativePath,
+			createParent: false
+		})).targetPath !== row.targetPath) return yield* transferError({
+			code: "symlink_escape",
+			message: "Workspace file destination changed during transfer.",
+			transferId: row.transferId
+		});
+		const tempInfo = yield* fileSystem.stat(row.tempPath).pipe(require_Schema$1.catch_(() => require_Schema$1.succeed(null)));
+		const candidatePath = tempInfo === null ? row.targetPath : row.tempPath;
+		const candidate = yield* fileSystem.readFile(candidatePath);
+		if (candidate.byteLength !== row.totalBytes || (yield* require_Schema$1.promise(() => sha256Hex(candidate))) !== row.wholeSha256) return yield* transferError({
+			code: "integrity_mismatch",
+			message: "Bulk transfer payload does not match its declared size and digest.",
+			transferId: row.transferId
+		});
+		if (tempInfo !== null) {
+			yield* fileSystem.rename(row.tempPath, row.targetPath);
+			yield* fault("after-atomic-rename");
+		}
+		yield* sql`
+        UPDATE workspace_bulk_transfers SET state = 'completed', updated_at = ${(/* @__PURE__ */ new Date()).toISOString()}
+        WHERE transfer_id = ${row.transferId}
+      `;
+		yield* workspaceEntries.invalidate(row.workspaceRoot);
+		return {
+			transferId: row.transferId,
+			relativePath: row.relativePath,
+			totalBytes: row.totalBytes,
+			sha256: row.wholeSha256
+		};
+	});
+	const commitWrite = (input) => withTransferLock(input.transferId, commitWriteEffect(input)).pipe(require_Schema$1.mapError(mapFailure("commit write", input.transferId)));
+	const cancelWriteEffect = require_Schema$1.fn("WorkspaceBulkTransfer.cancelWrite")(function* (input) {
+		const row = yield* requireTransfer(input.transferId);
+		if (row.state !== "completed") {
+			yield* fileSystem.remove(row.tempPath, { force: true });
+			yield* sql`
+          UPDATE workspace_bulk_transfers SET state = 'cancelled', updated_at = ${(/* @__PURE__ */ new Date()).toISOString()}
+          WHERE transfer_id = ${input.transferId}
+        `;
+		}
+		return {
+			transferId: input.transferId,
+			state: row.state === "completed" ? "completed" : "cancelled"
+		};
+	});
+	const cancelWrite = (input) => withTransferLock(input.transferId, cancelWriteEffect(input)).pipe(require_Schema$1.mapError(mapFailure("cancel write", input.transferId)));
+	const cleanupExpiredEffect = require_Schema$1.fn("WorkspaceBulkTransfer.cleanupExpired")(function* () {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const rows = yield* sql`
+        SELECT transfer_id AS "transferId", temp_path AS "tempPath"
+        FROM workspace_bulk_transfers WHERE state = 'open' AND expires_at <= ${now}
+      `;
+		let expiredCount = 0;
+		for (const row of rows) if (yield* withTransferLock(row.transferId, require_Schema$1.gen(function* () {
+			const current = yield* findTransfer(row.transferId);
+			if (current === null || current.state !== "open" || Date.parse(current.expiresAt) > Date.parse(now)) return false;
+			yield* fileSystem.remove(current.tempPath, { force: true });
+			yield* sql`
+              UPDATE workspace_bulk_transfers SET state = 'expired', updated_at = ${now}
+              WHERE transfer_id = ${row.transferId} AND state = 'open' AND expires_at <= ${now}
+            `;
+			return true;
+		}))) expiredCount += 1;
+		return expiredCount;
+	});
+	const cleanupExpired = () => cleanupExpiredEffect().pipe(require_Schema$1.mapError(mapFailure("expiry cleanup")));
+	return {
+		readFile,
+		beginWrite,
+		writeChunk,
+		commitWrite,
+		cancelWrite,
+		cleanupExpired
+	};
+});
+const WorkspaceBulkTransferLive = require_Schema$1.effect(WorkspaceBulkTransfer, makeWorkspaceBulkTransfer());
+//#endregion
 //#region src/workspace/Layers/WorkspacePaths.ts
 function toPosixRelativePath(input) {
 	return input.replaceAll("\\", "/");
@@ -294825,7 +294928,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "8cafbb87b6204b98e93c1c69253c1c590af5f8a1";
+	return "b79da36c868d5629c76dcec88a3326634a02c2c7";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;