@cmmd-center/forge 0.10.16 → 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);
 /**
@@ -16544,7 +16544,7 @@ function makeNetServiceShape(createServer = node_net.createServer) {
 }
 //#endregion
 //#region ../../packages/shared/src/releaseInfo.generated.ts
-const FORGE_RELEASE_VERSION = "0.10.6";
+const FORGE_RELEASE_VERSION = "0.11.0";
 //#endregion
 //#region ../../packages/shared/src/hostProcess.ts
 /**
@@ -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",
@@ -40972,7 +40995,7 @@ function splitPath(filename) {
 	const parts = splitPathRe.exec(truncated);
 	return parts ? parts.slice(1) : [];
 }
-function dirname$6(path) {
+function dirname$7(path) {
 	const result = splitPath(path);
 	const root = result[0] || "";
 	let dir = result[1];
@@ -58287,7 +58310,7 @@ function getSpotlightConfig(optionsSpotlight) {
 function normalizeWindowsPath(path) {
 	return path.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname$6(process.argv[1]) : process.cwd(), isWindows = node_path.sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname$7(process.argv[1]) : process.cwd(), isWindows = node_path.sep === "\\") {
 	const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
 	return (filename) => {
 		if (!filename) return;
@@ -65775,7 +65798,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.10.16";
+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);
@@ -92992,7 +93030,7 @@ var AnalyticsService = class AnalyticsService extends require_Schema$1.Service()
 var RuntimeReplication = class extends require_Schema$1.Service()("forge/runtimeReplication/Services/RuntimeReplication") {};
 //#endregion
 //#region src/runtimeDrain/forgeGitCommit.ts
-const execFileAsync$6 = (0, node_util.promisify)(node_child_process.execFile);
+const execFileAsync$7 = (0, node_util.promisify)(node_child_process.execFile);
 const FORGE_GIT_COMMIT_PATTERN = /^[0-9a-f]{7,40}$/i;
 /**
 * Resolve the commit this forge checkout actually booted from, so the
@@ -93016,7 +93054,7 @@ const FORGE_GIT_COMMIT_PATTERN = /^[0-9a-f]{7,40}$/i;
 * it yet.
 */
 let cached$1 = null;
-async function resolveForgeGitCommit(execImpl = (command, args) => execFileAsync$6(command, [...args], { timeout: 5e3 })) {
+async function resolveForgeGitCommit(execImpl = (command, args) => execFileAsync$7(command, [...args], { timeout: 5e3 })) {
 	if (cached$1 !== null) return cached$1;
 	try {
 		const { stdout } = await execImpl("git", ["rev-parse", "HEAD"]);
@@ -94979,7 +95017,7 @@ function mightCarryUsage(line, provider) {
 * a line at a time, so the usual cause is a tail the scan opened mid-write,
 * and a count that keeps growing is a file the scan can no longer read.
 */
-function parseJsonObject$1(line, diagnostics) {
+function parseJsonObject$2(line, diagnostics) {
 	let parsed;
 	try {
 		parsed = JSON.parse(line);
@@ -95009,7 +95047,7 @@ function claudeDedupeKey(messageId, requestId) {
 	return `${messageId ?? ""}:${requestId ?? ""}`;
 }
 function parseClaudeLine(line, diagnostics) {
-	const record = parseJsonObject$1(line, diagnostics);
+	const record = parseJsonObject$2(line, diagnostics);
 	if (record === null) return null;
 	if (record["type"] !== "assistant") return null;
 	const messageRecord = objectAt(record, "message");
@@ -95156,7 +95194,7 @@ function parseCodexTokenCount(record, payloadRecord, state) {
 	};
 }
 function parseCodexLine(line, state, diagnostics) {
-	const record = parseJsonObject$1(line, diagnostics);
+	const record = parseJsonObject$2(line, diagnostics);
 	if (record === null) return null;
 	const payloadRecord = objectAt(record, "payload");
 	if (payloadRecord === null) return null;
@@ -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
 /**
@@ -99537,7 +99188,7 @@ function buildDiscoveryResult(probes) {
 }
 //#endregion
 //#region src/sourceControl/probe.ts
-const execFileAsync$5 = (0, node_util.promisify)(node_child_process.execFile);
+const execFileAsync$6 = (0, node_util.promisify)(node_child_process.execFile);
 /**
 * How long a machine's toolchain answer stays good for.
 *
@@ -99548,7 +99199,7 @@ const execFileAsync$5 = (0, node_util.promisify)(node_child_process.execFile);
 */
 const DISCOVERY_TTL = "5 minutes";
 /** Probes time out because `gh auth status` reaches the network on a cold keyring. */
-const PROBE_TIMEOUT_MS = 5e3;
+const PROBE_TIMEOUT_MS$1 = 5e3;
 /**
 * Runs one probe. A tool that is absent, fails, or hangs is reported the same
 * way — `null`, meaning "no answer" — because the discovery result only
@@ -99560,7 +99211,7 @@ const PROBE_TIMEOUT_MS = 5e3;
 */
 const probe = (command, args) => require_Schema$1.promise(async () => {
 	try {
-		const { stdout, stderr } = await execFileAsync$5(command, [...args], { timeout: PROBE_TIMEOUT_MS });
+		const { stdout, stderr } = await execFileAsync$6(command, [...args], { timeout: PROBE_TIMEOUT_MS$1 });
 		const output = `${stdout}\n${stderr}`.trim();
 		return { output: output.length === 0 ? null : output };
 	} catch (cause) {
@@ -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
@@ -101099,6 +100773,7 @@ const CLAUDE_IDENTITY_KEYS = new Set([
 	"provider",
 	"credentialGenerationId"
 ]);
+const CLAUDE_IDENTITY_OPTIONAL_KEYS = new Set(["providerAccountIdentity"]);
 function isRecord$13(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -101123,6 +100798,10 @@ function daysInMonth$1(year, month) {
 function hasExactKeys$2(value, keys) {
 	return Object.keys(value).every((key) => keys.has(key)) && Object.keys(value).length === keys.size;
 }
+function hasAllowedKeys(value, required, optional) {
+	const keys = Object.keys(value);
+	return keys.every((key) => required.has(key) || optional.has(key)) && [...required].every((key) => keys.includes(key));
+}
 function parseDeliveryIdentity(value, provider) {
 	if (!isRecord$13(value)) return null;
 	if (provider === "openai") return parseCodexDeliveryIdentity(value);
@@ -101137,12 +100816,25 @@ function parseCodexDeliveryIdentity(value) {
 		providerAccountIdentity: value.providerAccountIdentity
 	};
 }
+/**
+* Absent means the writer does not name the Provider Account yet, and the
+* identity keeps the shape it has always had. Present but malformed means the
+* identity is not the one CMMD signed, so it is refused the same way a
+* malformed Codex account identity is.
+*/
+function claudeAccountFields(value) {
+	if (value === void 0) return {};
+	if (typeof value !== "string" || !PROVIDER_ACCOUNT_IDENTITY$2.test(value)) return null;
+	return { providerAccountIdentity: value };
+}
 function parseClaudeDeliveryIdentity(value) {
-	if (!hasExactKeys$2(value, CLAUDE_IDENTITY_KEYS) || value.kind !== "credential_generation" || value.provider !== "claude" || typeof value.credentialGenerationId !== "string" || !UUID.test(value.credentialGenerationId)) return null;
+	const account = claudeAccountFields(value.providerAccountIdentity);
+	if (!account || !hasAllowedKeys(value, CLAUDE_IDENTITY_KEYS, CLAUDE_IDENTITY_OPTIONAL_KEYS) || value.kind !== "credential_generation" || value.provider !== "claude" || typeof value.credentialGenerationId !== "string" || !UUID.test(value.credentialGenerationId)) return null;
 	return {
 		kind: "credential_generation",
 		provider: "claude",
-		credentialGenerationId: value.credentialGenerationId
+		credentialGenerationId: value.credentialGenerationId,
+		...account
 	};
 }
 function parseProviderRuntimeDeliveryReceipt(value, expected) {
@@ -101181,10 +100873,49 @@ function readProviderDeliveryBinding(value) {
 		identity
 	};
 }
+/** The Provider Account a delivery identity names, or null when it names none. */
+function providerDeliveryAccount(identity) {
+	return identity.kind === "provider_account" ? identity.providerAccountIdentity : identity.providerAccountIdentity ?? null;
+}
+function sameDeliveredCredential(left, right) {
+	if (left.kind === "provider_account" && right.kind === "provider_account") return left.providerAccountIdentity === right.providerAccountIdentity;
+	return left.kind === "credential_generation" && right.kind === "credential_generation" && left.credentialGenerationId === right.credentialGenerationId;
+}
+/**
+* Names how one thread's delivery binding moved, which is the question the
+* delivery layer could not answer while Claude's identity carried no account.
+*
+* `account_switch` needs both sides to name an account, the accounts to differ,
+* the delivered credential to change with them, and the runtime, machine and
+* epoch to hold. A switch changes the account and the generation together, so
+* two accounts on one generation would be two accounts sharing a credential,
+* and a switch that also moved the epoch changed more than the identity. Both
+* are `unknown`.
+*
+* The same delivered credential is `unchanged` whether or not either side names
+* an account, so a binding recorded before CMMD named the account still resumes
+* against the credential it ran on. A changed credential where either side
+* names no account is `unknown` rather than guessed at, which keeps an
+* account-less binding compared on exactly the fields it was compared on before.
+*
+* `providerDeliveryBindingsEqual` asks only whether the answer is `unchanged`.
+* `permitsProviderAccountTransition` in `provider/providerAccountTransition.ts`
+* asks whether it is `account_switch`, and is the Codex resume gate's rule
+* today. #3055 wires the Claude resume gate onto it.
+*/
+function classifyProviderDeliveryBindingChange(prior, current) {
+	if (prior.runtimeId !== current.runtimeId || prior.machineId !== current.machineId || prior.identity.kind !== current.identity.kind || prior.identity.provider !== current.identity.provider) return "unknown";
+	const sameEpoch = prior.credentialEpoch === current.credentialEpoch;
+	const sameCredential = sameDeliveredCredential(prior.identity, current.identity);
+	const priorAccount = providerDeliveryAccount(prior.identity);
+	const currentAccount = providerDeliveryAccount(current.identity);
+	if (priorAccount !== null && currentAccount !== null && priorAccount !== currentAccount) return sameEpoch && !sameCredential ? "account_switch" : "unknown";
+	if (sameEpoch && sameCredential) return "unchanged";
+	if (priorAccount === null || currentAccount === null) return "unknown";
+	return "credential_refresh";
+}
 function providerDeliveryBindingsEqual(left, right) {
-	if (left.runtimeId !== right.runtimeId || left.machineId !== right.machineId || left.credentialEpoch !== right.credentialEpoch || left.identity.kind !== right.identity.kind || left.identity.provider !== right.identity.provider) return false;
-	if (left.identity.kind === "provider_account" && right.identity.kind === "provider_account") return left.identity.providerAccountIdentity === right.identity.providerAccountIdentity;
-	return left.identity.kind === "credential_generation" && right.identity.kind === "credential_generation" && left.identity.credentialGenerationId === right.identity.credentialGenerationId;
+	return classifyProviderDeliveryBindingChange(left, right) === "unchanged";
 }
 //#endregion
 //#region src/provider/claudeReadinessReason.ts
@@ -101463,8 +101194,128 @@ const runClaudeLogout = (runtime) => new Promise((resolve, reject) => {
 	});
 });
 //#endregion
+//#region src/usage/providerRateLimits.ts
+/**
+* `new Date(ms).toISOString()` throws past +-8.64e15 ms, so a `resetsAt` past
+* the same bound in seconds is refused rather than allowed to throw inside a
+* decoder whose whole job is to fail closed.
+*/
+const MAX_RESETS_AT_SECONDS = 864e10;
+/**
+* One reset time in unix seconds as an ISO string, or null.
+*
+* Both mappers read reset times through this, so a malformed `resetsAt`
+* yields the null that means "this observation said nothing" instead of a
+* RangeError thrown out of a decoder the ingestion layer runs on every Claude
+* rate-limit event.
+*/
+function resetsAtIso(resetsAt) {
+	if (!Number.isFinite(resetsAt) || resetsAt <= 0 || resetsAt > MAX_RESETS_AT_SECONDS) return null;
+	return (/* @__PURE__ */ new Date(resetsAt * 1e3)).toISOString();
+}
+/**
+* The SDK only ever reports ONE window per event. Only `five_hour` and
+* `seven_day` map to the two windows the Usage page shows; the
+* per-model/overage variants (seven_day_opus, overage, ...) are ignored here
+* on purpose rather than silently overwriting the plain 7-day figure.
+*/
+function mapClaudeRateLimitInfo(info) {
+	if (typeof info.utilization !== "number" || typeof info.resetsAt !== "number" || !info.status) return null;
+	const kind = info.rateLimitType === "five_hour" ? "fiveHour" : info.rateLimitType === "seven_day" ? "sevenDay" : null;
+	if (!kind) return null;
+	const resetsAt = resetsAtIso(info.resetsAt);
+	if (resetsAt === null) return null;
+	return {
+		kind,
+		window: {
+			usedPercent: Math.round(info.utilization * 100),
+			resetsAt,
+			status: info.status
+		}
+	};
+}
+/**
+* The one place a used-percent becomes a status. `unifiedWindows` carries no
+* per-window status of its own, and the `/usage` parser derives one the same
+* way, so both Claude usage sources agree on where "warning" starts.
+*/
+function usageStatus(usedPercent) {
+	if (usedPercent >= 100) return "rejected";
+	return usedPercent >= 80 ? "allowed_warning" : "allowed";
+}
+/**
+* One untyped `utilization` as a whole percent, or nothing. The [0, 100] bound
+* matches `claudeUsageCli.ts`'s own bound on the `/usage` text, which in turn
+* matches CMMD's parser.
+*/
+function readUsedPercent(utilization) {
+	if (typeof utilization !== "number" || !Number.isFinite(utilization)) return null;
+	const usedPercent = Math.round(utilization * 100);
+	return usedPercent < 0 || usedPercent > 100 ? null : usedPercent;
+}
+/**
+* Reads one `unifiedWindows` entry, or nothing. Every field is checked because
+* none of them are typed: a non-object entry, a utilization that is not a
+* finite number in [0, 1], or a reset time that is not a positive finite
+* number of seconds all mean "this observation said nothing about this
+* window".
+*/
+function readUnifiedWindow(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const { utilization, resetsAt } = raw;
+	const usedPercent = readUsedPercent(utilization);
+	if (usedPercent === null) return null;
+	if (typeof resetsAt !== "number") return null;
+	const resetsAtIsoValue = resetsAtIso(resetsAt);
+	if (resetsAtIsoValue === null) return null;
+	return {
+		usedPercent,
+		resetsAt: resetsAtIsoValue,
+		status: usageStatus(usedPercent)
+	};
+}
+/**
+* Reads the `unifiedWindows` sub-object of `rate_limit_info` into the two
+* rolling windows. The SDK rebuilds that sub-object on every turn from the
+* `anthropic-ratelimit-unified-{5h,7d}-utilization` and `-reset` response
+* headers.
+*
+* The top-level `rateLimitType` names one window per event and carries a
+* utilization only for `five_hour` or `seven_day`. This sub-object reports
+* every window it knows on every observation, which makes it the only
+* SDK-side source that can feed the Usage card without waking a Sprite and
+* delivering a credential.
+*
+* Its `seven_day_overage_included` window is skipped. `/usage` names each model
+* row after the display name Anthropic's usage API gives that model, one row
+* per allowlisted model, and the `7d_oi` header behind this window is one
+* aggregate that carries no name. Any name given to it here would be a guess
+* that could disagree with the rows the probe writes, so model rows come from
+* the probe alone.
+*
+* It is also undocumented internal surface stripped from the SDK's exported
+* types, so this decoder fails closed everywhere. It returns null when the
+* sub-object is absent or is not a plain object, and null when neither window
+* in it survives validation. A window that fails validation is reported as
+* null, and an unrecognized key is skipped, never fatal. A caller that gets
+* null has learned nothing and must not publish, because a partial write could
+* overwrite a good `/usage` reading with a guess.
+*/
+function mapClaudeUnifiedWindows(info) {
+	const raw = info.unifiedWindows;
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const windows = raw;
+	const fiveHour = readUnifiedWindow(windows.five_hour);
+	const sevenDay = readUnifiedWindow(windows.seven_day);
+	if (!fiveHour && !sevenDay) return null;
+	return {
+		fiveHour,
+		sevenDay
+	};
+}
+//#endregion
 //#region src/usage/claudeUsageCli.ts
-const execFileAsync$4 = (0, node_util.promisify)(node_child_process.execFile);
+const execFileAsync$5 = (0, node_util.promisify)(node_child_process.execFile);
 const USAGE_ARGS = [
 	"--safe-mode",
 	"--no-session-persistence",
@@ -101488,7 +101339,7 @@ const MONTH_BY_NAME = {
 	Dec: 11
 };
 async function runClaudeUsageCommand(binaryPath, args, claudeConfigDir) {
-	const { stdout } = await execFileAsync$4(binaryPath, [...args], {
+	const { stdout } = await execFileAsync$5(binaryPath, [...args], {
 		env: {
 			...process.env,
 			TZ: "UTC",
@@ -101563,10 +101414,6 @@ function parseResetAt(value, now) {
 	});
 	return resetAt === null || Number.isNaN(resetAt.getTime()) ? null : resetAt.toISOString();
 }
-function usageStatus(usedPercent) {
-	if (usedPercent >= 100) return "rejected";
-	return usedPercent >= 80 ? "allowed_warning" : "allowed";
-}
 function parseUsageLine(output, label, now) {
 	const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 	const match = new RegExp(`^${escapedLabel}: (\\d+(?:\\.\\d+)?)% used(?: · resets (.+))?$`, "m").exec(output);
@@ -101635,6 +101482,29 @@ async function fetchClaudeUsageViaOfficialClient(input) {
 	};
 }
 //#endregion
+//#region src/usage/claudeUsageTelemetryRequest.ts
+/** The owner-session route for a Claude usage reading. */
+const CLAUDE_USAGE_TELEMETRY_PATH = "/api/forge/context/providers/usage/claude/telemetry";
+/**
+* Builds the body for either lane.
+*
+* `modelWindows` is sent only when the reading carries it. CMMD keeps the
+* stored model rows when the key is absent, so a reading that cannot name
+* model rows the way `/usage` does leaves the key out.
+*/
+function claudeUsageTelemetryBody(input) {
+	return {
+		providerAccountId: input.attribution.providerAccountId,
+		credentialGenerationId: input.attribution.credentialGenerationId,
+		...input.account,
+		source: input.source,
+		fiveHour: input.windows.fiveHour,
+		sevenDay: input.windows.sevenDay,
+		...input.windows.modelWindows !== void 0 ? { modelWindows: input.windows.modelWindows } : {},
+		observedAt: input.observedAt
+	};
+}
+//#endregion
 //#region src/cmmd/syncClaudeCredential.ts
 /**
 * Card 1359 (harvest path A, Claude) — publish a personal Claude subscription
@@ -101650,7 +101520,6 @@ async function fetchClaudeUsageViaOfficialClient(input) {
 const USER_CLAUDE_CREDENTIAL_PATH = "/api/forge/context/providers/claude/credential";
 const USER_CLAUDE_LINKED_ACCOUNT_PATH = "/api/forge/context/providers/claude/accounts";
 const AUTH_RUNTIME_CLAUDE_CREDENTIAL_PATH = "/api/forge/context/auth-runtime-claude-credential";
-const USER_CLAUDE_USAGE_PATH = "/api/forge/context/providers/usage/claude/telemetry";
 const AUTH_RUNTIME_CLAUDE_USAGE_PATH = "/api/forge/context/auth-runtime-claude-credential/usage";
 /** Path to the local Claude credentials.json, mirroring Claude Code's resolution. */
 function resolveLocalClaudeCredentialPath(homePath) {
@@ -101679,7 +101548,7 @@ function resolveLocalClaudeCredentialPath(homePath) {
 * it reaches — this is the first gate and the only one near the user, who is
 * standing in front of the sign-in and can simply try again.
 *
-* The floor is ONE token, not both, and that distinction is load-bearing: an
+* The floor is ONE token, not both, because an
 * expired or blank access token beside a live refresh token is the normal
 * resting state of a rotating login, which Claude Code refreshes silently on
 * use. Demanding both would reject a perfectly recoverable credential and break
@@ -101757,10 +101626,10 @@ function extractClaudeAccountMetadata(credentialJson) {
 		return {};
 	}
 }
-const execFileAsync$3 = (0, node_util.promisify)(node_child_process.execFile);
+const execFileAsync$4 = (0, node_util.promisify)(node_child_process.execFile);
 async function loadClaudeAccountMetadataFromCli(homePath) {
 	try {
-		const { stdout } = await execFileAsync$3(resolveClaudeBinaryPath("claude"), ["auth", "status"], {
+		const { stdout } = await execFileAsync$4(resolveClaudeBinaryPath("claude"), ["auth", "status"], {
 			timeout: 2e4,
 			maxBuffer: 1024 * 1024,
 			env: {
@@ -101856,18 +101725,20 @@ async function publishClaudeUsageAfterSync(input) {
 			binaryPath: resolveClaudeBinaryPath("claude"),
 			...input.homePath ? { claudeConfigDir: input.homePath } : {}
 		});
-		await publishUsageBody(input.auth.jwt, input.auth.path === AUTH_RUNTIME_CLAUDE_CREDENTIAL_PATH ? AUTH_RUNTIME_CLAUDE_USAGE_PATH : USER_CLAUDE_USAGE_PATH, {
-			providerAccountId: input.providerAccountId,
-			credentialGenerationId: input.credentialGenerationId,
-			accountEmail: input.accountEmail,
-			accountDisplayName: input.accountDisplayName,
-			planType: input.planType,
+		await publishUsageBody(input.auth.jwt, input.auth.path === AUTH_RUNTIME_CLAUDE_CREDENTIAL_PATH ? AUTH_RUNTIME_CLAUDE_USAGE_PATH : CLAUDE_USAGE_TELEMETRY_PATH, claudeUsageTelemetryBody({
+			attribution: {
+				providerAccountId: input.providerAccountId,
+				credentialGenerationId: input.credentialGenerationId
+			},
+			account: {
+				accountEmail: input.accountEmail,
+				accountDisplayName: input.accountDisplayName,
+				planType: input.planType
+			},
 			source: "active_poll",
-			fiveHour: usage.fiveHour,
-			sevenDay: usage.sevenDay,
-			modelWindows: usage.modelWindows,
+			windows: usage,
 			observedAt: (/* @__PURE__ */ new Date()).toISOString()
-		});
+		}));
 		return null;
 	} catch (cause) {
 		return { cause };
@@ -150195,7 +150066,7 @@ function issueCmmdLocalUserProviderEgressCredential(input) {
 	});
 }
 //#endregion
-//#region src/provider/codexAccountTransition.ts
+//#region src/provider/providerAccountTransition.ts
 function explicitProviderAccountTransition(fromAccountId, toAccountId) {
 	if (!fromAccountId || !toAccountId || fromAccountId === toAccountId) return void 0;
 	return {
@@ -150203,13 +150074,20 @@ function explicitProviderAccountTransition(fromAccountId, toAccountId) {
 		toAccountId
 	};
 }
-function permitsCodexAccountTransition(input) {
+/**
+* Whether a thread may move from `prior` to `current` because the person asked
+* for another Provider Account. The credential broker authorizes the selected
+* account, so only the identity may change, which is what `account_switch`
+* means.
+*
+* Nothing in the rule is specific to a provider, but the Codex resume gate in
+* `codexAppServerManager.ts` is its only caller. The Claude half is parked
+* until #3055 wires the Claude resume gate onto it.
+*/
+function permitsProviderAccountTransition(input) {
 	const { transition, requestedAccountId, prior, current } = input;
-	if (!transition || transition.fromAccountId === transition.toAccountId || transition.toAccountId !== requestedAccountId || prior.identity.kind !== "provider_account" || current.identity.kind !== "provider_account" || prior.identity.provider !== "codex" || current.identity.provider !== "codex") return false;
-	return providerDeliveryBindingsEqual({
-		...prior,
-		identity: current.identity
-	}, current);
+	if (!transition || transition.fromAccountId === transition.toAccountId || transition.toAccountId !== requestedAccountId) return false;
+	return classifyProviderDeliveryBindingChange(prior, current) === "account_switch";
 }
 //#endregion
 //#region src/providerAuth/codexLocalAccountIdentity.ts
@@ -150709,7 +150587,7 @@ var CodexAppServerManager = class extends node_events.EventEmitter {
 				const rawPriorDeliveryBinding = input.resumeCursor.providerDeliveryBinding;
 				const priorDeliveryBinding = readProviderDeliveryBinding(rawPriorDeliveryBinding);
 				if (rawPriorDeliveryBinding !== void 0 && rawPriorDeliveryBinding !== null && !priorDeliveryBinding) throw new Error("Existing Codex history cannot resume because its persisted delivered provider account binding is unreadable.");
-				if (priorDeliveryBinding && !providerDeliveryBindingsEqual(priorDeliveryBinding, currentDeliveryBinding) && !permitsCodexAccountTransition({
+				if (priorDeliveryBinding && !providerDeliveryBindingsEqual(priorDeliveryBinding, currentDeliveryBinding) && !permitsProviderAccountTransition({
 					transition: input.accountTransition,
 					requestedAccountId: input.providerAccountId,
 					prior: priorDeliveryBinding,
@@ -176783,7 +176661,7 @@ function em(e) {
 		BO ??= new Int32Array(new SharedArrayBuffer(4)), Atomics.wait(BO, 0, 0, SY);
 	}
 }
-function rm$5(e, t) {
+function rm$6(e, t) {
 	let n = (0, path.resolve)(t).toLowerCase(), r = (0, path.dirname)((0, path.resolve)(e)).toLowerCase();
 	if (r === n || KO(r, n) || qO(r, n, "lexical")) return !0;
 	let o = em(t)?.toLowerCase();
@@ -189633,7 +189511,7 @@ function Wo() {
 }
 function sle(e) {
 	let t = process.cwd();
-	return e.filter((n) => !rm$5(n, t));
+	return e.filter((n) => !rm$6(n, t));
 }
 function ZU(e) {
 	let t = Bun.which(e);
@@ -211140,11 +211018,243 @@ function hasConfiguredApexCredential(profiles) {
 	}));
 }
 //#endregion
+//#region src/provider/claudeCredentialDirectory.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`.
+*
+* 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.
+*
+* 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.
+*
+* 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.
+*/
+/** 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. 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 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;
+/**
+* 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.
+*
+* 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 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
+/**
+* CMMD writes this marker when it activates a personal Claude subscription
+* inside a running sprite. Activation always happens after boot, so a
+* boot-time env var alone cannot reflect it (FOR-36249).
+*
+* CMMD names the file in the Service env (FORGE_PERSONAL_CLAUDE_MARKER_PATH).
+* Without that, the marker sits directly under FORGE_HOME, which is the same
+* guest home CMMD derives every sprite path from. A server with neither has no
+* sprite home to look in, and a desktop never has a marker, so it reads none.
+*/
+const PERSONAL_CLAUDE_IN_VM_MARKER_NAME = ".forge-personal-claude-in-vm";
+const PERSONAL_CLAUDE_GENERATION_FILE_NAME = ".forge-personal-claude-generation";
+function markerPath(env) {
+	if (env.FORGE_PERSONAL_CLAUDE_MARKER_PATH) return env.FORGE_PERSONAL_CLAUDE_MARKER_PATH;
+	if (env.FORGE_HOME) return (0, node_path.join)(env.FORGE_HOME, PERSONAL_CLAUDE_IN_VM_MARKER_NAME);
+	return null;
+}
+/**
+* True when this runtime should offer the personal Claude subscription lane.
+*
+* Accepts either signal: the boot-time env var (backward compatible) or the
+* activation marker on disk. Reading the marker at call time lets the provider
+* catalog and the per-turn readiness guard self-heal once CMMD delivers,
+* without a sprite reboot. Callers still verify the credential is non-empty
+* before treating it as usable; this only decides whether the lane is active.
+*/
+function personalClaudeInVmEnabled(env = process.env) {
+	if (env.FORGE_PERSONAL_CLAUDE_IN_VM === "true") return true;
+	const marker = markerPath(env);
+	if (!marker) return false;
+	try {
+		return (0, node_fs.existsSync)(marker);
+	} catch {
+		return false;
+	}
+}
+/** Exported at boot. This is the restart proof CMMD waits on, so it must never read the file. */
+function bootExportedPersonalClaudeGenerationHash(env = process.env) {
+	return env.FORGE_PERSONAL_CLAUDE_GENERATION_HASH?.trim() ?? "";
+}
+/**
+* The sha256 of the Claude credential generation this runtime holds, or "" when
+* it holds none. The readiness guard compares it with the generation CMMD
+* applied. The restart proof must not use it; it uses the boot-exported hash.
+*
+* The boot preload exports FORGE_PERSONAL_CLAUDE_GENERATION_HASH, but only when
+* the marker already exists at boot. Activation in place writes the generation
+* file and touches the marker without setting any env, so an empty variable
+* falls back to that file, hashed the way the preload hashes it. CMMD puts the
+* file beside the marker in the guest home and names no path for it. A marker
+* with no generation file is a legacy runtime, and gets no hash here either.
+*/
+function personalClaudeGenerationHash(env = process.env) {
+	const exported = bootExportedPersonalClaudeGenerationHash(env);
+	if (exported) return exported;
+	const marker = markerPath(env);
+	if (!marker) return "";
+	try {
+		if (!(0, node_fs.existsSync)(marker)) return "";
+		const generation = (0, node_fs.readFileSync)((0, node_path.join)((0, node_path.dirname)(marker), PERSONAL_CLAUDE_GENERATION_FILE_NAME), "utf8").trim();
+		return generation ? (0, node_crypto.createHash)("sha256").update(generation).digest("hex") : "";
+	} catch {
+		return "";
+	}
+}
+//#endregion
 //#region src/provider/claudeCredentialContainment.ts
 /**
 * Containment for provider credentials inherited by the Claude Agent SDK child.
 *
-* Pure and dependency-free on purpose: ClaudeAdapter pulls in Effect platform
+* 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.
@@ -211191,6 +211301,190 @@ function withoutInheritedAnthropicCredentials(env, options) {
 	if (options?.stripEndpointOverride) delete contained[ANTHROPIC_ENDPOINT_OVERRIDE_KEY];
 	return contained;
 }
+/**
+* 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 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 {
+		...withoutInheritedAnthropicCredentials(scrubForgeProviderChildEnvSecrets(processEnv), { stripEndpointOverride: personalClaudeInVmEnabled(processEnv) }),
+		...credentialDirectory ? { [CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV]: credentialDirectory } : {}
+	};
+}
+//#endregion
+//#region src/provider/claudeCredentialDirectoryProbe.ts
+/**
+* Capability probe for `CLAUDE_SECURESTORAGE_CONFIG_DIR`.
+*
+* The variable is unpublished, so a runtime is asked rather than assumed to
+* honour it (`docs/adr/unpublished-provider-surface-needs-a-fallback.md`). The
+* question the probe can actually answer: point the variable at an empty
+* directory and a runtime that honours it flips from logged in to logged out.
+* 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
+* a failure signal and the `loggedIn` field is what gets read.
+*/
+const execFileAsync$3 = (0, node_util.promisify)(node_child_process.execFile);
+const AUTH_STATUS_ARGS = ["auth", "status"];
+const VERSION_ARGS = ["--version"];
+/**
+* The probe sits in front of a turn, so a provider process that never answers
+* must not hold that turn open. `execFile` kills the child at this bound, and
+* `runBounded` gives up on it at the same bound whatever the deps do, so a
+* 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();
+	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. 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) {
+	if (!binaryPath) return INCONCLUSIVE_PROBE;
+	const existing = probesByBinaryPath.get(binaryPath);
+	if (existing) return existing;
+	const probe = makeClaudeCredentialDirectoryProbe(claudeCredentialDirectoryProbeDeps(binaryPath));
+	probesByBinaryPath.set(binaryPath, probe);
+	return probe;
+}
+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 }) => run(AUTH_STATUS_ARGS, credentialDirectory),
+		readBinaryVersion: async () => {
+			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)),
+		removeProbeDirectory: (directory) => (0, node_fs_promises.rm)(directory, {
+			recursive: true,
+			force: true
+		})
+	};
+}
+/** Rejects when the probe could not tell. `support` turns that into `inconclusive`. */
+async function runProbe(deps) {
+	let probeDirectory = null;
+	try {
+		if (parseLoggedIn(await runBounded(deps, () => deps.runAuthStatus({ credentialDirectory: null }))) !== true) return "inconclusive";
+		probeDirectory = await deps.makeProbeDirectory();
+		const directory = probeDirectory;
+		const redirected = parseLoggedIn(await runBounded(deps, () => deps.runAuthStatus({ credentialDirectory: directory })));
+		if (redirected === false) return "supported";
+		return redirected === true ? "unsupported" : "inconclusive";
+	} finally {
+		if (probeDirectory !== null) await deps.removeProbeDirectory(probeDirectory).catch(() => void 0);
+	}
+}
+async function readVersionSafely(deps) {
+	try {
+		return await runBounded(deps, () => deps.readBinaryVersion());
+	} catch {
+		return null;
+	}
+}
+/**
+* Give up on a call that outlives the bound. The underlying promise is left to
+* settle on its own; the real deps hand `execFile` the same bound, so its child
+* is already being killed by the time this rejects.
+*/
+async function runBounded(deps, operation) {
+	const timeoutMs = deps.timeoutMs ?? PROBE_TIMEOUT_MS;
+	let timer;
+	try {
+		return await Promise.race([operation(), new Promise((_resolve, reject) => {
+			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(output) {
+	const parsed = parseJsonObject$1(output.stdout);
+	return typeof parsed?.loggedIn === "boolean" ? parsed.loggedIn : null;
+}
+function parseJsonObject$1(output) {
+	const trimmed = output.trim();
+	const start = trimmed.indexOf("{");
+	const end = trimmed.lastIndexOf("}");
+	if (start === -1 || end <= start) return null;
+	try {
+		const parsed = JSON.parse(trimmed.slice(start, end + 1));
+		return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+async function runClaudeCommand$1(execFileImpl, binaryPath, args, env) {
+	try {
+		const { stdout } = await execFileImpl(binaryPath, args, {
+			env,
+			maxBuffer: PROBE_OUTPUT_LIMIT_BYTES,
+			timeout: PROBE_TIMEOUT_MS
+		});
+		return { stdout };
+	} catch (cause) {
+		const failure = cause;
+		if (typeof failure.stdout !== "string") throw cause;
+		return { stdout: failure.stdout };
+	}
+}
 //#endregion
 //#region src/provider/makeManagedServerProvider.ts
 const makeManagedServerProvider = require_Schema$1.fn("makeManagedServerProvider")(function* (input) {
@@ -211283,43 +211577,6 @@ const makeProviderAuthProvenance = (input) => {
 	};
 };
 //#endregion
-//#region src/provider/personalClaudeInVm.ts
-/**
-* CMMD writes this marker when it activates a personal Claude subscription
-* inside a running sprite. Activation always happens after boot, so a
-* boot-time env var alone cannot reflect it (FOR-36249).
-*
-* CMMD names the file in the Service env (FORGE_PERSONAL_CLAUDE_MARKER_PATH).
-* Without that, the marker sits directly under FORGE_HOME, which is the same
-* guest home CMMD derives every sprite path from. A server with neither has no
-* sprite home to look in, and a desktop never has a marker, so it reads none.
-*/
-const PERSONAL_CLAUDE_IN_VM_MARKER_NAME = ".forge-personal-claude-in-vm";
-function markerPath(env) {
-	if (env.FORGE_PERSONAL_CLAUDE_MARKER_PATH) return env.FORGE_PERSONAL_CLAUDE_MARKER_PATH;
-	if (env.FORGE_HOME) return (0, node_path.join)(env.FORGE_HOME, PERSONAL_CLAUDE_IN_VM_MARKER_NAME);
-	return null;
-}
-/**
-* True when this runtime should offer the personal Claude subscription lane.
-*
-* Accepts either signal: the boot-time env var (backward compatible) or the
-* activation marker on disk. Reading the marker at call time lets the provider
-* catalog and the per-turn readiness guard self-heal once CMMD delivers,
-* without a sprite reboot. Callers still verify the credential is non-empty
-* before treating it as usable; this only decides whether the lane is active.
-*/
-function personalClaudeInVmEnabled(env = process.env) {
-	if (env.FORGE_PERSONAL_CLAUDE_IN_VM === "true") return true;
-	const marker = markerPath(env);
-	if (!marker) return false;
-	try {
-		return (0, node_fs.existsSync)(marker);
-	} catch {
-		return false;
-	}
-}
-//#endregion
 //#region src/provider/Layers/ClaudeProvider.ts
 function endpointProfileDisplayNames(settings) {
 	return Object.fromEntries(settings.endpointProfiles.filter((p) => p.displayName).map((p) => [p.slug, p.displayName]));
@@ -212738,10 +212995,26 @@ function claudeForgeAttributionPrompt() {
 	const attribution = resolveAgentAttribution();
 	return `When creating git commits, do NOT add any "Claude" or "Anthropic" co-author trailers. Use exactly:\n  ${attribution.coauthorTrailer}\n\nWhen creating GitHub pull request descriptions, do NOT add any "🤖 Generated with [Claude Code]" footer. Use exactly:\n  ${attribution.prFooter}`;
 }
-function buildClaudeQueryEnv(baseProcessEnv, endpointProfile, claudeSettings, providerProxyCredential) {
+/**
+* `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 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
+* turn, an API key is, so pointing the variable there would add a second source
+* of truth that a later reader has to rule out.
+*/
+function buildClaudeQueryEnv(baseProcessEnv, endpointProfile, claudeSettings, providerProxyCredential, credentialDirectory) {
 	const baseEnv = scrubForgeProviderChildEnvSecrets(baseProcessEnv);
 	const effectiveBaseUrl = resolveClaudeQueryBaseUrl(endpointProfile, claudeSettings, providerProxyCredential);
-	if (!effectiveBaseUrl) return withoutInheritedAnthropicCredentials(baseEnv, { stripEndpointOverride: baseProcessEnv.FORGE_PERSONAL_CLAUDE_IN_VM === "true" });
+	if (!effectiveBaseUrl) return claudeSubscriptionChildEnv(baseProcessEnv, credentialDirectory);
 	const effectiveApiKey = resolveClaudeQueryApiKey(endpointProfile, claudeSettings, providerProxyCredential?.token ?? null);
 	return {
 		...baseEnv,
@@ -215010,6 +215283,17 @@ const makeClaudeAdapter = require_Schema$1.fn("makeClaudeAdapter")(function* (op
 		})));
 		const claudeSettings = serverSettings.providers.claudeAgent;
 		const claudeBinaryPath = claudeSettings.binaryPath;
+		const credentialDirectoryDecision = yield* decideClaudeCredentialDirectory({
+			env: process.env,
+			baseDir: serverConfig.baseDir,
+			accountIdentity: resolveClaudeProviderAccountIdentity(process.env),
+			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);
@@ -215034,7 +215318,7 @@ const makeClaudeAdapter = require_Schema$1.fn("makeClaudeAdapter")(function* (op
 			existingResumeSessionId,
 			newSessionId,
 			canUseTool,
-			env: buildClaudeQueryEnv(process.env, modelConfig.endpointProfile, claudeSettings, providerProxyCredential),
+			env: buildClaudeQueryEnv(process.env, modelConfig.endpointProfile, claudeSettings, providerProxyCredential, claudeCredentialDirectory),
 			browserManager,
 			threadId,
 			browserToolEnvironmentId,
@@ -230138,7 +230422,7 @@ function claudeReadinessGuardEffect(config, dependencies, resolved, input) {
 	});
 }
 function requiresNativeClaudeReadiness(config, provider) {
-	return provider === "claudeAgent" && config.forgeCmmdRuntimeMode === true && process.env.FORGE_PERSONAL_CLAUDE_IN_VM === "true";
+	return provider === "claudeAgent" && config.forgeCmmdRuntimeMode === true && personalClaudeInVmEnabled();
 }
 function resolveGuardAuthority(config, readSessionId, input) {
 	const runtimeId = config.forgeCmmdRuntimeId?.trim();
@@ -230150,7 +230434,7 @@ function resolveGuardAuthority(config, readSessionId, input) {
 		runtimeId,
 		machineId,
 		credentialEpoch,
-		localGenerationHash: process.env.FORGE_PERSONAL_CLAUDE_GENERATION_HASH?.trim() ?? "",
+		localGenerationHash: personalClaudeGenerationHash(),
 		sessionId
 	};
 }
@@ -287365,25 +287649,124 @@ const makeRuntimeDrainReporter = require_Schema$1.gen(function* () {
 var RuntimeDrainReporter = class extends require_Schema$1.Service()("forge/runtimeDrain/RuntimeDrainReporter") {};
 const RuntimeDrainReporterLive = require_Schema$1.effect(RuntimeDrainReporter, makeRuntimeDrainReporter);
 //#endregion
-//#region src/usage/providerRateLimits.ts
-/**
-* The SDK only ever reports ONE window per event. Only `five_hour` and
-* `seven_day` map to the two windows the Usage page shows; the
-* per-model/overage variants (seven_day_opus, overage, ...) are ignored here
-* on purpose rather than silently overwriting the plain 7-day figure.
-*/
-function mapClaudeRateLimitInfo(info) {
-	if (typeof info.utilization !== "number" || typeof info.resetsAt !== "number" || !info.status) return null;
-	const kind = info.rateLimitType === "five_hour" ? "fiveHour" : info.rateLimitType === "seven_day" ? "sevenDay" : null;
-	if (!kind) return null;
-	return {
-		kind,
-		window: {
-			usedPercent: Math.round(info.utilization * 100),
-			resetsAt: (/* @__PURE__ */ new Date(info.resetsAt * 1e3)).toISOString(),
-			status: info.status
-		}
-	};
+//#region src/usage/Services/ClaudeUsageTelemetry.ts
+/**
+* Claude usage the SDK reports on every turn, published as passive telemetry.
+*
+* Every Claude turn carries a `rate_limit_event` whose `unifiedWindows`
+* sub-object holds the two rolling windows the Usage card renders. Reading it
+* costs nothing: no `claude` process, no credential delivery, no woken sprite.
+*
+* This module is the whole publish lane behind one call. `observe` takes what
+* an observation knows and returns void. Whether the floor admits it, which
+* credential generation it ran on, whether the value is new, and whether CMMD
+* accepted it are all decided here, so the ingestion layer stays a decoder and
+* a hand-off. Nothing decided here can fail a turn, and no admitted
+* observation outlives `CLAUDE_USAGE_TELEMETRY_PUBLISH_TIMEOUT_MS`.
+*
+* The `/usage` probe in `syncClaudeCredential.ts` is a separate lane that
+* publishes `source: "active_poll"`. This one publishes
+* `source: "passive_sdk_telemetry"`, and both lanes build their body with
+* `claudeUsageTelemetryBody`.
+*
+* @module ClaudeUsageTelemetry
+*/
+var ClaudeUsageTelemetry = class extends require_Schema$1.Service()("forge/usage/Services/ClaudeUsageTelemetry") {};
+/**
+* The longest one admitted observation may take, from the credential
+* generation lookup through the CMMD credential and the POST, before it is
+* abandoned and counted as failed. Ingestion does not wait on it, so this
+* bounds how long a slow lookup or a slow CMMD keeps a fiber alive, not how
+* long a turn waits. Together with the floor it caps how many observations for
+* one account can be in flight at once.
+*/
+const CLAUDE_USAGE_TELEMETRY_PUBLISH_TIMEOUT_MS = 1e4;
+/** How many accounts, and how many pairs, the observer remembers before evicting the oldest. */
+const MAX_TRACKED_KEYS = 32;
+/**
+* Why one publish did not land. Every reason is the same to `observe`, which
+* logs it and moves on, so the type exists to name the lane rather than to be
+* matched on.
+*/
+var ClaudeUsageTelemetryPublishError = class extends require_Schema$1.TaggedError("ClaudeUsageTelemetryPublishError") {};
+function pairKey(attribution) {
+	return `${attribution.providerAccountId}\u0000${attribution.credentialGenerationId}`;
+}
+function windowFingerprint(value) {
+	return value === null ? "-" : `${value.usedPercent}|${value.resetsAt}|${value.status}`;
+}
+/**
+* A value fingerprint built field by field rather than by `JSON.stringify` on
+* the whole object, so the comparison does not depend on key insertion order
+* and cannot silently start ignoring a field a future mapper adds without a
+* matching change here.
+*/
+function windowsFingerprint(windows) {
+	return `${windowFingerprint(windows.fiveHour)}/${windowFingerprint(windows.sevenDay)}`;
+}
+/**
+* Stores `value` as the newest entry for `key` and evicts the oldest entry past
+* the cap. Map iteration is insertion-ordered, so the first key is the one
+* touched longest ago. An idle account or a rotated credential generation
+* rarely comes back, so evicting it costs at most one early lookup or one
+* redundant publish.
+*/
+function remember(map, key, value) {
+	map.delete(key);
+	map.set(key, value);
+	if (map.size > MAX_TRACKED_KEYS) {
+		const oldest = map.keys().next();
+		if (!oldest.done) map.delete(oldest.value);
+	}
+}
+/**
+* Builds the observer over injected dependencies. The HTTP call and the clock
+* both arrive from outside, so a test drives the whole policy without a network
+* or a timer.
+*/
+function makeClaudeUsageTelemetry(dependencies) {
+	const now = dependencies.now ?? (() => Date.now());
+	/** When each account last had an observation admitted, whatever came of it. */
+	const admittedAt = /* @__PURE__ */ new Map();
+	/** The fingerprint of the last value CMMD accepted, per pair. */
+	const publishedFingerprints = /* @__PURE__ */ new Map();
+	const publishIfNew = (windows, providerAccountId, lookupCredentialGenerationId, at) => require_Schema$1.gen(function* () {
+		const credentialGenerationId = yield* lookupCredentialGenerationId;
+		if (!credentialGenerationId) return;
+		const attribution = {
+			providerAccountId,
+			credentialGenerationId
+		};
+		const key = pairKey(attribution);
+		const fingerprint = windowsFingerprint(windows);
+		if (publishedFingerprints.get(key) === fingerprint) return;
+		yield* dependencies.publish(claudeUsageTelemetryBody({
+			attribution,
+			source: "passive_sdk_telemetry",
+			windows,
+			observedAt: new Date(at).toISOString()
+		}));
+		remember(publishedFingerprints, key, fingerprint);
+	});
+	/**
+	* The floor is read and claimed inside the returned effect, never while
+	* building it, and before anything suspends. Two turns on one account can be
+	* in flight at once, and the floor only holds them apart if the second one
+	* reads what the first one wrote.
+	*/
+	const observe = (observation) => require_Schema$1.suspend$1(() => {
+		const { windows, providerAccountId } = observation;
+		if (!windows || !providerAccountId) return require_Schema$1.void_;
+		const at = now();
+		const lastAdmittedAt = admittedAt.get(providerAccountId);
+		if (lastAdmittedAt !== void 0 && at - lastAdmittedAt < 5e3) return require_Schema$1.void_;
+		remember(admittedAt, providerAccountId, at);
+		return publishIfNew(windows, providerAccountId, observation.credentialGenerationId, at).pipe(require_Schema$1.timeout(CLAUDE_USAGE_TELEMETRY_PUBLISH_TIMEOUT_MS), require_Schema$1.catchCause((cause) => require_Schema$1.logWarning("claude usage passive telemetry publish failed", {
+			providerAccountId,
+			cause
+		})), require_Schema$1.asVoid);
+	});
+	return { observe };
 }
 //#endregion
 //#region src/orchestration/Layers/ProviderRuntimeIngestion.ts
@@ -287398,20 +287781,37 @@ const BUFFERED_PROPOSED_PLAN_BY_ID_TTL = require_Schema$1.minutes(120);
 const MAX_BUFFERED_ASSISTANT_CHARS = 24e3;
 const PROVIDER_INGESTION_CONCURRENCY = 8;
 const STRICT_PROVIDER_LIFECYCLE_GUARD = process.env.FORGE_STRICT_PROVIDER_LIFECYCLE_GUARD !== "0";
-function decodeClaudeRateLimitWindows(raw) {
+/**
+* The SDK's own `rate_limit_info` off one ClaudeAdapter rate-limit event, or
+* nothing. Both readers below start here: the banner takes the single window
+* `rateLimitType` names, and passive usage telemetry takes the `unifiedWindows`
+* sub-object riding along on the same object.
+*/
+function readClaudeRateLimitInfo(raw) {
 	const rateLimitInfo = raw.rate_limit_info;
-	if (rateLimitInfo === null || typeof rateLimitInfo !== "object") return [];
+	if (rateLimitInfo === null || typeof rateLimitInfo !== "object") return null;
+	return rateLimitInfo;
+}
+function decodeClaudeRateLimitWindows(raw) {
+	const rateLimitInfo = readClaudeRateLimitInfo(raw);
+	if (!rateLimitInfo) return [];
 	const mapped = mapClaudeRateLimitInfo(rateLimitInfo);
 	return mapped ? [{
 		window: mapped.kind === "fiveHour" ? "five_hour" : "seven_day",
 		...mapped.window
 	}] : [];
 }
+/** The raw telemetry object ClaudeAdapter/CodexAdapter wrap as `payload.rateLimits`. */
+function readRateLimitPayload(event) {
+	if (event.type !== "account.rate-limits.updated") return null;
+	const raw = event.payload.rateLimits;
+	return raw !== null && typeof raw === "object" ? raw : null;
+}
 /**
 * Codex's app-server protocol shape isn't type-published anywhere this
-* codebase has access to, so it's read defensively - an unrecognized shape
-* is skipped rather than thrown, since this is a best-effort in-chat notice,
-* never load-bearing for the turn itself.
+* codebase has access to, so it's read defensively. An unrecognized shape
+* is skipped rather than thrown, since this is a best-effort in-chat notice
+* that the turn itself never depends on.
 */
 /**
 * Decodes ONE window of the codex app-server `account/rateLimits/updated`
@@ -287724,6 +288124,9 @@ function shouldApplyProviderTurnCompleted(activeTurnId, eventTurnId) {
 }
 const make$9 = require_Schema$1.fn("make")(function* () {
 	const orchestrationEngine = yield* OrchestrationEngineService;
+	const claudeUsageTelemetry = yield* ClaudeUsageTelemetry;
+	const claudeUsageScope = yield* require_Schema$1.make$3("parallel");
+	yield* require_Schema$1.addFinalizer(() => require_Schema$1.close(claudeUsageScope, require_Schema$1.void_$1));
 	const providerService = yield* ProviderService;
 	const projectionTurnRepository = yield* ProjectionTurnRepository;
 	const serverSettingsService = yield* ServerSettingsService;
@@ -288132,18 +288535,53 @@ const make$9 = require_Schema$1.fn("make")(function* () {
 	* SDKRateLimitInfo, reused from apps/server/src/usage/providerRateLimits.ts
 	* (same decoder the Usage page cache uses). Codex's app-server protocol
 	* shape isn't type-published anywhere this codebase has access to, so it's
-	* read defensively - an unrecognized shape means no window update, not a
-	* thrown error, since this is a best-effort in-chat notice, never load-
-	* bearing for the turn itself.
+	* read defensively. An unrecognized shape means no window update, not a
+	* thrown error, since this is a best-effort in-chat notice that the turn
+	* itself never depends on.
 	*/
 	function decodeRateLimitWindows(event) {
-		if (event.type !== "account.rate-limits.updated") return [];
-		const raw = event.payload.rateLimits;
-		if (raw === null || typeof raw !== "object") return [];
+		const raw = readRateLimitPayload(event);
+		if (!raw) return [];
 		if (event.provider === "claudeAgent") return decodeClaudeRateLimitWindows(raw);
 		if (event.provider === "codex") return decodeCodexRateLimitWindows(raw);
 		return [];
 	}
+	/**
+	* The credential generation a Claude thread's live session runs on, or null.
+	*
+	* It is the delivery identity the readiness guard verified before the
+	* session started, which ProviderService writes into the provider resume
+	* cursor and `listSessions` hands back on the live session. Claude's
+	* delivery identity is `{kind: "credential_generation"}` and carries NO
+	* account field, so it cannot stand in for the account the thread's model
+	* selection names, and neither id is derivable from the other. The usage
+	* observer drops an observation missing either one, because publishing under
+	* a guessed id would write one account's usage onto another account's card.
+	*/
+	const claudeCredentialGenerationId = require_Schema$1.fn("claudeCredentialGenerationId")(function* (threadId) {
+		const cursor = (yield* providerService.listSessions()).find((entry) => entry.threadId === threadId && entry.provider === "claudeAgent")?.resumeCursor;
+		const binding = cursor !== null && typeof cursor === "object" ? readProviderDeliveryBinding(cursor.providerDeliveryBinding) : null;
+		return binding?.identity.kind === "credential_generation" ? binding.identity.credentialGenerationId : null;
+	});
+	/**
+	* Publishes the unified windows the same event already carried for the
+	* banner. Passive: no probe, no credential delivery, no woken sprite. The SDK
+	* reports these figures on every turn whether anything reads them or not.
+	* The observer owns the floor, the credential generation lookup, dedupe, the
+	* timeout and the HTTP call, and never fails.
+	*/
+	const observeClaudeUsage = require_Schema$1.fn("observeClaudeUsage")(function* (event, thread) {
+		if (event.provider !== "claudeAgent") return;
+		const raw = readRateLimitPayload(event);
+		const rateLimitInfo = raw ? readClaudeRateLimitInfo(raw) : null;
+		const windows = rateLimitInfo ? mapClaudeUnifiedWindows(rateLimitInfo) : null;
+		if (!windows) return;
+		yield* claudeUsageTelemetry.observe({
+			windows,
+			providerAccountId: readProviderAccountId(thread.modelSelection) ?? null,
+			credentialGenerationId: claudeCredentialGenerationId(thread.id)
+		});
+	});
 	const handleRateLimitEvent = require_Schema$1.fn("handleRateLimitEvent")(function* (event, thread) {
 		const provider = event.provider === "claudeAgent" ? "claude" : event.provider === "codex" ? "codex" : null;
 		if (!provider) return;
@@ -288160,6 +288598,10 @@ const make$9 = require_Schema$1.fn("make")(function* () {
 			resetsAt: win.resetsAt,
 			createdAt: event.createdAt
 		}), { discard: true });
+		yield* observeClaudeUsage(event, thread).pipe(require_Schema$1.catchCause((cause) => require_Schema$1.hasInterruptsOnly(cause) ? require_Schema$1.void_ : require_Schema$1.logWarning("claude usage observation failed", {
+			eventId: event.eventId,
+			cause
+		})), require_Schema$1.forkIn(claudeUsageScope));
 	});
 	const processRuntimeEvent = require_Schema$1.fn("processRuntimeEvent")(function* (event) {
 		const thread = (yield* orchestrationEngine.getReadModel()).threads.find((entry) => entry.id === event.threadId);
@@ -288275,6 +288717,44 @@ const make$9 = require_Schema$1.fn("make")(function* () {
 });
 const ProviderRuntimeIngestionLive = require_Schema$1.effect(ProviderRuntimeIngestionService, make$9()).pipe(require_Schema$1.provide$1(ProjectionTurnRepositoryLive));
 //#endregion
+//#region src/usage/Layers/ClaudeUsageTelemetry.ts
+/**
+* The real publish behind `ClaudeUsageTelemetry`: the owner's CMMD credential
+* and one POST to `CLAUDE_USAGE_TELEMETRY_PATH`.
+*
+* The call always goes out on the owner session credential, never on a
+* runtime grant.
+*
+* A machine with nobody signed in, or one whose CMMD credential cannot be
+* minted, fails the publish rather than reporting success. The observer only
+* remembers a value it managed to send, so a quiet success here would suppress
+* the publish for as long as that reading stayed the same, which on a stable
+* account is hours.
+*
+* @module ClaudeUsageTelemetryLive
+*/
+const LOG_PREFIX = "claude-usage-passive-telemetry";
+const ClaudeUsageTelemetryLive = require_Schema$1.effect(ClaudeUsageTelemetry, require_Schema$1.gen(function* () {
+	const sql = yield* require_SqlError.SqlClient;
+	const publish = (body) => require_Schema$1.gen(function* () {
+		const credential = yield* resolveCmmdOwnerSessionCredential(sql, { logPrefix: LOG_PREFIX });
+		if (credential.kind !== "credential") return yield* new ClaudeUsageTelemetryPublishError({ reason: credential.kind });
+		yield* require_Schema$1.tryPromise({
+			try: () => cmmdGateway.request({
+				method: "POST",
+				jwt: credential.jwt,
+				path: CLAUDE_USAGE_TELEMETRY_PATH,
+				body
+			}),
+			catch: (cause) => new ClaudeUsageTelemetryPublishError({
+				reason: "request-failed",
+				cause
+			})
+		});
+	});
+	return makeClaudeUsageTelemetry({ publish });
+}));
+//#endregion
 //#region ../../packages/shared/src/DrainableWorker.ts
 /**
 * Create a drainable worker that processes items from an unbounded queue.
@@ -292460,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("\\", "/");
@@ -294072,7 +294928,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "7f0d765bc59cb837f8aa8025b9b2f855df3fd36d";
+	return "b79da36c868d5629c76dcec88a3326634a02c2c7";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;
@@ -316677,7 +317533,7 @@ function claimClaudeReadinessJti(input) {
 	return "claimed";
 }
 const readUsableClaudeGenerationHash = (config) => {
-	const configuredGenerationHash = process.env.FORGE_PERSONAL_CLAUDE_GENERATION_HASH?.trim() ?? "";
+	const configuredGenerationHash = bootExportedPersonalClaudeGenerationHash();
 	if (!/^[a-f0-9]{64}$/.test(configuredGenerationHash)) return require_Schema$1.succeed(null);
 	return require_Schema$1.tryPromise(() => (0, node_fs_promises.readFile)(resolveLocalClaudeCredentialPath(config.forgeClaudeConfigPath), "utf8")).pipe(require_Schema$1.map((credentialJson) => isClaudeSubscriptionCredential(credentialJson) ? configuredGenerationHash : null), require_Schema$1.orElseSucceed(() => null));
 };
@@ -317195,7 +318051,7 @@ const PlatformServicesLive = require_Schema$1.unwrap(require_Schema$1.gen(functi
 }));
 const RuntimeReplicationLayerLive = RuntimeReplicationLive.pipe(require_Schema$1.provideMerge(RuntimeReplicationClientLive), require_Schema$1.provideMerge(RuntimeReplicationOutboxLive), require_Schema$1.provideMerge(ActiveHourMeterLive.pipe(require_Schema$1.provide$1(RuntimeReplicationOutboxLive))));
 const RuntimeDrainLayerLive = RuntimeDrainReporterLive.pipe(require_Schema$1.provideMerge(RuntimeDrainStateLive));
-const RuntimeAwareProviderReactorsLive = require_Schema$1.mergeAll(ProviderRuntimeIngestionLive, ProviderCommandReactorLive).pipe(require_Schema$1.provide$1(RuntimeDrainLayerLive));
+const RuntimeAwareProviderReactorsLive = require_Schema$1.mergeAll(ProviderRuntimeIngestionLive, ProviderCommandReactorLive).pipe(require_Schema$1.provide$1(RuntimeDrainLayerLive), require_Schema$1.provide$1(ClaudeUsageTelemetryLive));
 const PipelineWorkerCoordinatorLayerLive = PipelineWorkerCoordinatorLive.pipe(require_Schema$1.provideMerge(PipelineRunClientLive));
 const AgentProtocolReactorLayerLive = AgentProtocolReactorLive.pipe(require_Schema$1.provideMerge(PipelineRunStoreLive));
 const PipelineRunCoordinatorLayerLive = PipelineRunCoordinatorLive.pipe(require_Schema$1.provideMerge(PipelineProviderAuthorityInstallerLive), require_Schema$1.provideMerge(PipelineChangeInspectorLive), require_Schema$1.provideMerge(PipelineContextArtifactStoreLive), require_Schema$1.provideMerge(PipelineModelPolicyLive), require_Schema$1.provideMerge(PipelineRunClientLive), require_Schema$1.provideMerge(PipelineRunStoreLive), require_Schema$1.provideMerge(PipelineRunWorkspaceAllocatorLive), require_Schema$1.provideMerge(PipelineStagePolicyLive), require_Schema$1.provideMerge(PipelineWorkerCoordinatorLayerLive));