@cmmd-center/forge 0.13.11 → 0.13.13

package/dist/bin.mjs

@@ -2,16 +2,16 @@
 
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./chunk-C5ckVeoz.mjs";
 import { $ as encodeEffect, $a as make$39, $c as fromNullishOr, $i as spaced, $l as constTrue, $n as filterMapOrFail, $r as runPromise, $s as millis, $t as stringifyJson, Aa as Scope$1, Ai as void_$1, Al as format, An as cached$3, Ar as match$1, As as uninterruptibleMask, At as withConstructorDefault, Ba as CurrentLogSpans, Bc as add$2, Bi as counter, Bl as compose$1, Bn as catch_, Bo as addFinalizer, Br as orDie, Bs as make$42, Bt as head, C as Record, Ca as mergeAll, Ci as tx$1, Cn as andThen, Co as hasDies, Cr as logInfo, Cs as sleep$3, Ct as optionalKey, D as TaggedStruct, Da as succeedContext, Di as uninterruptibleMask$1, Dn as as$3, Do as interruptors, Ds as suspend, Dt as toCodecStringTree, E as TaggedErrorClass, Ea as succeed$2, Ei as uninterruptible, En as annotateSpans, Eo as interrupt$2, Er as map$3, Et as toCodecJson, F as UndefinedOr, Fa as forkUnsafe, Fc as isSuccess$1, Fi as withParentSpan, Fn as catchFilter, Fr as onError$1, Fs as MinimumTraceLevel, G as decodeExit, Ga as done, Gc as getUnsafe$1, Gi as withAttributes, Gl as isNullish, Gn as die$1, Gr as provideService, Gs as format$1, Gt as Transformation, H as declare, Hc as get$3, Hi as snapshotUnsafe, Hl as isNotNull, Hn as contextWith, Ho as as$2, Hr as promise, Ht as size$2, I as Union, Ia as make$37, Ii as withSpan, In as catchIf, Io as ConsoleRef, Ir as onExit, Is as NativeSpan, It as assign, J as decodeUnknownEffect, Ja as failCause$3, Jc as merge$2, Ji as exponential, Jn as exit, Jr as repeat, Js as hours, Jt as transformOrFail, K as decodeSync, Kc as make$35, Ki as addDelay, Kl as isObject$1, Ko as consolePretty$1, Kr as race, Ks as fromInput, L as Unknown, La as makeUnsafe$4, Lc as succeed$1, Li as withTracerEnabled, Ln as catchReason, Lo as CurrentLoggers$1, Ls as ParentSpan, Lt as append$1, M as URLFromString, Ma as addFinalizerExit, Mi as whileLoop, Mn as callback, Mo as pretty, Ms as void_$2, Na as close, Ni as withFiber$1, Nn as catchCause, No as prettyErrors, Nr as matchEffect, O as TemplateLiteral, Oa as sync$2, Ol as NodeInspectSymbol, On as asSome, Or as mapError, Os as sync, Ot as toJsonSchemaDocument, P as Undefined, Pa as closeUnsafe, Pc as isFailure$1, Pl as equals, Pn as catchDefect, Po as squash, Pr as never$1, Q as encode$4, Qc as flatten$1, Qi as recurs, Qn as filter$1, Qr as runForkWith, Qs as max, R as UnknownFromJsonString$1, Ra as provide$2, Rc as Reference$1, Ri as yieldNow, Rn as catchTag, Rr as onInterrupt, Rs as Tracer, Rt as drop$1, S as Option, Sa as merge$3, Sc as sort, Si as try_, Sn as all, Sr as logFatal, Ss as scopeAddFinalizerExit, St as optional$4, T as Struct, Ta as provideMerge, Ti as undefined_, Tl as withFiber, Tn as annotateLogs, To as hasInterruptsOnly, Tr as makeSpanScoped, Tt as tag, Ua as TracerTimingEnabled, Ui as timer, Ul as isNotNullish, Un as currentSpan, Ur as provide, Ut as toArray, V as brand, Va as MinimumLogLevel, Vc as empty$1, Vi as gauge, Vl as hasProperty, Vn as context, Vo as andThen$1, Vr as orElseSucceed, Vt as isEmpty$2, W as decodeEffect, Wa as _await, Wi as update$3, Wl as isNotUndefined, Wr as provideContext, Ws as days, X as decodeUnknownOption, Xc as firstSomeOf, Xl as cast, Xn as failCause$1, Xr as retry, Xt as onSome, Y as decodeUnknownExit, Yi as forever$2, Yn as fail, Yr as result, Z as decodeUnknownSync, Za as isDeferred, Zc as flatMap$2, Zi as passthrough$1, Zl as compose, Zr as runFork, Zt as parseJson$1, _ as NonEmptyArray, _a as effectContext, _i as tapErrorTag, _l as YieldableProto, _n as toUtc, _t as isSchemaError, a as DateTimeUtc, aa as Random$1, ac as toSeconds, al as isSome, an as value, ao as interrupt$3, ar as fnUntraced, at as isBetween, au as identity, b as NullOr, bi as timeoutOrElse, bn as acquireUseRelease, br as logDebug, bs as reportCauseUnsafe, bt as makeFilter, c as Defect, ca as Clock, cc as empty$3, ci as sleep$4, cl as none$4, cn as add$3, co as match$2, cr as forkChild, cs as flatMap$1, ct as isGreaterThanOrEqualTo, d as Exit, dc as flatMapNullishOr, di as succeedSome, dl as make$41, dn as isGreaterThanOrEqualTo$1, dr as forkScoped, ds as forkDetach, dt as isMaxLength, ea as catchDone, ec as min, el as fromUndefinedOr, er as filterOrFail, et as encodeSync, eu as constUndefined, fa as TaggedError, fc as fromIterable, fi as suspend$1, fn as make$38, fr as gen, ft as isMaxProperties, g as Never, ga as effect, gi as tapError, gl as PipeInspectableProto, gn as toEpochMillis, gr as interruptible, gt as isSchema, h as Literals, ha as buildWithMemoMap, hc as isReadonlyArrayNonEmpty, hi as tapCause, hn as toDate, hr as interrupt$1, ht as isPattern, i as Class, ic as toMillis, ii as scoped, il as isNone, in as make$40, io as failCause$2, ir as fn$1, it as is$1, ja as addFinalizer$1, jc as fail$1, jn as cachedWithTTL, jo as map$6, jr as matchCauseEffect, jt as withDecodingDefault, k as Trim, ka as unwrap, ki as useSpan, kl as toJson, kn as asVoid, ks as tracerLogger$1, kt as toType, l as Duration, la as currentTimeMillis, lc as ensure, li as succeed, ll as some, ln as distance, lr as forkDetach$1, ls as fnUntraced$1, lt as isInt, m as Literal, ma as build, mc as isArrayNonEmpty, mi as tap, mn as now, mo as StackTrace, mr as ignoreCause, ms as loggerMake, mt as isNonEmpty, n as ArraySchema, nc as seconds, nl as getOrNull, no as die$2, nt as encodeUnknownExit, nu as constant, o as DateTimeUtcFromString, oa as clamp, oc as zero, oi as service, ol as map$5, oo as isFailure, or as forEach, ot as isFinite$1, ou as pipe$1, p as Int$1, pa as CurrentMemoMap, pi as sync$1, pn as makeUnsafe$5, po as NoSuchElementError, pr as ignore, pt as isMinLength, q as decodeTo, qa as fail$3, qc as makeUnsafe$3, qi as both, ql as isTagged, qn as ensuring, qr as raceFirst, qs as fromInputUnsafe, r as Boolean$1, ra as isDoneCause, rc as times, ri as scope$1, rl as getOrUndefined, rn as makeFormatterDefault, ro as fail$2, rr as flatten$2, rt as fromJsonString, ru as dual, sa as parse$6, sc as allocate, si as serviceOption, sl as match, sn as encodeBase64Url$2, so as isSuccess, sr as forever$1, st as isGreaterThan, su as pipeArguments, t as Any, tc as minutes, ti as runPromiseWith, tl as getOrElse, tn as InvalidValue$1, to as succeed$3, tr as flatMap, ts as fiberInterrupt, tt as encodeUnknownEffect, tu as constVoid, u as ErrorClass, ua as Class$1, uc as filter, ui as succeedNone, ul as Number$2, un as formatIso, uo as void_$3, ur as forkIn, us as forever, ut as isLessThanOrEqualTo, v as NonEmptyString, va as effectDiscard, vi as timeout$1, vn as Transaction$1, vo as done$1, vr as isEffect, w as String$1, wa as provide$1, wi as txRetry, wl as isEffect$1, wn as annotateCurrentSpan, wo as hasInterrupts, wr as logWarning$1, wt as suspend$2, x as Number$1, xa as launch$1, xc as reverse, xi as tryPromise, xn as addFinalizer$2, xr as logError, xs as scope, xt as mutable, y as Null, ya as empty$4, yc as map$4, yi as timeoutOption, yn as acquireRelease, yo as fail$4, yr as log$4, yt as make$36, z as Void, za as CurrentLogAnnotations, zc as Service$1, zi as zipWith, zn as catchTags, zr as option, zs as externalSpan, zt as empty$2 } from "./Schema-DOBWF8gQ.mjs";
-import { $ as tick, $t as runIn, A as isStream, At as failCause$4, Bt as takeAll, C as fromEffect, D as fromQueue, Dt as bounded, E as fromPull, Et as makeUnsafe$6, Ft as offerUnsafe, G as runDrain, Gt as unbounded$1, H as provideContext$1, Ht as publish, I as merge$4, J as runForEachArray, Jt as makeUnsafe$7, K as runFold, Lt as shutdown$1, M as map$7, Mt as make$45, N as mapAccum, Nt as offer$1, Ot as end, P as mapEffect$1, Pt as offerAll, Q as takeWhile, Rt as sliding, S as fromChannel, St as fromTransform, T as fromPubSub, Tt as make$44, U as run$2, Ut as shutdown$2, Vt as unbounded$2, W as runCollect, Wt as subscribe$1, X as succeed$4, Xt as getCurrent, Yt as await_, Zt as interrupt$4, at as unwrap$1, b as flatMap$3, c as callback$1, ct as get$5, d as debounce$1, et as toAsyncIterable, f as decodeText$1, g as ensuring$1, gt as forEach$1, h as encodeText, ht as drain, j as make$43, k as fromSubscription, l as catchCause$1, lt as make$47, m as empty$5, ot as get$4, q as runForEach, r as FileSystem, st as make$46, t as Path$2, tt as toPull, u as concat$2, v as failCause$5, w as fromIterable$1, x as fromAsyncIterable, xt as fromSubscriptionArray, y as filter$2, yt as mapInput, z as onExit$1, zt as take$1 } from "./Path-evOm-H0Q.mjs";
-import { _ as ChildProcessSpawner, a as Stdio, g as make$48, o as make$49, r as isQuitError } from "./NodeTerminal-pYVVRTiD.mjs";
-import { n as layer$7 } from "./NodeServices-z1Ac4lEO.mjs";
-import { $ as file, A as SocketErrorReason, At as merge$5, Bt as set$3, Ct as HttpClientErrorSchema, Dt as empty$7, Ft as getAndSet, G as TracerPropagationEnabled, Ht as updateAndGet, I as HttpServerError, It as getUnsafe$2, J as transformResponse, K as filterStatusOk$1, Lt as make$50, Ot as fromInput$1, Pt as get$6, Q as empty$6, Rt as makeUnsafe$8, St as setBody, Tt as jsonUnsafe$1, U as layer$8, Vt as update$4, W as HttpClient, Z as symbol$1, _ as schemaBodyUrlParams, _t as acceptJson, a as withLogAddress, at as setCookie, bt as get$7, ct as stream, d as logger$1, dt as filterStatusOk, et as isHttpServerResponse, f as withLoggerDisabled, ft as matchStatus, g as schemaBodyJson, gt as schemaBodyJson$1, i as serve$1, it as schemaJson, kt as fromRecordUnsafe, lt as text$2, m as ParsedSearchParams, nt as raw, ot as setCookies, p as HttpServerRequest, q as retryTransient, rt as redirect, st as setHeader, t as HttpServer, tt as jsonUnsafe, u as cors, ut as uint8Array, v as schemaHeaders, vt as bearerToken, wt as isHttpClientError, xt as post, y as toURL, yt as bodyJson, z as RouteNotFound, zt as modify$3 } from "./HttpServer-COaBeM7-.mjs";
+import { $ as takeWhile, A as fromSubscription, B as onExit$1, Bt as take$1, C as fromChannel, Ct as fromTransform, D as fromPull, Dt as makeUnsafe$6, E as fromPubSub, Et as make$44, F as mapEffect$1, Ft as offerAll, G as runCollect, Gt as subscribe$1, Ht as unbounded$2, I as mapError$1, It as offerUnsafe, J as runForEach, K as runDrain, Kt as unbounded$1, L as merge$4, M as make$43, N as map$7, Nt as make$45, O as fromQueue, Ot as bounded, P as mapAccum, Pt as offer$1, Qt as interrupt$4, Rt as shutdown$1, S as fromAsyncIterable, St as fromSubscriptionArray, T as fromIterable$1, U as provideContext$1, Ut as publish, Vt as takeAll, W as run$2, Wt as shutdown$2, Xt as await_, Y as runForEachArray, Yt as makeUnsafe$7, Z as succeed$4, Zt as getCurrent, _t as forEach$1, b as flatMap$3, bt as mapInput, c as callback$1, ct as make$46, d as debounce$1, en as runIn, et as tick, f as decodeText$1, g as ensuring$1, gt as drain, h as encodeText, j as isStream, jt as failCause$4, kt as end, l as catchCause$1, lt as get$5, m as empty$5, nt as toPull, ot as unwrap$1, q as runFold, r as FileSystem, st as get$4, t as Path$2, tt as toAsyncIterable, u as concat$2, ut as make$47, v as failCause$5, w as fromEffect, x as fromArray, y as filter$2, zt as sliding } from "./Path-CZJ1gPPo.mjs";
+import { _ as ChildProcessSpawner, a as Stdio, g as make$48, o as make$49, r as isQuitError } from "./NodeTerminal-9iHZIdt1.mjs";
+import { n as layer$7 } from "./NodeServices-D3IxOzHl.mjs";
+import { $ as file, A as SocketErrorReason, At as merge$5, Bt as set$3, Ct as HttpClientErrorSchema, Dt as empty$7, Ft as getAndSet, G as TracerPropagationEnabled, Ht as updateAndGet, I as HttpServerError, It as getUnsafe$2, J as transformResponse, K as filterStatusOk$1, Lt as make$50, Ot as fromInput$1, Pt as get$6, Q as empty$6, Rt as makeUnsafe$8, St as setBody, Tt as jsonUnsafe$1, U as layer$8, Vt as update$4, W as HttpClient, Z as symbol$1, _ as schemaBodyUrlParams, _t as acceptJson, a as withLogAddress, at as setCookie, bt as get$7, ct as stream, d as logger$1, dt as filterStatusOk, et as isHttpServerResponse, f as withLoggerDisabled, ft as matchStatus, g as schemaBodyJson, gt as schemaBodyJson$1, i as serve$1, it as schemaJson, kt as fromRecordUnsafe, lt as text$2, m as ParsedSearchParams, nt as raw, ot as setCookies, p as HttpServerRequest, q as retryTransient, rt as redirect, st as setHeader, t as HttpServer, tt as jsonUnsafe, u as cors, ut as uint8Array, v as schemaHeaders, vt as bearerToken, wt as isHttpClientError, xt as post, y as toURL, yt as bodyJson, z as RouteNotFound, zt as modify$3 } from "./HttpServer-Bclwvu0I.mjs";
 import { _ as withDefault$3, a as all$1, c as logLevel, d as option$1, f as port, g as url$2, i as TrueValues, l as map$8, m as string$7, n as FalseValues, o as boolean$5, p as schema$2, r as Record$1, s as int$2, t as Boolean$2, u as number$2 } from "./Config-Cdfpphpo.mjs";
-import { a as make$51, i as keys, n as getOption, o as makeWith$1, r as invalidate, s as set$4, t as get$8 } from "./Cache-C9cwdCDt.mjs";
-import { S as layer$9, _ as defaultEscape, a as DeadlockError, b as makeCompiler$1, c as SqlError, d as UnknownError, g as custom, h as make$52, i as ConstraintError, l as SqlSyntaxError, m as SqlClient, n as AuthorizationError, o as LockTimeoutError, r as ConnectionError, s as SerializationError, t as AuthenticationError, u as StatementTimeoutError, v as defaultTransforms, y as fragment } from "./SqlError-CezTFGvr.mjs";
+import { a as make$51, i as keys, n as getOption, o as makeWith$1, r as invalidate, s as set$4, t as get$8 } from "./Cache-D57GWb9-.mjs";
+import { S as layer$9, _ as defaultEscape, a as DeadlockError, b as makeCompiler$1, c as SqlError, d as UnknownError, g as custom, h as make$52, i as ConstraintError, l as SqlSyntaxError, m as SqlClient, n as AuthorizationError, o as LockTimeoutError, r as ConnectionError, s as SerializationError, t as AuthenticationError, u as StatementTimeoutError, v as defaultTransforms, y as fragment } from "./SqlError-BMBkezUO.mjs";
 import { r as wrapper_default, t as Mime_default } from "./Mime-Dq9IoNiV.mjs";
 import { a as diag, c as SpanKind$1, d as TraceFlags, f as ROOT_CONTEXT, i as propagation, l as isSpanContextValid, m as DiagLogLevel, n as init_esm$1, o as context$1, p as createContextKey, r as trace, s as SpanStatusCode, t as esm_exports$1 } from "./esm-wLIF-u3N.mjs";
-import { a as verifyCmmdAuthRuntimeTicket, c as verifyCmmdRuntimeTicket, d as setRuntimeGrantToken, f as createReadOnceFileTokenAccessor, i as sendRuntimeControlHeartbeat, l as verifyCmmdRuntimeTicketRefreshProof, n as bootstrapRuntimeControlAuthorityFromNarrowGrant, o as verifyCmmdClaudeReadinessTicket, r as readRuntimeControlAuthority, s as verifyCmmdClaudeUsageTicket, t as bootstrapRuntimeControlAuthority, u as runtimeGrantToken } from "./runtimeControlAuthority-D_zKr_eI.mjs";
+import { a as verifyCmmdAuthRuntimeTicket, c as verifyCmmdRuntimeTicket, d as runtimeGrantToken, f as setRuntimeGrantToken, i as sendRuntimeControlHeartbeat, l as verifyCmmdRuntimeTicketRefreshProof, n as bootstrapRuntimeControlAuthorityFromNarrowGrant, o as verifyCmmdClaudeReadinessTicket, p as createReadOnceFileTokenAccessor, r as readRuntimeControlAuthority, s as verifyCmmdClaudeUsageTicket, t as bootstrapRuntimeControlAuthority, u as verifyCmmdScopedRuntimePayload } from "./runtimeControlAuthority-E_kdeD_P.mjs";
 import { n as PtySpawnError, t as PtyAdapter } from "./PTY-BzdbZ0Ym.mjs";
 import { createRequire } from "node:module";
 import * as HE from "node:child_process";
@@ -22,7 +22,7 @@ import { createCipheriv, createDecipheriv, createHash, createHmac, createPublicK
 import * as FS$1 from "node:fs";
 import fs, { accessSync, chmodSync, constants, createReadStream, existsSync, mkdirSync, mkdtempSync, promises, readFile, readFileSync, readdir, readdirSync, realpathSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import * as NodeOS from "node:os";
-import $U, { homedir, networkInterfaces, tmpdir } from "node:os";
+import os, { homedir, networkInterfaces, tmpdir } from "node:os";
 import * as Path$1 from "node:path";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -65,12 +65,12 @@ import * as tls from "node:tls";
 import { performance as performance$1 } from "perf_hooks";
 import { execFile as execFile$1, spawn as spawn$1 } from "child_process";
 import * as NodeFSP from "node:fs/promises";
-import fs$1, { link, lstat, mkdir, mkdtemp, readFile as readFile$1, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import fs$1, { chmod, link, lstat, mkdir, mkdtemp, readFile as readFile$1, readdir as readdir$1, realpath, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { StringDecoder } from "string_decoder";
 import * as timers from "node:timers/promises";
 import { pipeline } from "node:stream/promises";
 import z$ from "http2";
-import { access, appendFile, chmod, copyFile, link as link$1, lstat as lstat$1, mkdir as mkdir$1, open, readFile as readFile$2, readdir as readdir$1, readlink, realpath as realpath$1, rename as rename$1, rm as rm$1, rmdir, stat as stat$1, symlink, unlink as unlink$1, writeFile as writeFile$1 } from "fs/promises";
+import { access, appendFile, chmod as chmod$1, copyFile, link as link$1, lstat as lstat$1, mkdir as mkdir$1, open, readFile as readFile$2, readdir as readdir$2, readlink, realpath as realpath$1, rename as rename$1, rm as rm$1, rmdir, stat as stat$1, symlink, unlink as unlink$1, writeFile as writeFile$1 } from "fs/promises";
 import { createInterface as createInterface$1 } from "readline";
 import { AsyncLocalStorage as AsyncLocalStorage$1 } from "async_hooks";
 import { chromium } from "playwright";
@@ -17358,7 +17358,8 @@ const ORCHESTRATION_WS_METHODS = {
 	getArchivedShellSnapshot: "orchestration.getArchivedShellSnapshot",
 	subscribeShell: "orchestration.subscribeShell",
 	subscribeThread: "orchestration.subscribeThread",
-	searchThreads: "orchestration.searchThreads"
+	searchThreads: "orchestration.searchThreads",
+	getThreadDetailPage: "orchestration.getThreadDetailPage"
 };
 const ProviderKind = Literals([
 	"codex",
@@ -17868,10 +17869,39 @@ const OrchestrationShellStreamItem = Union([Struct({
 	kind: Literal("snapshot"),
 	snapshot: OrchestrationShellSnapshot
 }), OrchestrationShellStreamEvent]);
-const OrchestrationSubscribeThreadInput = Struct({ threadId: ThreadId });
+const OrchestrationSubscribeThreadInput = Struct({
+	threadId: ThreadId,
+	afterSequence: optionalKey(NonNegativeInt),
+	requestCompletionMarker: optionalKey(Boolean$1),
+	turnLimit: optionalKey(PositiveInt)
+});
+Struct({
+	turnLimit: optionalKey(PositiveInt),
+	beforeCursor: optionalKey(TrimmedNonEmptyString)
+});
+/**
+* Reads one windowed page of a thread's detail directly over the RPC socket.
+*
+* The HTTP snapshot route and `subscribeThread`'s fallback snapshot both take
+* the same `turnLimit`/`beforeCursor` window, but neither can serve "load
+* earlier" on a connection with no HTTP endpoint: the fallback snapshot only
+* fires once, on subscribe. This method exists for exactly that case (a
+* relay-only connection), gated on the server's `threadDetailPageRpc`
+* capability so older servers are never sent a method they do not know.
+*/
+const OrchestrationGetThreadDetailPageInput = Struct({
+	threadId: ThreadId,
+	turnLimit: optionalKey(PositiveInt),
+	beforeCursor: optionalKey(TrimmedNonEmptyString)
+});
 const OrchestrationThreadDetailSnapshot = Struct({
 	snapshotSequence: NonNegativeInt,
-	thread: OrchestrationThread
+	thread: OrchestrationThread,
+	page: optional$4(Struct({
+		beforeCursor: NullOr(TrimmedNonEmptyString),
+		hasMore: Boolean$1,
+		snapshotSequence: NonNegativeInt
+	}))
 });
 const ProjectCreateCommand = Struct({
 	type: Literal("project.create"),
@@ -18675,13 +18705,17 @@ const OrchestrationEvent = Union([
 		payload: ThreadRateLimitSetPayload$1
 	})
 ]);
-const OrchestrationThreadStreamItem = Union([Struct({
-	kind: Literal("snapshot"),
-	snapshot: OrchestrationThreadDetailSnapshot
-}), Struct({
-	kind: Literal("event"),
-	event: OrchestrationEvent
-})]);
+const OrchestrationThreadStreamItem = Union([
+	Struct({ kind: Literal("synchronized") }),
+	Struct({
+		kind: Literal("snapshot"),
+		snapshot: OrchestrationThreadDetailSnapshot
+	}),
+	Struct({
+		kind: Literal("event"),
+		event: OrchestrationEvent
+	})
+]);
 const OrchestrationCommandReceiptStatus = Literals(["accepted", "rejected"]);
 const TurnCountRange = Struct({
 	fromTurnCount: NonNegativeInt,
@@ -18824,6 +18858,10 @@ const OrchestrationRpcSchemas = {
 	searchThreads: {
 		input: OrchestrationSearchThreadsInput,
 		output: OrchestrationSearchThreadsResult
+	},
+	getThreadDetailPage: {
+		input: OrchestrationGetThreadDetailPageInput,
+		output: OrchestrationThreadDetailSnapshot
 	}
 };
 var OrchestrationGetSnapshotError = class extends TaggedErrorClass()("OrchestrationGetSnapshotError", {
@@ -22792,6 +22830,9 @@ const ServerConfig$1 = Struct({
 	availableEditors: ArraySchema(EditorId),
 	shellRevealInFileManager: optionalKey(Boolean$1),
 	shellRevealInFileManagerKind: optionalKey(FileManagerRevealKind),
+	threadResumeCompletionMarker: optionalKey(Boolean$1),
+	threadSnapshotPagination: optionalKey(Boolean$1),
+	threadDetailPageRpc: optionalKey(Boolean$1),
 	observability: ServerObservability,
 	settings: ServerSettings
 });
@@ -26658,6 +26699,17 @@ const WsOrchestrationSearchThreadsRpc = make$30(ORCHESTRATION_WS_METHODS.searchT
 	error: OrchestrationSearchThreadsError
 });
 /**
+* The socket-only path for "load earlier turns": a relay-only connection has
+* no HTTP endpoint, so this reads the same windowed page the HTTP snapshot
+* route and `subscribeThread`'s fallback snapshot serve, over the RPC socket
+* instead.
+*/
+const WsOrchestrationGetThreadDetailPageRpc = make$30(ORCHESTRATION_WS_METHODS.getThreadDetailPage, {
+	payload: OrchestrationRpcSchemas.getThreadDetailPage.input,
+	success: OrchestrationRpcSchemas.getThreadDetailPage.output,
+	error: OrchestrationGetSnapshotError
+});
+/**
 * Resolve `owner/repo` to the repository the caller is allowed to clone.
 *
 * Both of these run against the same CMMD-brokered GitHub credential the web
@@ -26770,7 +26822,7 @@ const WsRpcGroup = make$29(WsServerGetConfigRpc, WsServerRefreshProvidersRpc, Ws
 	payload: ProviderUploadFeedbackInput,
 	success: ProviderUploadFeedbackResult,
 	error: ProviderUploadFeedbackError
-}), WsOrchestrationSearchThreadsRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc);
+}), WsOrchestrationSearchThreadsRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsOrchestrationGetThreadDetailPageRpc);
 const RelayWsRpcGroup = WsRpcGroup.middleware(RelayAuthorizationMiddleware).middleware(RelayDeliveryMiddleware);
 /**
 * The direct-WebSocket mount of the same group, with per-method scope
@@ -26843,6 +26895,32 @@ function encodeCmmdRuntimeToolActivityPayload(kind, payload) {
 		}
 	};
 }
+const WORKTREE_LAUNCH_ACTIVITY_KINDS = new Set([
+	"worktree.requested",
+	"worktree.stage",
+	"worktree.output",
+	"worktree.created",
+	"worktree.failed",
+	"setup-script.requested",
+	"setup-script.started",
+	"setup-script.skipped",
+	"setup-script.failed",
+	"launch.agent-starting",
+	"launch.cancelled"
+]);
+function encodeCmmdRuntimeWorktreeLaunchActivityPayload(kind, payload) {
+	return {
+		...isRecord$23(payload) ? payload : { sourcePayload: payload },
+		forgeWorktreeLaunchActivity: {
+			schemaVersion: 1,
+			source: "native",
+			kind
+		}
+	};
+}
+function isCmmdRuntimeWorktreeLaunchActivityKind(kind) {
+	return WORKTREE_LAUNCH_ACTIVITY_KINDS.has(kind);
+}
 //#endregion
 //#region ../../packages/contracts/src/cmmdProjectPatch.ts
 const CMMD_PROJECT_PATCH_FIELDS = {
@@ -31945,6 +32023,11 @@ const RELAY_METHOD_POLICY_BASES = [
 		requiredScope: "thread.read",
 		deliveryClass: "subscription"
 	},
+	{
+		method: ORCHESTRATION_WS_METHODS.getThreadDetailPage,
+		requiredScope: "thread.read",
+		deliveryClass: "read"
+	},
 	{
 		method: WS_METHODS.assetsCreateUrl,
 		requiredScope: "thread.read",
@@ -50614,7 +50697,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
 	const min = forceColor || 0;
 	if (env.TERM === "dumb") return min;
 	if (process$1.platform === "win32") {
-		const osRelease = $U.release().split(".");
+		const osRelease = os.release().split(".");
 		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
 		return 1;
 	}
@@ -53057,7 +53140,7 @@ var require_ProcessDetector = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.processDetector = void 0;
 	const api_1 = (init_esm$1(), __toCommonJS(esm_exports$1));
 	const semconv_1 = require_semconv$1();
-	const os$3 = __require("os");
+	const os$4 = __require("os");
 	/**
 	* ProcessDetector will be used to detect the resources related current process running
 	* and being instrumented from the NodeJS Process module.
@@ -53079,7 +53162,7 @@ var require_ProcessDetector = /* @__PURE__ */ __commonJSMin(((exports) => {
 			};
 			if (process.argv.length > 1) attributes[semconv_1.ATTR_PROCESS_COMMAND] = process.argv[1];
 			try {
-				const userInfo = os$3.userInfo();
+				const userInfo = os$4.userInfo();
 				attributes[semconv_1.ATTR_PROCESS_OWNER] = userInfo.username;
 			} catch (e) {
 				api_1.diag.debug(`error obtaining process owner: ${e}`);
@@ -66002,7 +66085,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.13.11";
+var version$1 = "0.13.13";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -66404,6 +66487,129 @@ const respondToAuthError = (error) => gen(function* () {
 	}));
 	return response;
 });
+//#endregion
+//#region src/http/rateLimit.ts
+/**
+* Per-client, per-route-class rate limiting for Forge's own HTTP surface.
+*
+* Scoped to the routes a broken or looping client can hammer before it ever
+* has an authenticated session — the CMMD device-code poll, the bootstrap and
+* pairing-token exchanges — plus the authenticated /api/cmmd proxy, which
+* every desktop UI interaction runs through. None of these had any limit
+* before FOR-36706: a stuck pairing loop or a poll that never saw `slow_down`
+* could retry as fast as the network allowed, with nothing to stop it and
+* nothing telling the client to back off.
+*
+* Defaults are generous on purpose. This exists to bound a runaway client,
+* not to throttle a working one — see `defaultRateLimitPolicies` for the
+* reasoning behind each number and how to override it.
+*
+* Deliberately plain module state, not an Effect service: every route this
+* guards is a synchronous decision (count, compare, maybe reset a window),
+* and threading a new Context requirement through the whole server's layer
+* graph for that would touch every test file that stands up any of these
+* routes. `cmmdJwtResolver.ts`'s in-flight-refresh map is the same call.
+*/
+function envInt(name, fallback) {
+	const raw = process.env[name];
+	if (!raw) return fallback;
+	const parsed = Number(raw);
+	return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+/**
+* One reasoning line per class, so a future change to a default has to
+* confront why the old one was picked:
+*
+* - `auth-device-poll` (`/api/auth/cmmd-oauth/device` and `/token`): RFC 8628
+*   polls every `interval` seconds, 5 by default, so a well-behaved client
+*   sits under 12/min. 120/min leaves room for several concurrent sign-in
+*   attempts and CMMD's own `slow_down` handling without ever tripping on
+*   normal use, while still bounding a client that ignores `slow_down`.
+* - `auth-bootstrap` (`/api/auth/bootstrap*`, the bearer bootstrap routes):
+*   a working client bootstraps once per sign-in. 30/min is generous headroom
+*   for retries after a network blip, not a budget anyone should approach.
+* - `auth-token-exchange` (`/oauth/token`, the vendored pairing exchange):
+*   same shape as bootstrap — one pairing attempt, occasionally retried.
+* - `cmmd-proxy` (every `/api/cmmd/*` route): this is the one real desktop
+*   traffic actually leans on — task lists, project browsing, comments, all
+*   day. 1200/min (20/sec) is set high enough that no normal session should
+*   ever see it; it exists for a retry loop or a runaway resync, not for
+*   ordinary use.
+*/
+function buildPoliciesFromEnv() {
+	return {
+		"auth-device-poll": {
+			maxRequests: envInt("FORGE_RATE_LIMIT_AUTH_DEVICE_POLL_MAX", 120),
+			windowMs: envInt("FORGE_RATE_LIMIT_AUTH_DEVICE_POLL_WINDOW_SECONDS", 60) * 1e3
+		},
+		"auth-bootstrap": {
+			maxRequests: envInt("FORGE_RATE_LIMIT_AUTH_BOOTSTRAP_MAX", 30),
+			windowMs: envInt("FORGE_RATE_LIMIT_AUTH_BOOTSTRAP_WINDOW_SECONDS", 60) * 1e3
+		},
+		"auth-token-exchange": {
+			maxRequests: envInt("FORGE_RATE_LIMIT_AUTH_TOKEN_EXCHANGE_MAX", 30),
+			windowMs: envInt("FORGE_RATE_LIMIT_AUTH_TOKEN_EXCHANGE_WINDOW_SECONDS", 60) * 1e3
+		},
+		"cmmd-proxy": {
+			maxRequests: envInt("FORGE_RATE_LIMIT_CMMD_PROXY_MAX", 1200),
+			windowMs: envInt("FORGE_RATE_LIMIT_CMMD_PROXY_WINDOW_SECONDS", 60) * 1e3
+		}
+	};
+}
+let policies = buildPoliciesFromEnv();
+const windows = /* @__PURE__ */ new Map();
+function windowKey(routeClass, clientKey) {
+	return `${routeClass}\0${clientKey}`;
+}
+/**
+* Fixed-window counting: cheap, and precise enough for a loop-guard rather
+* than a security boundary. The one imprecision this trades away — up to 2x
+* the configured rate right at a window boundary — matters for an attacker
+* budgeting requests against the limiter's clock, not for the runaway
+* clients this exists to catch.
+*/
+function checkHttpRateLimit(input) {
+	const policy = policies[input.routeClass];
+	const nowMs = Date.now();
+	const key = windowKey(input.routeClass, input.clientKey);
+	const existing = windows.get(key);
+	const windowIsLive = existing !== void 0 && nowMs - existing.windowStartMs < policy.windowMs;
+	const windowStartMs = windowIsLive ? existing.windowStartMs : nowMs;
+	const count = (windowIsLive ? existing.count : 0) + 1;
+	windows.set(key, {
+		windowStartMs,
+		count
+	});
+	return {
+		allowed: count <= policy.maxRequests,
+		retryAfterSeconds: Math.max(0, Math.ceil((windowStartMs + policy.windowMs - nowMs) / 1e3))
+	};
+}
+/**
+* Checks the limiter for one request and, when the caller is over budget,
+* returns the 429 to send instead of running the route — `null` means
+* proceed. Every route this guards is expected to call this first and return
+* early on a non-null result, before doing any other work.
+*/
+function rateLimitOrRespond(input) {
+	const decision = checkHttpRateLimit(input);
+	if (decision.allowed) return null;
+	return jsonUnsafe({ error: "Too many requests. Try again later." }, {
+		status: 429,
+		headers: { "retry-after": String(decision.retryAfterSeconds) }
+	});
+}
+/**
+* The client identity for a route with no session yet — the device-code
+* poll, bootstrap and pairing-token exchange all run before Forge has issued
+* one. IP address is the only stable-enough signal available at that point;
+* the authenticated `/api/cmmd` proxy keys on the session instead (see its
+* call site), so one desktop and one phone sharing a NAT never share a
+* budget there.
+*/
+function clientKeyFromRequest(request) {
+	return normalizeIpAddress(getOrNull(request.remoteAddress)) ?? "unknown";
+}
 const OAUTH_ACCESS_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:access_token";
 /**
 * The one exchange this endpoint performs, or the reason it will not.
@@ -66429,6 +66635,29 @@ function accessTokenExpiresInSeconds(remainingMillis) {
 	return Math.max(0, Math.floor(remainingMillis / 1e3));
 }
 //#endregion
+//#region src/auth/commandBootstrapClient.ts
+const BOOTSTRAP_CLIENT_LABELS = {
+	desktop: "Forge Desktop Cloud",
+	mobile: "Forge Mobile Cloud"
+};
+/**
+* Client metadata for a bearer bootstrap session.
+*
+* The declared device type wins over the one inferred from the user agent. A
+* React Native fetch sends whatever the platform's networking stack sends, and
+* on iOS that is a CFNetwork string no user-agent heuristic reads as a phone.
+*/
+function resolveCommandBootstrapClient(input) {
+	const deviceType = input.clientDeviceType ?? "desktop";
+	return {
+		...deriveAuthClientMetadata({
+			request: input.request,
+			label: BOOTSTRAP_CLIENT_LABELS[deviceType]
+		}),
+		deviceType
+	};
+}
+//#endregion
 //#region ../../packages/shared/src/cmmdIdentity.ts
 const MAX_CMMD_AVATAR_URL_LENGTH = 256 * 1024;
 const DATA_IMAGE_AVATAR_PATTERN = /^data:image\/(?:avif|gif|jpeg|jpg|png|webp);base64,[a-z0-9+/=]+$/i;
@@ -66882,14 +67111,26 @@ function extractJwtExpiresAt(jwtToken) {
 	}
 }
 /**
-* Returns true when a stored JWT is past its expiry or has no decodable expiry.
-* CMMD REST JWTs are short-lived bearer tokens, so unknown expiry is not safe.
+* How long before `exp` a stored JWT is already treated as spent.
+*
+* Comparing against `exp` exactly leaves a window where Forge sends a token it
+* believes is good and CMMD has already stopped accepting it: the clocks differ by a
+* little, the request spends time in flight, and the answer comes back 401 on a
+* session that had a perfectly good refresh token sitting next to it. Two
+* minutes is far inside the JWT's own lifetime, so this costs one early
+* rotation and removes the race.
+*/
+const JWT_EXPIRY_SKEW_MS = 2 * 6e4;
+/**
+* Returns true when a stored JWT is at or near its expiry, or has no decodable
+* expiry. CMMD REST JWTs are short-lived bearer tokens, so unknown expiry is
+* not safe.
 */
 function isJwtExpiredForSession(sessionId) {
 	if (!jwtCache.has(sessionId)) return false;
 	const expiresAt = jwtExpiryCache.get(sessionId);
 	if (!expiresAt) return true;
-	return new Date(expiresAt) <= /* @__PURE__ */ new Date();
+	return new Date(expiresAt).getTime() - JWT_EXPIRY_SKEW_MS <= Date.now();
 }
 /**
 * Hydrate the in-memory cache from the configured persistence layer. Call once at server startup
@@ -67445,10 +67686,27 @@ const clearUnrecoverableCmmdAuthForSession = (sessionId) => gen(function* () {
 * Retire refresh credentials copied into historical desktop bearer sessions.
 * Electron owns rotation for native desktop OAuth; Forge Local keeps only the
 * derived access authority needed by the current bearer session.
-*/
-const clearDesktopBearerRefreshTokensForSubject = (subject) => gen(function* () {
-	const normalizedSubject = subject.trim();
-	if (!normalizedSubject) return;
+*
+* Scoped to the bootstrapping client, not to the whole subject. The phone and
+* Electron sign in as the same `user:<id>`, so a subject-wide sweep let one
+* desktop launch null out a phone's refresh token and end its session a day
+* later. Two clauses keep that from happening:
+*
+* - `client_device_type = 'desktop'`, which now excludes phones outright,
+*   because the mobile app declares itself at bootstrap.
+* - the same recorded `client_user_agent` as the bootstrap doing the
+*   retirement, which is the only thing that separates a phone row written
+*   before that stamp existed from a real Electron row. Both are stamped
+*   `desktop`; neither carries any other mark. An empty or unmatched user agent
+*   retires nothing, which is the direction that keeps a live credential.
+*
+* Electron re-bootstraps under a stable user agent, so its own historical rows
+* still match and still get swept.
+*/
+const clearDesktopBearerRefreshTokensForSubject = (input) => gen(function* () {
+	const normalizedSubject = input.subject.trim();
+	const normalizedUserAgent = input.clientUserAgent?.trim() ?? "";
+	if (!normalizedSubject || !normalizedUserAgent) return;
 	const rows = yield* (yield* SqlClient)`
       UPDATE command_access_tokens
       SET
@@ -67461,6 +67719,7 @@ const clearDesktopBearerRefreshTokensForSubject = (subject) => gen(function* ()
           AND role = 'owner'
           AND method = 'bearer-session-token'
           AND client_device_type = 'desktop'
+          AND client_user_agent = ${normalizedUserAgent}
       )
       RETURNING session_id AS "sessionId"
     `.pipe(mapError(toPersistenceSqlError("CommandAccessTokenStore.clearDesktopBearerRefresh:query")));
@@ -67483,6 +67742,17 @@ const OAUTH_STATE_COOKIE = "forge_oauth_state";
 const OAUTH_VERIFIER_COOKIE = "forge_oauth_verifier";
 //#endregion
 //#region src/auth/http/cloudOwnerOAuth.ts
+const FORGE_CLOUD_SESSION_GRANT_COOKIE = "forge_cloud_session_grant";
+function resolveCloudOwnerSessionGrantCookie(input) {
+	const token = input.token?.trim();
+	if (!token || !input.expiresAt) return null;
+	const expiresAt = new Date(input.expiresAt);
+	if (!Number.isFinite(expiresAt.getTime()) || expiresAt.getTime() <= Date.now()) return null;
+	return {
+		token,
+		expiresAt
+	};
+}
 function validateCloudOwnerCallbackAssertion(input) {
 	if (input.serverAuth.isForgeCloudShell?.() !== true) return succeed(null);
 	if (!input.assertionToken || !input.serverAuth.verifyForgeCloudOwnerAssertion) return fail(new AuthError({
@@ -67546,8 +67816,19 @@ function cloudOwnerAssertionCookieOptions(assertion) {
 		secure: true
 	};
 }
-function cloudOwnerOAuthResponse(homeUrl, assertion) {
-	return redirect(homeUrl, { status: 302 }).pipe(setCookie(FORGE_CLOUD_OWNER_ASSERTION_COOKIE, assertion.token, cloudOwnerAssertionCookieOptions(assertion)), flatMap(setCookie(OAUTH_STATE_COOKIE, "", expiredCallbackCookie)), flatMap(setCookie(OAUTH_VERIFIER_COOKIE, "", expiredCallbackCookie)));
+function cloudOwnerSessionGrantCookieOptions(grant) {
+	return {
+		expires: grant.expiresAt,
+		httpOnly: true,
+		path: "/api/auth",
+		sameSite: "lax",
+		secure: true
+	};
+}
+function cloudOwnerOAuthResponse(homeUrl, assertion, sessionGrant) {
+	let response = redirect(homeUrl, { status: 302 }).pipe(setCookie(FORGE_CLOUD_OWNER_ASSERTION_COOKIE, assertion.token, cloudOwnerAssertionCookieOptions(assertion)));
+	if (sessionGrant) response = response.pipe(flatMap(setCookie(FORGE_CLOUD_SESSION_GRANT_COOKIE, sessionGrant.token, cloudOwnerSessionGrantCookieOptions(sessionGrant))));
+	return response.pipe(flatMap(setCookie(OAUTH_STATE_COOKIE, "", expiredCallbackCookie)), flatMap(setCookie(OAUTH_VERIFIER_COOKIE, "", expiredCallbackCookie)));
 }
 //#endregion
 //#region src/auth/http.ts
@@ -67597,6 +67878,56 @@ const authSessionRouteLayer = add$1("GET", "/api/auth/session", gen(function* ()
 	}));
 	return response;
 }));
+const authSessionRenewRouteLayer = add$1("POST", "/api/auth/session/renew", gen(function* () {
+	const request = yield* HttpServerRequest;
+	const serverAuth = yield* ServerAuth;
+	if (serverAuth.isForgeCloudShell?.() !== true) return yield* new AuthError({
+		message: "Session renewal is unavailable.",
+		status: 401
+	});
+	const sessionGrant = request.cookies[FORGE_CLOUD_SESSION_GRANT_COOKIE]?.trim();
+	if (!sessionGrant) return yield* new AuthError({
+		message: "Session renewal is unavailable.",
+		status: 401
+	});
+	const credentials = yield* resolveCmmdTokenBundleCredentials(yield* readCmmdJsonResponse(yield* tryPromise({
+		try: () => fetch(resolveCommandAppEndpoint("/api/mcp-server/oauth/token"), {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				grant_type: "forge_session_grant",
+				grant_token: sessionGrant,
+				client_id: "cmmd-forge-web"
+			})
+		}),
+		catch: (cause) => new AuthError({
+			message: "Failed to renew the Forge Cloud session with CMMD.",
+			status: 500,
+			cause
+		})
+	}), "Failed to renew the Forge Cloud session with CMMD."));
+	const { cmmdIdentity, userId, patToStore } = credentials;
+	if (!cmmdIdentity || !userId || !patToStore) return yield* new AuthError({
+		message: "CMMD did not return a complete renewed Forge session.",
+		status: 500
+	});
+	const assertion = yield* validateCloudOwnerCallbackAssertion({
+		serverAuth,
+		assertionToken: credentials.forgeOwnerAssertion,
+		authenticatedUserId: userId
+	});
+	if (!assertion) return yield* die$1(/* @__PURE__ */ new Error("Expected a renewed Forge Cloud owner assertion."));
+	yield* persistCloudOwnerArtifacts({
+		assertion,
+		accessToken: patToStore,
+		identity: cmmdIdentity,
+		jwtToken: credentials.jwtToStore,
+		refreshToken: credentials.refreshToken,
+		sessionGrant,
+		sessionGrantExpiresAt: void 0
+	});
+	return yield* jsonUnsafe({ renewed: true }, { status: 200 }).pipe(setCookie(FORGE_CLOUD_OWNER_ASSERTION_COOKIE, assertion.token, cloudOwnerAssertionCookieOptions(assertion)));
+}).pipe(catchTag("AuthError", (error) => respondToAuthError(error))));
 const authLogoutRouteLayer = add$1("POST", "/api/auth/logout", gen(function* () {
 	const request = yield* HttpServerRequest;
 	const serverAuth = yield* ServerAuth;
@@ -67619,14 +67950,24 @@ const authLogoutRouteLayer = add$1("POST", "/api/auth/logout", gen(function* ()
 		sameSite: "lax",
 		secure
 	}));
-	if (cloudShell) response = yield* response.pipe(setCookie(FORGE_CLOUD_OWNER_ASSERTION_COOKIE, "", {
-		expires: /* @__PURE__ */ new Date(0),
-		httpOnly: true,
-		maxAge: 0,
-		path: "/",
-		sameSite: "lax",
-		secure: true
-	}));
+	if (cloudShell) {
+		response = yield* response.pipe(setCookie(FORGE_CLOUD_OWNER_ASSERTION_COOKIE, "", {
+			expires: /* @__PURE__ */ new Date(0),
+			httpOnly: true,
+			maxAge: 0,
+			path: "/",
+			sameSite: "lax",
+			secure: true
+		}));
+		response = yield* response.pipe(setCookie(FORGE_CLOUD_SESSION_GRANT_COOKIE, "", {
+			expires: /* @__PURE__ */ new Date(0),
+			httpOnly: true,
+			maxAge: 0,
+			path: "/api/auth",
+			sameSite: "lax",
+			secure: true
+		}));
+	}
 	response = yield* pipeExpireLegacySessionCookie(sessions.cookieName, succeed(response), { secure });
 	if (sessions.cookieName !== "forge_session") response = yield* response.pipe(setCookie(BASE_SESSION_COOKIE_NAME, "", {
 		expires: /* @__PURE__ */ new Date(0),
@@ -67649,7 +67990,8 @@ const CommandBootstrapInput = Struct({
 	refreshToken: optionalKey(String$1),
 	userId: optionalKey(Number$1),
 	displayName: optionalKey(String$1),
-	user: optionalKey(Unknown)
+	user: optionalKey(Unknown),
+	clientDeviceType: optionalKey(Literals(["desktop", "mobile"]))
 });
 const CommandOAuthDeviceInput = Struct({
 	client_id: String$1,
@@ -68115,6 +68457,11 @@ function commandOAuthProxyStatus(path, status, body) {
 }
 const authBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap", gen(function* () {
 	const request = yield* HttpServerRequest;
+	const limited = rateLimitOrRespond({
+		routeClass: "auth-bootstrap",
+		clientKey: clientKeyFromRequest(request)
+	});
+	if (limited) return limited;
 	const serverAuth = yield* ServerAuth;
 	const sessions = yield* SessionCredentialService;
 	const payload = yield* schemaBodyJson(AuthBootstrapInput).pipe(mapError((cause) => new AuthError({
@@ -68132,6 +68479,11 @@ const authBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap", gen(functio
 }).pipe(catchTag("AuthError", (error) => respondToAuthError(error))));
 const authCommandBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap/command", gen(function* () {
 	const request = yield* HttpServerRequest;
+	const limited = rateLimitOrRespond({
+		routeClass: "auth-bootstrap",
+		clientKey: clientKeyFromRequest(request)
+	});
+	if (limited) return limited;
 	const serverAuth = yield* ServerAuth;
 	const sessions = yield* SessionCredentialService;
 	if (serverAuth.isForgeCloudShell?.() === true) return yield* new AuthError({
@@ -68180,6 +68532,11 @@ const authCommandBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap/comman
 }).pipe(catchTag("AuthError", (error) => respondToAuthError(error))));
 const authCommandBearerBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap/command/bearer", gen(function* () {
 	const request = yield* HttpServerRequest;
+	const limited = rateLimitOrRespond({
+		routeClass: "auth-bootstrap",
+		clientKey: clientKeyFromRequest(request)
+	});
+	if (limited) return limited;
 	const serverAuth = yield* ServerAuth;
 	const sessions = yield* SessionCredentialService;
 	if (serverAuth.isForgeCloudShell?.() === true) return yield* new AuthError({
@@ -68197,13 +68554,10 @@ const authCommandBearerBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap/
 		method: "bearer-session-token",
 		role: "owner",
 		subject: sessionSubject,
-		client: {
-			...deriveAuthClientMetadata({
-				request,
-				label: "Forge Desktop Cloud"
-			}),
-			deviceType: "desktop"
-		}
+		client: resolveCommandBootstrapClient({
+			request,
+			clientDeviceType: payload.clientDeviceType
+		})
 	}).pipe(mapError((cause) => new AuthError({
 		message: "Failed to issue authenticated bearer session.",
 		cause
@@ -68213,7 +68567,10 @@ const authCommandBearerBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap/
 		payload,
 		cmmdIdentity: validated.cmmdIdentity
 	});
-	if (!payload.refreshToken?.trim()) yield* clearDesktopBearerRefreshTokensForSubject(sessionSubject).pipe(mapError((cause) => new AuthError({
+	if ((payload.clientDeviceType ?? "desktop") === "desktop" && !payload.refreshToken?.trim()) yield* clearDesktopBearerRefreshTokensForSubject({
+		subject: sessionSubject,
+		clientUserAgent: request.headers["user-agent"]
+	}).pipe(mapError((cause) => new AuthError({
 		message: "Failed to retire legacy desktop refresh credentials.",
 		status: 500,
 		cause
@@ -68228,6 +68585,11 @@ const authCommandBearerBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap/
 	}, { status: 200 });
 }).pipe(catchTag("AuthError", (error) => respondToAuthError(error))));
 const authCmmdOAuthDeviceRouteLayer = add$1("POST", "/api/auth/cmmd-oauth/device", gen(function* () {
+	const limited = rateLimitOrRespond({
+		routeClass: "auth-device-poll",
+		clientKey: clientKeyFromRequest(yield* HttpServerRequest)
+	});
+	if (limited) return limited;
 	const payload = yield* schemaBodyJson(CommandOAuthDeviceInput).pipe(mapError((cause) => new AuthError({
 		message: "Invalid CMMD OAuth device payload.",
 		status: 400,
@@ -68239,7 +68601,17 @@ const authCmmdOAuthDeviceRouteLayer = add$1("POST", "/api/auth/cmmd-oauth/device
 		...payload.scope ? { scope: payload.scope } : {}
 	});
 }).pipe(catchTag("AuthError", (error) => respondToAuthError(error))));
+/**
+* The device-code poll. Called every `interval` seconds by design (RFC
+* 8628), which is exactly why FOR-36706 puts a limiter on it: a client that
+* ignores `slow_down` — a bug, not a person — has no other backstop here.
+*/
 const authCmmdOAuthTokenRouteLayer = add$1("POST", "/api/auth/cmmd-oauth/token", gen(function* () {
+	const limited = rateLimitOrRespond({
+		routeClass: "auth-device-poll",
+		clientKey: clientKeyFromRequest(yield* HttpServerRequest)
+	});
+	if (limited) return limited;
 	const payload = yield* schemaBodyJson(CommandOAuthTokenInput).pipe(mapError((cause) => new AuthError({
 		message: "Invalid CMMD OAuth token payload.",
 		status: 400,
@@ -68281,6 +68653,14 @@ function completeCloudOwnerPasswordLogin(input) {
 			authenticatedUserId: userId
 		});
 		if (!assertion) return yield* die$1(/* @__PURE__ */ new Error("Expected a Forge Cloud owner assertion in cloud shell mode."));
+		const sessionGrant = resolveCloudOwnerSessionGrantCookie({
+			token: credentials.sessionGrant,
+			expiresAt: credentials.sessionGrantExpiresAt
+		});
+		if (!sessionGrant) return yield* new AuthError({
+			message: "CMMD did not return a durable Forge Cloud session grant.",
+			status: 500
+		});
 		yield* persistCloudOwnerArtifacts({
 			assertion,
 			accessToken: patToStore,
@@ -68290,10 +68670,12 @@ function completeCloudOwnerPasswordLogin(input) {
 			sessionGrant: credentials.sessionGrant,
 			sessionGrantExpiresAt: credentials.sessionGrantExpiresAt
 		});
-		return yield* jsonUnsafe({
+		let response = jsonUnsafe({
 			authenticated: true,
 			cmmdIdentity
 		}, { status: 200 }).pipe(setCookie(FORGE_CLOUD_OWNER_ASSERTION_COOKIE, assertion.token, cloudOwnerAssertionCookieOptions(assertion)));
+		if (sessionGrant) response = response.pipe(flatMap(setCookie(FORGE_CLOUD_SESSION_GRANT_COOKIE, sessionGrant.token, cloudOwnerSessionGrantCookieOptions(sessionGrant))));
+		return yield* response;
 	});
 }
 const authCmmdPasswordTokenRouteLayer = add$1("POST", "/api/auth/cmmd-password/token", gen(function* () {
@@ -68467,6 +68849,14 @@ const authWebCallbackRouteLayer = add$1("GET", "/api/auth/callback", gen(functio
 		assertionToken: forgeOwnerAssertion,
 		authenticatedUserId: userId
 	});
+	const cloudSessionGrant = cloudOwnerAssertion ? resolveCloudOwnerSessionGrantCookie({
+		token: sessionGrant,
+		expiresAt: sessionGrantExpiresAt
+	}) : null;
+	if (cloudOwnerAssertion && !cloudSessionGrant) return yield* new AuthError({
+		message: "CMMD did not return a durable Forge Cloud session grant.",
+		status: 500
+	});
 	const sessionSubject = resolveCommandOAuthSubject(userId);
 	const issued = cloudOwnerAssertion ? null : yield* sessions.issue({
 		method: "browser-session-cookie",
@@ -68498,7 +68888,7 @@ const authWebCallbackRouteLayer = add$1("GET", "/api/auth/callback", gen(functio
 	else yield* persistLocalOAuthArtifacts(persistenceInput);
 	const homeUrl = `${publicUrl}/`;
 	const secureCookie = shouldUseSecureCookie(publicUrl);
-	if (cloudOwnerAssertion) return yield* cloudOwnerOAuthResponse(homeUrl, cloudOwnerAssertion);
+	if (cloudOwnerAssertion) return yield* cloudOwnerOAuthResponse(homeUrl, cloudOwnerAssertion, cloudSessionGrant);
 	if (!issued) return yield* die$1(/* @__PURE__ */ new Error("Expected a local session outside Forge Cloud."));
 	return yield* pipeExpireLegacySessionCookie(sessions.cookieName, redirect(homeUrl, { status: 302 }).pipe(setCookie(sessions.cookieName, issued.token, {
 		expires: toDate(issued.expiresAt),
@@ -68516,6 +68906,11 @@ const authWebCallbackRouteLayer = add$1("GET", "/api/auth/callback", gen(functio
 }).pipe(catchTag("AuthError", (error) => respondToAuthError(error))));
 const authBearerBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap/bearer", gen(function* () {
 	const request = yield* HttpServerRequest;
+	const limited = rateLimitOrRespond({
+		routeClass: "auth-bootstrap",
+		clientKey: clientKeyFromRequest(request)
+	});
+	if (limited) return limited;
 	const serverAuth = yield* ServerAuth;
 	const payload = yield* schemaBodyJson(AuthBootstrapInput).pipe(mapError((cause) => new AuthError({
 		message: "Invalid bootstrap payload.",
@@ -68547,6 +68942,11 @@ const authBearerBootstrapRouteLayer = add$1("POST", "/api/auth/bootstrap/bearer"
 */
 const authOAuthTokenExchangeRouteLayer = add$1("POST", "/oauth/token", gen(function* () {
 	const request = yield* HttpServerRequest;
+	const limited = rateLimitOrRespond({
+		routeClass: "auth-token-exchange",
+		clientKey: clientKeyFromRequest(request)
+	});
+	if (limited) return limited;
 	const serverAuth = yield* ServerAuth;
 	const payload = yield* schemaBodyUrlParams(OAuthTokenExchangeInput).pipe(mapError((cause) => new AuthError({
 		message: "Invalid token exchange payload.",
@@ -70518,6 +70918,11 @@ function redeemCmmdSessionGrant(grantToken) {
 		};
 	}).catch(() => null);
 }
+const REJECTED_OAUTH_ERROR_CODES = new Set([
+	"invalid_grant",
+	"invalid_client",
+	"invalid_request"
+]);
 /**
 * Rotate a CMMD refresh token into a fresh access JWT.
 *
@@ -70530,7 +70935,7 @@ function redeemCmmdSessionGrant(grantToken) {
 * code are what identify the failure, and `invalid_grant` in particular means
 * the token was already spent, which is a different fix from a 500.
 */
-function refreshCmmdJwt(refreshToken) {
+function refreshCmmdJwt(refreshToken, observer) {
 	return fetch(new URL("/api/mcp-server/oauth/token", resolveCommandAppUrl()).toString(), {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
@@ -70541,7 +70946,9 @@ function refreshCmmdJwt(refreshToken) {
 		})
 	}).then(async (response) => {
 		if (!response.ok) {
-			console.warn(`[cmmd-auth] CMMD refused a JWT rotation with ${response.status}${await readOAuthError(response)}`);
+			const errorCode = await readOAuthErrorCode(response);
+			if (errorCode !== null && REJECTED_OAUTH_ERROR_CODES.has(errorCode)) observer?.onCredentialRejected?.();
+			console.warn(`[cmmd-auth] CMMD refused a JWT rotation with ${response.status}${errorCode === null ? "" : ` (${errorCode})`}`);
 			return null;
 		}
 		const parsed = parseCmmdOAuthRefreshResponse(await response.json());
@@ -70553,20 +70960,73 @@ function refreshCmmdJwt(refreshToken) {
 	});
 }
 /**
-* The OAuth `error` code from a refusal, as a loggable suffix.
+* The OAuth `error` code from a refusal, lowercased, or null when there is none.
 *
 * Best effort by design: a body that is not JSON, or is already consumed, must
-* not turn a logged failure into an unlogged one.
+* not turn a logged failure into an unlogged one. Null also reads correctly as
+* "no evidence the credential is dead", which is the safe answer for a caller
+* deciding whether to keep a refresh token.
 */
-async function readOAuthError(response) {
+async function readOAuthErrorCode(response) {
 	try {
 		const code = (await response.json())["error"];
-		return typeof code === "string" && code.trim().length > 0 ? ` (${code.trim()})` : "";
+		return typeof code === "string" && code.trim().length > 0 ? code.trim().toLowerCase() : null;
 	} catch {
-		return "";
+		return null;
 	}
 }
 //#endregion
+//#region src/command/cmmdRotationFence.ts
+/**
+* True when Forge must not rotate this session's CMMD credentials.
+*
+* Fails closed: if the session row cannot be read, assume the fence applies.
+* Spending a token Forge had no right to spend is worse than one extra
+* reconnect.
+*/
+function isRotationFencedSession(sessionId) {
+	if (readCommandRefreshTokenForSession(sessionId)) return succeed(false);
+	return isDesktopBearerAuthSession(sessionId).pipe(orElseSucceed(() => true));
+}
+//#endregion
+//#region src/cmmdConnection/cmmdCredentialRejection.ts
+/**
+* How long a recorded rejection stays usable.
+*
+* Long enough to span the resolver ladder and the response that follows it,
+* short enough that it cannot outlive the credential it describes.
+*/
+const REJECTION_TTL_MS = 6e4;
+const rejectedAt = /* @__PURE__ */ new Map();
+/** Record that CMMD refused this session's credential outright. */
+function noteCmmdCredentialRejected(sessionId) {
+	rejectedAt.set(sessionId, Date.now());
+}
+/** Whether CMMD refused this session's credential recently enough to act on. */
+function hasCmmdCredentialRejection(sessionId) {
+	const observedAt = rejectedAt.get(sessionId);
+	if (observedAt === void 0) return false;
+	if (Date.now() - observedAt <= REJECTION_TTL_MS) return true;
+	rejectedAt.delete(sessionId);
+	return false;
+}
+/** Drop a recorded rejection, once it has been acted on or superseded. */
+function forgetCmmdCredentialRejection(sessionId) {
+	rejectedAt.delete(sessionId);
+}
+/**
+* Clear a session's CMMD credentials, but only if CMMD rejected them.
+*
+* This is the only door the 401 path may use. A resolver that returned null
+* because it was not allowed to try is a policy refusal and leaves the stored
+* credential exactly where it is, so the next request can rotate it.
+*/
+const clearCmmdAuthAfterCmmdRejection = (sessionId) => gen(function* () {
+	if (!hasCmmdCredentialRejection(sessionId)) return;
+	yield* clearUnrecoverableCmmdAuthForSession(sessionId);
+	forgetCmmdCredentialRejection(sessionId);
+});
+//#endregion
 //#region src/command/cmmdJwtResolver.ts
 function usableCmmdUserJwt(token) {
 	return isCmmdUserAccessJwt(token) ? token : null;
@@ -70579,7 +71039,7 @@ function refreshOnceForSession(sessionId, refreshToken) {
 	return promise(() => {
 		const existing = inFlightRefreshes.get(sessionId);
 		if (existing) return existing;
-		const pending = refreshCmmdJwt(refreshToken).catch(() => null).finally(() => {
+		const pending = refreshCmmdJwt(refreshToken, { onCredentialRejected: () => noteCmmdCredentialRejected(sessionId) }).catch(() => null).finally(() => {
 			inFlightRefreshes.delete(sessionId);
 		});
 		inFlightRefreshes.set(sessionId, pending);
@@ -70689,13 +71149,16 @@ function trySubjectFallback(sessionId, subject, logPrefix) {
 * Fail-closed: never returns a non-user / malformed Bearer. Callers must map
 * null to CMMD_AUTH_REQUIRED and must not call CMMD upstream with a bad token.
 */
-function resolveCmmdJwtForSession({ sessionId, subject, logPrefix = "cmmd-auth", forceRefresh = false }) {
+function resolveCmmdJwtForSession({ sessionId, subject, logPrefix = "cmmd-auth", forceRefresh = false, staleAccessToken = null }) {
 	const cached = usableCmmdUserJwt(readCommandJwtForSession(sessionId));
-	if (!forceRefresh && cached && !isJwtExpiredForSession(sessionId)) return succeed(cached);
+	if (cached && !isJwtExpiredForSession(sessionId)) {
+		if (!forceRefresh) return succeed(cached);
+		if (staleAccessToken && cached !== staleAccessToken) return succeed(cached);
+	}
 	const normalizedSubject = subject?.trim() || null;
 	if (!normalizedSubject && !forceRefresh) return succeed(null);
 	return gen(function* () {
-		if (yield* isDesktopBearerAuthSession(sessionId).pipe(orElseSucceed(() => true))) return null;
+		if (yield* isRotationFencedSession(sessionId)) return null;
 		if (forceRefresh) {
 			const forced = yield* tryOwnCredentialRecovery(sessionId, logPrefix);
 			if (forced) return forced;
@@ -71454,15 +71917,25 @@ function clearCmmdAuthAfterFailure(sessionId) {
 	})));
 }
 /**
-* The single "no usable CMMD credential" response: clears whatever
-* unrecoverable auth state this session is holding, then returns the
-* canonical `CMMD_AUTH_REQUIRED` body. Every prologue path that decides the
-* session has no way to reach CMMD — a missing PAT, a JWT that fails to
-* resolve, a bespoke gate elsewhere in http.ts — emits this same response so
-* the Shell only ever has one `CMMD_AUTH_REQUIRED` body to branch on.
+* The single "no usable CMMD credential" response: returns the canonical
+* `CMMD_AUTH_REQUIRED` body. Every prologue path that decides the session has
+* no way to reach CMMD — a missing PAT, a JWT that fails to resolve, a bespoke
+* gate elsewhere in http.ts — emits this same response so the Shell only ever
+* has one `CMMD_AUTH_REQUIRED` body to branch on.
+*
+* It used to delete the session's stored credentials on the way out, and that
+* was the wrong reading of its own argument. Most of the paths that reach here
+* are refusals, not rejections: the resolver was fenced, the subject was
+* missing, a gate said no. A phone would arrive holding a refresh token good
+* for the next three months, be refused by a rule, and have that token deleted
+* as "unrecoverable". The clear now happens only where CMMD has actually
+* refused the credential, which `clearCmmdAuthAfterCmmdRejection` checks.
 */
 function respondCmmdConnectionRequired(sessionId) {
-	return clearCmmdAuthAfterFailure(sessionId).pipe(as$3(buildProxyErrorResponse(new CmmdProxyAuthenticationRequiredError("CMMD connection required. Reconnect CMMD to continue."))));
+	return clearCmmdAuthAfterCmmdRejection(sessionId).pipe(catch_((error) => logWarning$1("Failed to clear CMMD auth that CMMD itself rejected.", {
+		cause: error,
+		sessionId
+	})), as$3(buildProxyErrorResponse(new CmmdProxyAuthenticationRequiredError("CMMD connection required. Reconnect CMMD to continue."))));
 }
 async function dispatchToProxy(method, jwt, cmmdPath, rawBody, orgId, searchParams) {
 	return cmmdGateway.request({
@@ -71518,6 +71991,11 @@ function buildProxyRouteLayer(route) {
 	const handler = gen(function* () {
 		const req = yield* HttpServerRequest;
 		const session = yield* (yield* ServerAuth).authenticateHttpRequest(req);
+		const limited = rateLimitOrRespond({
+			routeClass: "cmmd-proxy",
+			clientKey: session.sessionId
+		});
+		if (limited) return limited;
 		const pathParams = yield* params;
 		const cmmdPath = substitutePath(route.cmmdPath, pathParams);
 		if (!cmmdPath) return jsonUnsafe({ error: "Missing required path parameter." }, { status: 400 });
@@ -71577,6 +72055,11 @@ function buildProxyHandlerEffect(route) {
 	return gen(function* () {
 		const req = yield* HttpServerRequest;
 		const session = yield* (yield* ServerAuth).authenticateHttpRequest(req);
+		const limited = rateLimitOrRespond({
+			routeClass: "cmmd-proxy",
+			clientKey: session.sessionId
+		});
+		if (limited) return limited;
 		if (!readCommandAccessTokenForSession(session.sessionId)) return yield* respondCmmdConnectionRequired(session.sessionId);
 		const parsed = yield* route.parse(req);
 		if (!parsed.ok) return jsonUnsafe(parsed.body, { status: parsed.status });
@@ -75215,7 +75698,7 @@ var require_node_gyp_build = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	var fs$6 = __require("fs");
 	var path$5 = __require("path");
 	var url$1 = __require("url");
-	var os$2 = __require("os");
+	var os$3 = __require("os");
 	var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
 	var vars = process.config && process.config.variables || {};
 	var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
@@ -75223,8 +75706,8 @@ var require_node_gyp_build = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	var abi = versions.modules;
 	if (versions.deno || process.isBun) abi = "unsupported";
 	var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
-	var arch = process.env.npm_config_arch || os$2.arch();
-	var platform = process.env.npm_config_platform || os$2.platform();
+	var arch = process.env.npm_config_arch || os$3.arch();
+	var platform = process.env.npm_config_platform || os$3.platform();
 	var libc = process.env.LIBC || (isMusl(platform) ? "musl" : "glibc");
 	var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
 	var uv = (versions.uv || "").split(".")[0];
@@ -83346,12 +83829,12 @@ const makePullRequestService = gen(function* () {
 	}));
 	const submitReview = (input) => requireProject(input).pipe(flatMap((project) => {
 		const review = project.api.capabilities.review;
-		if (!review.verdicts.includes(input.verdict)) return refuse(`This host cannot ${VERDICT_LABELS[input.verdict]} a change request.`);
-		if (input.comments.length > 0 && !review.inlineComment) return refuse("This host cannot comment on a line of a change request.");
-		if (input.verdict !== "approve" && input.body.trim().length === 0 && input.comments.length === 0) return refuse("A review needs a summary or at least one comment.");
+		if (!review.verdicts.includes(input.verdict)) return refuse$1(`This host cannot ${VERDICT_LABELS[input.verdict]} a change request.`);
+		if (input.comments.length > 0 && !review.inlineComment) return refuse$1("This host cannot comment on a line of a change request.");
+		if (input.verdict !== "approve" && input.body.trim().length === 0 && input.comments.length === 0) return refuse$1("A review needs a summary or at least one comment.");
 		return viewerPermissionsOf(project, input, "submitReview").pipe(flatMap((viewer) => {
-			if (!viewer.verdicts.includes(input.verdict)) return refuse(`You need write access on this repository to ${VERDICT_LABELS[input.verdict]} a change request.`);
-			if (input.comments.length > 0 && !viewer.comment) return refuse("You need write access on this repository to comment on a line of a change request.");
+			if (!viewer.verdicts.includes(input.verdict)) return refuse$1(`You need write access on this repository to ${VERDICT_LABELS[input.verdict]} a change request.`);
+			if (input.comments.length > 0 && !viewer.comment) return refuse$1("You need write access on this repository to comment on a line of a change request.");
 			return project.api.submitReview({
 				projectId: project.project.id,
 				cwd: project.project.workspaceRoot,
@@ -83748,7 +84231,7 @@ const toEntry = (input) => {
 		...input.item.reviewDecision === void 0 || input.item.reviewDecision === null ? {} : { reviewDecision: input.item.reviewDecision }
 	};
 };
-const refuse = (detail) => fail(new PullRequestOperationError({
+const refuse$1 = (detail) => fail(new PullRequestOperationError({
 	operation: "submitReview",
 	detail
 }));
@@ -93406,7 +93889,7 @@ const launchDetached = (launch) => gen(function* () {
 });
 const OpenLive = effect(Open, gen(function* () {
 	const open = yield* tryPromise({
-		try: () => import("./open-D8mGyWmt.mjs"),
+		try: () => import("./open-FIgTDosf.mjs"),
 		catch: (cause) => new OpenError$1({
 			message: "failed to load browser opener",
 			cause
@@ -93590,6 +94073,166 @@ const admitNormalizedDispatchCommand = (command, admit) => uninterruptibleMask$1
 	};
 }));
 //#endregion
+//#region src/orchestration/threadDetailWindow.ts
+function earliest(current, candidate) {
+	return current === void 0 || candidate < current ? candidate : current;
+}
+/**
+* Every turn in the thread, oldest first.
+*
+* Ordering is by the earliest timestamp across all four windowed collections
+* rather than by message order alone: a turn can open with an activity (a tool
+* call before any text) and a checkpoint-only turn has no message at all.
+* Ties break on turn id so the order is total and a cursor means the same thing
+* on every read.
+*/
+function orderThreadTurns(thread) {
+	const anchors = /* @__PURE__ */ new Map();
+	const touch = (turnId, at, isUserMessage) => {
+		if (turnId === null) return;
+		const existing = anchors.get(turnId);
+		anchors.set(turnId, {
+			at: earliest(existing?.at, at),
+			hasUserMessage: (existing?.hasUserMessage ?? false) || isUserMessage
+		});
+	};
+	for (const message of thread.messages) touch(message.turnId, message.createdAt, message.role === "user");
+	for (const activity of thread.activities) touch(activity.turnId, activity.createdAt, false);
+	for (const plan of thread.proposedPlans) touch(plan.turnId, plan.createdAt, false);
+	for (const checkpoint of thread.checkpoints) touch(checkpoint.turnId, checkpoint.completedAt, false);
+	return Array.from(anchors, ([turnId, anchor]) => ({
+		turnId,
+		...anchor
+	})).toSorted((left, right) => left.at === right.at ? left.turnId.localeCompare(right.turnId) : left.at < right.at ? -1 : 1);
+}
+/**
+* Index of the first turn to include, counting back `turnLimit` user-anchored
+* turns from the end of `ordered`. Returns 0 when the thread holds fewer user
+* turns than the limit, which is how a short thread comes back whole.
+*/
+function windowStartIndex(ordered, turnLimit) {
+	let userTurns = 0;
+	for (let index = ordered.length - 1; index >= 0; index -= 1) {
+		const anchor = ordered[index];
+		if (anchor !== void 0 && anchor.hasUserMessage) {
+			userTurns += 1;
+			if (userTurns === turnLimit) return index;
+		}
+	}
+	return 0;
+}
+/**
+* The turns a windowed read returns.
+*
+* `beforeCursor` bounds the read to turns strictly older than a cursor an
+* earlier read handed out, which is what "load earlier" sends back. A cursor
+* naming a turn this thread no longer holds, after a revert, say, yields an
+* empty page rather than the whole thread: returning everything would be a
+* silent full download at the exact moment the client asked for less.
+*/
+function selectWindowTurnIds(ordered, window) {
+	const cursorIndex = window.beforeCursor === void 0 ? ordered.length : ordered.findIndex((anchor) => anchor.turnId === window.beforeCursor);
+	if (cursorIndex < 0) return {
+		turnIds: /* @__PURE__ */ new Set(),
+		beforeCursor: null,
+		hasMore: false,
+		includeUnanchored: false
+	};
+	const candidates = ordered.slice(0, cursorIndex);
+	const startIndex = window.turnLimit === void 0 ? 0 : windowStartIndex(candidates, window.turnLimit);
+	const included = candidates.slice(startIndex);
+	const oldest = included[0];
+	return {
+		turnIds: new Set(included.map((anchor) => anchor.turnId)),
+		beforeCursor: oldest?.turnId ?? null,
+		hasMore: startIndex > 0,
+		includeUnanchored: startIndex === 0
+	};
+}
+function keepsTurn(selection, turnId) {
+	return turnId === null ? selection.includeUnanchored : selection.turnIds.has(turnId);
+}
+/**
+* Applies a turn window to a full thread detail read.
+*
+* A request with neither field is a full read and comes back untouched with no
+* page, which is exactly what a pre-pagination client already receives. Only
+* the four turn-scoped collections are filtered; thread metadata, the session,
+* and `latestTurn` describe the thread as a whole and stay as they are, so a
+* windowed snapshot still renders a correct header and a correct running state.
+*/
+function windowThreadDetail(input) {
+	const { thread, window, snapshotSequence } = input;
+	if (window.turnLimit === void 0 && window.beforeCursor === void 0) return {
+		thread,
+		page: void 0
+	};
+	const selection = selectWindowTurnIds(orderThreadTurns(thread), window);
+	return {
+		thread: {
+			...thread,
+			messages: thread.messages.filter((row) => keepsTurn(selection, row.turnId)),
+			activities: thread.activities.filter((row) => keepsTurn(selection, row.turnId)),
+			proposedPlans: thread.proposedPlans.filter((row) => keepsTurn(selection, row.turnId)),
+			checkpoints: thread.checkpoints.filter((row) => keepsTurn(selection, row.turnId)),
+			...thread.turnModelSelections === void 0 ? {} : { turnModelSelections: thread.turnModelSelections.filter((row) => keepsTurn(selection, row.turnId)) }
+		},
+		page: {
+			beforeCursor: selection.hasMore ? selection.beforeCursor : null,
+			hasMore: selection.hasMore,
+			snapshotSequence
+		}
+	};
+}
+/** Whether a subscriber's cursor can be served by replay rather than a snapshot. */
+function canResumeFromSequence(input) {
+	if (input.afterSequence > input.currentSequence) return false;
+	return input.currentSequence - input.afterSequence <= (input.maxGap ?? 2e3);
+}
+function snapshotCatchUp(snapshot) {
+	return {
+		items: [{
+			kind: "snapshot",
+			snapshot
+		}],
+		watermark: snapshot.snapshotSequence
+	};
+}
+function replayCatchUp(events, afterSequence) {
+	return {
+		items: events.map((event) => ({
+			kind: "event",
+			event
+		})),
+		watermark: events.at(-1)?.sequence ?? afterSequence
+	};
+}
+/**
+* Builds the frames that precede live events: either the replayed catch-up or
+* the snapshot, plus the completion marker when one was asked for.
+*/
+const buildCatchUp = fn$1("threadSubscription.buildCatchUp")(function* (input, sources) {
+	const afterSequence = input.afterSequence;
+	if (afterSequence === void 0) return snapshotCatchUp(yield* sources.loadSnapshot);
+	if (!canResumeFromSequence({
+		afterSequence,
+		currentSequence: yield* sources.currentSequence
+	})) return snapshotCatchUp(yield* sources.loadSnapshot);
+	const replayed = yield* runCollect(sources.replayEvents(afterSequence));
+	return replayCatchUp(Array.from(replayed), afterSequence);
+});
+function makeThreadSubscriptionStream(input, sources) {
+	return unwrap$1(gen(function* () {
+		const liveEvents = yield* sources.subscribeLiveEvents;
+		const catchUp = yield* buildCatchUp(input, sources);
+		const marker = input.requestCompletionMarker === true ? [{ kind: "synchronized" }] : [];
+		return concat$2(fromArray([...catchUp.items, ...marker]), liveEvents.pipe(filter$2((event) => event.sequence > catchUp.watermark), map$7((event) => ({
+			kind: "event",
+			event
+		}))));
+	}));
+}
+//#endregion
 //#region src/orchestration/bootstrapCommandCoordinator.ts
 const MAX_COMPLETED_COMMANDS_PER_ENGINE = 256;
 const commandsByEngine = /* @__PURE__ */ new WeakMap();
@@ -97243,6 +97886,26 @@ function serializeNativeToolActivity(activity) {
 		}
 	};
 }
+function serializeWorktreeLaunchActivity(activity) {
+	if (decodeWorktreeLaunchActivityKind(activity.kind) === null) return null;
+	const summary = text(activity.summary, 4e3);
+	if (summary === null) return null;
+	return {
+		sourceSequence: null,
+		event: {
+			eventId: `activity:${activity.id}`,
+			occurredAt: canonicalRuntimeEventTimestamp(activity.createdAt),
+			...eventTurn(activity.turnId),
+			kind: "tool_call",
+			summary,
+			status: "completed",
+			payload: encodeCmmdRuntimeWorktreeLaunchActivityPayload(activity.kind, activity.payload)
+		}
+	};
+}
+function decodeWorktreeLaunchActivityKind(kind) {
+	return isCmmdRuntimeWorktreeLaunchActivityKind(kind) ? kind : null;
+}
 function isReplicatedFailureActivity(activity) {
 	return activity.kind === "runtime.error" || activity.kind.startsWith("provider.") && activity.kind.endsWith(".failed");
 }
@@ -97623,12 +98286,17 @@ function serializeRuntimeThreadEvents(thread) {
 		const event = serializeNativeToolActivity(activity);
 		return event === null ? [] : [event];
 	});
+	const worktreeLaunchActivities = thread.activities.flatMap((activity) => {
+		const event = serializeWorktreeLaunchActivity(activity);
+		return event === null ? [] : [event];
+	});
 	const recordedTurns = serializeRecordedTurns(thread);
 	const textGenerations = serializeTextGenerations(thread);
 	return [
 		...messages,
 		...replicaActivities,
 		...toolActivities,
+		...worktreeLaunchActivities,
 		...failureActivities,
 		...recordedTurns,
 		...textGenerations
@@ -101904,7 +102572,7 @@ function claudeReadinessReasonCode(reason) {
 //#endregion
 //#region src/egress/providerDeliveryReceipt.ts
 const PROVIDER_ACCOUNT_IDENTITY$2 = /^pai_v1_[A-Za-z0-9_-]{43}$/;
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const UUID$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const RFC3339$1 = /^(\d{4})-(\d{2})-(\d{2})T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
 const RECEIPT_KEYS = new Set([
 	"receiptId",
@@ -101987,7 +102655,7 @@ function claudeAccountFields(value) {
 }
 function parseClaudeDeliveryIdentity(value) {
 	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;
+	if (!account || !hasAllowedKeys(value, CLAUDE_IDENTITY_KEYS, CLAUDE_IDENTITY_OPTIONAL_KEYS) || value.kind !== "credential_generation" || value.provider !== "claude" || typeof value.credentialGenerationId !== "string" || !UUID$1.test(value.credentialGenerationId)) return null;
 	return {
 		kind: "credential_generation",
 		provider: "claude",
@@ -102754,7 +103422,10 @@ function extractClaudeProviderAccountId(response) {
 	if (typeof response !== "object" || response === null || !("data" in response)) return null;
 	const data = response.data;
 	if (typeof data !== "object" || data === null) return null;
-	if ("connected" in data && data.connected === true) return extractClaudeCredentialGenerationId(response);
+	if ("connected" in data && data.connected === true) {
+		if ("providerAccountId" in data) return asNonEmptyString$1(data.providerAccountId) ?? null;
+		return extractClaudeCredentialGenerationId(response);
+	}
 	if (!("account" in data)) return null;
 	const account = data.account;
 	if (typeof account !== "object" || account === null || !("providerAccountId" in account) || typeof account.providerAccountId !== "string") return null;
@@ -105726,6 +106397,14 @@ function makeRelayCommandInboxRepository(sql) {
 function isThreadDetailEvent(event) {
 	return event.type === "thread.message-sent" || event.type === "thread.proposed-plan-upserted" || event.type === "thread.activity-appended" || event.type === "thread.turn-diff-completed" || event.type === "thread.reverted" || event.type === "thread.session-set" || event.type === "thread.rate-limit-set";
 }
+/**
+* Narrows the domain-event feed to one thread's stream-visible events. The same
+* predicate guards the live feed and the resume replay, so a subscriber cannot
+* be handed a different set of events depending on which path served it.
+*/
+function isThreadDetailEventFor(threadId) {
+	return (event) => event.aggregateKind === "thread" && event.aggregateId === threadId && isThreadDetailEvent(event);
+}
 const PROVIDER_STATUS_DEBOUNCE_MS = 200;
 function streamBoundedText(contents) {
 	if (Buffer.byteLength(contents, "utf8") > 16777216) return fail(new BulkTransferError({
@@ -105771,6 +106450,39 @@ function loadInitialShellSnapshot(input) {
 		return yield* input.projectionSnapshotQuery.getShellSnapshot();
 	});
 }
+/**
+* The thread snapshot a subscription falls back to, windowed when the
+* subscriber asked for a window. A missing thread is a failure rather than an
+* empty snapshot: the subscriber asked about a thread this server does not
+* have, and saying so is the only honest answer.
+*
+* Also the read behind `getThreadDetailPage`, the socket RPC a relay-only
+* connection uses for "load earlier turns" in place of the HTTP snapshot
+* route: same window, same pure `windowThreadDetail`, so the two reads cannot
+* disagree about what a page is.
+*/
+function loadThreadDetailSnapshot(input) {
+	return gen(function* () {
+		const [threadDetail, snapshotSequence] = yield* all([input.projectionSnapshotQuery.getThreadDetailById(input.threadId).pipe(mapError((cause) => new OrchestrationGetSnapshotError({
+			message: `Failed to load thread ${input.threadId}`,
+			cause
+		}))), input.orchestrationEngine.getReadModel().pipe(map$3((readModel) => readModel.snapshotSequence))]);
+		if (isNone(threadDetail)) return yield* new OrchestrationGetSnapshotError({
+			message: `Thread ${input.threadId} was not found`,
+			cause: input.threadId
+		});
+		const windowed = windowThreadDetail({
+			thread: threadDetail.value,
+			window: input.window,
+			snapshotSequence
+		});
+		return {
+			snapshotSequence,
+			thread: windowed.thread,
+			...windowed.page === void 0 ? {} : { page: windowed.page }
+		};
+	});
+}
 function makeSnapshotThenLiveStream(input) {
 	return unwrap$1(gen(function* () {
 		const liveEvents = yield* input.subscribeLiveEvents;
@@ -106017,6 +106729,9 @@ const makeWsRpcLayer = (currentSessionId, currentUserId) => WsRpcGroup.toLayer(g
 				shellRevealInFileManager: true,
 				shellRevealInFileManagerKind: fileManagerRevealKind
 			},
+			threadResumeCompletionMarker: true,
+			threadSnapshotPagination: true,
+			threadDetailPageRpc: true,
 			observability: {
 				logsDirectoryPath: config.logsDir,
 				localTracingEnabled: true,
@@ -106114,26 +106829,28 @@ const makeWsRpcLayer = (currentSessionId, currentUserId) => WsRpcGroup.toLayer(g
 				projectionSnapshotQuery
 			})), flatMap$3((event) => isSome(event) ? succeed$4(event.value) : empty$5))))
 		})), { "rpc.aggregate": "orchestration" }),
-		[ORCHESTRATION_WS_METHODS.subscribeThread]: (input) => observeRpcStreamEffect(ORCHESTRATION_WS_METHODS.subscribeThread, gen(function* () {
-			const [threadDetail, snapshotSequence] = yield* all([projectionSnapshotQuery.getThreadDetailById(input.threadId).pipe(mapError((cause) => new OrchestrationGetSnapshotError({
-				message: `Failed to load thread ${input.threadId}`,
+		[ORCHESTRATION_WS_METHODS.subscribeThread]: (input) => observeRpcStreamEffect(ORCHESTRATION_WS_METHODS.subscribeThread, succeed(makeThreadSubscriptionStream(input, {
+			subscribeLiveEvents: orchestrationEngine.subscribeDomainEvents().pipe(map$3((events) => events.pipe(filter$2(isThreadDetailEventFor(input.threadId))))),
+			currentSequence: orchestrationEngine.getReadModel().pipe(map$3((readModel) => readModel.snapshotSequence)),
+			loadSnapshot: loadThreadDetailSnapshot({
+				threadId: input.threadId,
+				window: input.turnLimit === void 0 ? {} : { turnLimit: input.turnLimit },
+				projectionSnapshotQuery,
+				orchestrationEngine
+			}),
+			replayEvents: (afterSequence) => orchestrationEngine.readEvents(afterSequence).pipe(filter$2(isThreadDetailEventFor(input.threadId)), mapError$1((cause) => new OrchestrationGetSnapshotError({
+				message: `Failed to replay thread ${input.threadId}`,
 				cause
-			}))), orchestrationEngine.getReadModel().pipe(map$3((readModel) => readModel.snapshotSequence))]);
-			if (isNone(threadDetail)) return yield* new OrchestrationGetSnapshotError({
-				message: `Thread ${input.threadId} was not found`,
-				cause: input.threadId
-			});
-			const liveStream = orchestrationEngine.streamDomainEvents.pipe(filter$2((event) => event.aggregateKind === "thread" && event.aggregateId === input.threadId && isThreadDetailEvent(event)), map$7((event) => ({
-				kind: "event",
-				event
-			})));
-			return concat$2(make$43({
-				kind: "snapshot",
-				snapshot: {
-					snapshotSequence,
-					thread: threadDetail.value
-				}
-			}), liveStream);
+			})))
+		})), { "rpc.aggregate": "orchestration" }),
+		[ORCHESTRATION_WS_METHODS.getThreadDetailPage]: (input) => observeRpcEffect(ORCHESTRATION_WS_METHODS.getThreadDetailPage, loadThreadDetailSnapshot({
+			threadId: input.threadId,
+			window: {
+				...input.turnLimit === void 0 ? {} : { turnLimit: input.turnLimit },
+				...input.beforeCursor === void 0 ? {} : { beforeCursor: input.beforeCursor }
+			},
+			projectionSnapshotQuery,
+			orchestrationEngine
 		}), { "rpc.aggregate": "orchestration" }),
 		[WS_METHODS.serverGetConfig]: (_input) => observeRpcEffect(WS_METHODS.serverGetConfig, loadServerConfig, { "rpc.aggregate": "server" }),
 		[WS_METHODS.serverRefreshProviders]: (_input) => observeRpcEffect(WS_METHODS.serverRefreshProviders, providerRegistry.refresh().pipe(map$3((providers) => ({ providers }))), { "rpc.aggregate": "server" }),
@@ -117598,8 +118315,8 @@ effectDiscard(runMigrations());
 //#endregion
 //#region src/persistence/Layers/Sqlite.ts
 const defaultSqliteClientLoaders = {
-	bun: () => import("./SqliteClient-D3Yd3ZHn.mjs"),
-	node: () => import("./NodeSqliteClient-BrzqdOsF.mjs")
+	bun: () => import("./SqliteClient-BKB695RF.mjs"),
+	node: () => import("./NodeSqliteClient-md8xd9hY.mjs")
 };
 const makeRuntimeSqliteLayer = fn$1("makeRuntimeSqliteLayer")(function* (config) {
 	const loader = defaultSqliteClientLoaders[process.versions.bun !== void 0 ? "bun" : "node"];
@@ -183040,7 +183757,7 @@ var AM = class {
 		return unlink$1(e);
 	}
 	list(e) {
-		return readdir$1(e);
+		return readdir$2(e);
 	}
 	append(e, t, n) {
 		return appendFile(e, t, {
@@ -183065,7 +183782,7 @@ var AM = class {
 		return { mtimeMs: (await stat$1(e)).mtimeMs };
 	}
 	async listEntries(e) {
-		return (await readdir$1(e, { withFileTypes: !0 })).map((n) => ({
+		return (await readdir$2(e, { withFileTypes: !0 })).map((n) => ({
 			name: n.name,
 			isDirectory: n.isDirectory(),
 			isFile: n.isFile()
@@ -190295,7 +191012,7 @@ var Vce = {
 		return lstat$1(e);
 	},
 	async readdir(e) {
-		return readdir$1(e, { withFileTypes: !0 });
+		return readdir$2(e, { withFileTypes: !0 });
 	},
 	async unlink(e) {
 		return unlink$1(e);
@@ -190352,7 +191069,7 @@ var Vce = {
 		return link$1(e, t);
 	},
 	async chmod(e, t) {
-		return chmod(e, t);
+		return chmod$1(e, t);
 	},
 	statSync(e) {
 		let n = [];
@@ -190535,7 +191252,7 @@ var Vce = {
 function Ve() {
 	return Vce;
 }
-var Us = $U.homedir(), lk = $U.tmpdir(), { env: Vc } = process$1, Yce = (e) => {
+var Us = os.homedir(), lk = os.tmpdir(), { env: Vc } = process$1, Yce = (e) => {
 	let t = path.join(Us, "Library");
 	return {
 		data: path.join(t, "Application Support", e),
@@ -190871,7 +191588,7 @@ async function hme(e) {
 	await Promise.all(o.map(async (s) => {
 		let i;
 		try {
-			i = await readdir$1(s, { withFileTypes: !0 });
+			i = await readdir$2(s, { withFileTypes: !0 });
 		} catch {
 			return;
 		}
@@ -200735,12 +201452,12 @@ function qZ(e, t) {
 	}
 	return n;
 }
-var os$1 = "https://code.claude.com/docs/en", kKe = [
+var os$2 = "https://code.claude.com/docs/en", kKe = [
 	{
 		matches: (e) => e.path === "permissions.defaultMode" && e.code === "invalid_value",
 		tip: {
 			suggestion: "Valid modes: \"acceptEdits\" (ask before file changes), \"plan\" (analysis only), \"bypassPermissions\" (auto-accept all), or \"default\" (standard behavior)",
-			docLink: `${os$1}/iam#permission-modes`
+			docLink: `${os$2}/iam#permission-modes`
 		}
 	},
 	{
@@ -200755,7 +201472,7 @@ var os$1 = "https://code.claude.com/docs/en", kKe = [
 		matches: (e) => e.path.startsWith("env.") && e.code === "invalid_type",
 		tip: {
 			suggestion: "Environment variables must be strings. Wrap numbers and booleans in quotes. Example: \"DEBUG\": \"true\", \"PORT\": \"3000\"",
-			docLink: `${os$1}/settings#environment-variables`
+			docLink: `${os$2}/settings#environment-variables`
 		}
 	},
 	{
@@ -200766,14 +201483,14 @@ var os$1 = "https://code.claude.com/docs/en", kKe = [
 		matches: (e) => e.path.startsWith("hooks.") && e.code === "invalid_key",
 		tip: {
 			suggestion: "Not a recognized hook event. Common events: PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, SessionEnd, Stop. Check spelling and capitalization.",
-			docLink: `${os$1}/hooks`
+			docLink: `${os$2}/hooks`
 		}
 	},
 	{
 		matches: (e) => /\.hooks\.\d+\.command$/.test(e.path) && e.code === "invalid_type" && e.received === "undefined",
 		tip: {
 			suggestion: "Command hooks require `command`. For exec form (no shell), set `command` to the executable and `args` to its arguments: {\"type\": \"command\", \"command\": \"echo\", \"args\": [\"hi\"]}. For shell form, set `command` to the full shell string: {\"type\": \"command\", \"command\": \"echo hi\"}.",
-			docLink: `${os$1}/hooks#exec-form-and-shell-form`
+			docLink: `${os$2}/hooks#exec-form-and-shell-form`
 		}
 	},
 	{
@@ -200788,7 +201505,7 @@ var os$1 = "https://code.claude.com/docs/en", kKe = [
 		matches: (e) => e.code === "unrecognized_keys",
 		tip: {
 			suggestion: "Check for typos or refer to the documentation for valid fields",
-			docLink: `${os$1}/settings`
+			docLink: `${os$2}/settings`
 		}
 	},
 	{
@@ -200803,13 +201520,13 @@ var os$1 = "https://code.claude.com/docs/en", kKe = [
 		matches: (e) => e.path === "permissions.additionalDirectories" && e.code === "invalid_type",
 		tip: {
 			suggestion: "Must be an array of directory paths. Example: [\"~/projects\", \"/tmp/workspace\"]. You can also use --add-dir flag or /add-dir command",
-			docLink: `${os$1}/iam#working-directories`
+			docLink: `${os$2}/iam#working-directories`
 		}
 	}
 ], AKe = {
-	permissions: `${os$1}/iam#configuring-permissions`,
-	env: `${os$1}/settings#environment-variables`,
-	hooks: `${os$1}/hooks`
+	permissions: `${os$2}/iam#configuring-permissions`,
+	env: `${os$2}/settings#environment-variables`,
+	hooks: `${os$2}/hooks`
 };
 function GZ(e) {
 	let t = kKe.find((r) => r.matches(e));
@@ -212181,6 +212898,8 @@ const PUBLIC_PROVIDER_LEAK_PATTERNS = [
 	/\bCURSOR_API_KEY\b/,
 	/\bOPENCODE_API_KEY\b/,
 	/\bforge_proxy_[A-Za-z0-9._-]+\b/,
+	/\bProviderValidationError\b/,
+	/\/forge-server\/node_modules\//,
 	/https?:\/\/[^\s'"<>)]*\/api\/provider-egress\/[^\s'"<>)]*/i,
 	/https?:\/\/[^\s'"<>)]*(?:apex|deepseek|moonshot|kimi)[^\s'"<>)]*/i
 ];
@@ -212190,6 +212909,12 @@ function isProviderRateOrQuotaError(message) {
 	const normalized = message.toLowerCase();
 	return /\b(rate[\s-]?limit|too\s+many\s+requests|usage[ _-]limit|usage_limit_reached|quota|insufficient_quota)\b/.test(normalized) || /\b429\b/.test(normalized);
 }
+function providerLifecycleOrAccountCopy(message) {
+	if (/\bbound to provider account\b/.test(message) && /\bcannot use provider account\b/.test(message)) return "Forge could not switch this conversation to the selected AI account. Retry the account switch.";
+	if (/\bforge_runtime_repairing\b/.test(message) || /\bthis turn was interrupted because the environment is being repaired\b/.test(message)) return "This turn was interrupted because the environment is being repaired. Retry after the repair finishes.";
+	if (/\bforge_runtime_stopped\b/.test(message) || /\bthis turn was interrupted because the environment was stopped\b/.test(message)) return "This turn was interrupted because the environment was stopped. Start the environment and retry.";
+	return null;
+}
 /**
 * Infer a SAFE, clearer failure category from a (possibly leaky) provider error.
 *
@@ -212202,7 +212927,8 @@ function isProviderRateOrQuotaError(message) {
 function categorizePublicProviderError(message) {
 	if (!message) return null;
 	const m = message.toLowerCase();
-	if (/\bforge_runtime_stopped\b/.test(m) || /\bthis turn was interrupted because the environment was stopped\b/.test(m)) return "This turn was interrupted because the environment was stopped. Start the environment and retry.";
+	const lifecycleOrAccountCopy = providerLifecycleOrAccountCopy(m);
+	if (lifecycleOrAccountCopy !== null) return lifecycleOrAccountCopy;
 	if (/\bforge_provider_model_not_allowed\b/.test(m) || /\bnot\s+scoped\s+to\s+the\s+requested\s+model\b/.test(m)) return "The workspace AI credential does not cover the model this turn asked for. Retry, or pick that model for the thread.";
 	if (/\bmodel\b[\s\S]*\b(not\s+(found|available|supported)|does\s+not\s+exist|unsupported|invalid|unknown)\b/.test(m) || /\b(unsupported|unknown|invalid)\b[\s\S]*\bmodel\b/.test(m) || /\b(model_not_found|invalid_model|model_not_supported)\b/.test(m)) return "The selected model isn't available right now. Pick a different model and retry.";
 	if (isProviderRateOrQuotaError(m)) return "The AI service is rate-limited or out of quota. Wait a moment and retry.";
@@ -212268,60 +212994,14 @@ 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.
-*/
+/** Per-account credentials share the existing Claude transcript directory. */
 /** 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
@@ -212330,11 +213010,12 @@ const DIRECTORY_NAME_HASH_LENGTH = 32;
 function claudeCredentialDirectoryName(accountIdentity) {
 	return `account-${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;
+/** Only a matching CMMD delivery can select a credential directory. */
+function resolveSelectedClaudeAccountIdentity(selectedAccountId, binding) {
+	if (selectedAccountId === void 0) return null;
+	const identity = binding?.identity;
+	if (identity?.kind !== "credential_generation" || identity.provider !== "claude" || identity.providerAccountIdentity !== selectedAccountId) throw new Error("The selected Claude account has no matching credential delivery. Reconnect that account and try again.");
+	return identity.providerAccountIdentity;
 }
 /**
 * Where per-account credential directories live: `claude-credentials` under the
@@ -212361,29 +213042,19 @@ function resolveClaudeCredentialDirectory(input) {
 	if (!root) return null;
 	return 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.
-*/
+/** Refuse selected accounts that cannot use their own credential directory. */
 function decideClaudeCredentialDirectory(input) {
 	return gen(function* () {
 		if (!input.accountIdentity) return skip("no-account");
-		if (input.env["CLAUDE_SECURESTORAGE_CONFIG_DIR"]?.trim()) return skip("operator-override");
+		if (input.env["CLAUDE_SECURESTORAGE_CONFIG_DIR"]?.trim()) return refuse("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");
+		if (!directory) return refuse("no-root");
+		if (!holdsUsableCredential(directory)) return refuse("no-usable-credential");
+		if ((yield* input.probeSupport) === "supported") return set(directory);
+		return input.primaryCredentialMatchesSelected === true ? {
+			outcome: "skipped",
+			reason: "same-primary-account"
+		} : refuse("capability-not-supported");
 	});
 }
 /**
@@ -212422,6 +213093,12 @@ function skip(reason) {
 		reason
 	};
 }
+function refuse(reason) {
+	return {
+		outcome: "refused",
+		reason
+	};
+}
 function claudeConfigDirectory(env) {
 	const configured = env.CLAUDE_CONFIG_DIR?.trim();
 	if (configured) return configured;
@@ -212431,6 +213108,24 @@ function claudeConfigDirectory(env) {
 		return null;
 	}
 }
+/**
+* The fallback is allowed only when the primary on-disk credential is
+* byte-identical to what CMMD prepared for the selected account. A ticket's
+* `credentialRevisionHash` cannot express that: it hashes the encrypted row
+* CMMD stores, not the decrypted bytes this process ever sees. Comparing
+* files directly is the only check that means what the fallback needs.
+*/
+function primaryClaudeCredentialMatchesPrepared(env, preparedDirectory) {
+	const directory = claudeConfigDirectory(env);
+	if (!directory) return false;
+	try {
+		const primary = readFileSync(join(directory, CLAUDE_CREDENTIAL_FILE_NAME), "utf8");
+		const prepared = readFileSync(join(preparedDirectory, CLAUDE_CREDENTIAL_FILE_NAME), "utf8");
+		return hasAccessToken(JSON.parse(primary)) && createHash("sha256").update(primary).digest("hex") === createHash("sha256").update(prepared).digest("hex");
+	} catch {
+		return false;
+	}
+}
 //#endregion
 //#region src/provider/personalClaudeInVm.ts
 /**
@@ -212563,13 +213258,106 @@ function withoutInheritedAnthropicCredentials(env, options) {
 * 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) {
+function claudeSubscriptionChildEnv(processEnv, credentialDirectory, selectedSubscription = false) {
 	return {
-		...withoutInheritedAnthropicCredentials(scrubForgeProviderChildEnvSecrets(processEnv), { stripEndpointOverride: personalClaudeInVmEnabled(processEnv) }),
+		...withoutInheritedAnthropicCredentials(scrubForgeProviderChildEnvSecrets(processEnv), { stripEndpointOverride: selectedSubscription || credentialDirectory !== null || personalClaudeInVmEnabled(processEnv) }),
 		...credentialDirectory ? { [CLAUDE_SECURESTORAGE_CONFIG_DIR_ENV]: credentialDirectory } : {}
 	};
 }
 //#endregion
+//#region src/provider/claudeSelectedCredentialStore.ts
+async function ensurePrivateDirectory(path) {
+	await mkdir(path, {
+		recursive: true,
+		mode: 448
+	});
+	const info = await lstat(path);
+	if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Unsafe credential directory.");
+	await chmod(path, 448);
+}
+async function makeCapacity(root, target, active, maximum) {
+	const entries = (await readdir$1(root, { withFileTypes: true })).filter((entry) => entry.isDirectory() && /^account-[a-f0-9]{32}$/.test(entry.name));
+	if (entries.some((entry) => join(root, entry.name) === target)) return;
+	const candidates = await Promise.all(entries.filter((entry) => !active.has(join(root, entry.name))).map(async (entry) => ({
+		path: join(root, entry.name),
+		modified: (await lstat(join(root, entry.name))).mtimeMs
+	})));
+	candidates.sort((a, b) => a.modified - b.modified);
+	const required = entries.length - maximum + 1;
+	if (required > candidates.length) throw new Error("All Claude credential slots are active. Stop a session before choosing another account.");
+	for (const candidate of candidates.slice(0, Math.max(0, required))) await rm(candidate.path, { recursive: true });
+}
+function createClaudeSelectedCredentialStore(baseDir, options = {}) {
+	const sessions = /* @__PURE__ */ new Map();
+	const maximum = options.maxAccounts ?? 8;
+	if (!Number.isSafeInteger(maximum) || maximum < 1) throw new Error("Invalid credential capacity.");
+	let queue = Promise.resolve();
+	async function install(threadId, acquired) {
+		if (acquired.claims.threadId !== threadId) throw new Error("Credential thread mismatch.");
+		const directory = resolveClaudeCredentialDirectory({
+			env: process.env,
+			baseDir,
+			accountIdentity: acquired.claims.providerAccountId
+		});
+		if (!directory) throw new Error("Unsafe credential directory.");
+		const binding = {
+			runtimeId: acquired.claims.runtimeId,
+			machineId: acquired.claims.machineId,
+			credentialEpoch: acquired.claims.credentialEpoch,
+			identity: {
+				kind: "credential_generation",
+				provider: "claude",
+				credentialGenerationId: acquired.claims.generationId,
+				providerAccountIdentity: acquired.claims.providerAccountId
+			}
+		};
+		for (const prepared of sessions.values()) if (prepared.directory === directory && (!providerDeliveryBindingsEqual(prepared.binding, binding) || prepared.credentialRevisionHash !== acquired.claims.credentialRevisionHash)) throw new Error("The Claude account has an active session. Stop it before replacing its credentials.");
+		const root = dirname(directory);
+		await ensurePrivateDirectory(root);
+		await makeCapacity(root, directory, new Set([...sessions.values()].map((entry) => entry.directory)), maximum);
+		await ensurePrivateDirectory(directory);
+		const temporary = join(directory, `.credential-${randomUUID()}.tmp`);
+		try {
+			await writeFile(temporary, acquired.credentialJson, {
+				mode: 384,
+				flag: "wx"
+			});
+			await rename(temporary, join(directory, ".credentials.json"));
+		} finally {
+			await rm(temporary, { force: true });
+		}
+		sessions.set(threadId, {
+			directory,
+			binding,
+			accountKind: acquired.claims.accountKind,
+			credentialRevisionHash: acquired.claims.credentialRevisionHash
+		});
+		return binding;
+	}
+	return {
+		prepare(threadId, acquired) {
+			const operation = queue.then(() => install(threadId, acquired));
+			queue = operation.then(() => void 0, () => void 0);
+			return operation;
+		},
+		read(threadId, binding) {
+			const prepared = sessions.get(threadId);
+			return prepared && providerDeliveryBindingsEqual(prepared.binding, binding) ? prepared : null;
+		},
+		release(threadId) {
+			sessions.delete(threadId);
+		}
+	};
+}
+const stores = /* @__PURE__ */ new Map();
+function selectedClaudeCredentialStore(baseDir) {
+	const existing = stores.get(baseDir);
+	if (existing) return existing;
+	const store = createClaudeSelectedCredentialStore(baseDir);
+	stores.set(baseDir, store);
+	return store;
+}
+//#endregion
 //#region src/provider/claudeCredentialDirectoryProbe.ts
 /**
 * Capability probe for `CLAUDE_SECURESTORAGE_CONFIG_DIR`.
@@ -214611,7 +215399,8 @@ function claudeForgeAttributionPrompt() {
 * 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) {
+function buildClaudeQueryEnv(baseProcessEnv, endpointProfile, claudeSettings, providerProxyCredential, credentialDirectory, selectedSubscription = false) {
+	if (selectedSubscription) return claudeSubscriptionChildEnv(baseProcessEnv, credentialDirectory, true);
 	const baseEnv = scrubForgeProviderChildEnvSecrets(baseProcessEnv);
 	const effectiveBaseUrl = resolveClaudeQueryBaseUrl(endpointProfile, claudeSettings, providerProxyCredential);
 	if (!effectiveBaseUrl) return claudeSubscriptionChildEnv(baseProcessEnv, credentialDirectory);
@@ -216524,6 +217313,7 @@ const makeClaudeAdapter = fn$1("makeClaudeAdapter")(function* (options) {
 		if (streamFiber && streamFiber.pollUnsafe() === void 0) yield* interrupt$4(streamFiber);
 		try {
 			context.query.close();
+			selectedClaudeCredentialStore(serverConfig.baseDir).release(context.session.threadId);
 		} catch (cause) {
 			yield* emitRuntimeError(context, "Failed to close Claude runtime query.", cause);
 		}
@@ -216835,6 +217625,43 @@ const makeClaudeAdapter = fn$1("makeClaudeAdapter")(function* (options) {
 			sessionId: existingResumeSessionId ?? newSessionId
 		};
 	});
+	const resolveSelectedCredentialDirectory = fn$1("resolveSelectedCredentialDirectory")(function* (input, resumeState, claudeBinaryPath) {
+		const requestedAccountId = input.modelSelection?.provider === "claudeAgent" ? input.modelSelection.providerAccountId : void 0;
+		const selectedAccountIdentity = yield* try_({
+			try: () => resolveSelectedClaudeAccountIdentity(requestedAccountId, resumeState?.providerDeliveryBinding),
+			catch: () => new ProviderAdapterValidationError({
+				provider: PROVIDER$11,
+				operation: "startSession",
+				issue: `The selected Claude account ${requestedAccountId} has no matching credential delivery. Reconnect that account and try again.`
+			})
+		});
+		const preparedCredential = resumeState?.providerDeliveryBinding ? selectedClaudeCredentialStore(serverConfig.baseDir).read(input.threadId, resumeState.providerDeliveryBinding) : null;
+		if (selectedAccountIdentity !== null && preparedCredential === null) return yield* new ProviderAdapterValidationError({
+			provider: PROVIDER$11,
+			operation: "startSession",
+			issue: `The selected Claude account ${selectedAccountIdentity} has no prepared credential. Try again to reconnect it.`
+		});
+		const credentialDirectoryDecision = yield* decideClaudeCredentialDirectory({
+			env: process.env,
+			baseDir: serverConfig.baseDir,
+			accountIdentity: selectedAccountIdentity,
+			probeSupport: claudeCredentialDirectoryProbeFor(claudeBinaryPath).support,
+			primaryCredentialMatchesSelected: preparedCredential?.accountKind === "primary" && primaryClaudeCredentialMatchesPrepared(process.env, preparedCredential.directory)
+		});
+		if (credentialDirectoryDecision.outcome === "refused") return yield* new ProviderAdapterValidationError({
+			provider: PROVIDER$11,
+			operation: "startSession",
+			issue: `The selected Claude account ${selectedAccountIdentity} cannot run on this environment: ${credentialDirectoryDecision.reason}. Reconnect the account or choose another environment.`
+		});
+		if (credentialDirectoryDecision.outcome === "skipped") {
+			const skipLine = `Claude credential directory skipped: ${credentialDirectoryDecision.reason}`;
+			yield* credentialDirectoryDecision.reason === "no-account" ? logDebug(skipLine) : logWarning$1(skipLine);
+		}
+		return {
+			selectedAccountIdentity,
+			claudeCredentialDirectory: credentialDirectoryDecision.outcome === "set" ? credentialDirectoryDecision.directory : null
+		};
+	});
 	const startSession = fn$1("startSession")(function* (input) {
 		const sessionProvider = yield* validateClaudeStartSessionProvider(input.provider);
 		const startedAt = yield* nowIso;
@@ -216895,19 +217722,14 @@ const makeClaudeAdapter = fn$1("makeClaudeAdapter")(function* (options) {
 		})));
 		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" ? logDebug(skipLine) : logWarning$1(skipLine);
-		}
-		const claudeCredentialDirectory = credentialDirectoryDecision.outcome === "set" ? credentialDirectoryDecision.directory : null;
+		const { selectedAccountIdentity, claudeCredentialDirectory } = yield* resolveSelectedCredentialDirectory(input, resumeState, claudeBinaryPath);
 		const modelConfig = resolveClaudeSessionModelConfig(input.modelSelection, claudeSettings.endpointProfiles);
-		const providerProxyCredential = yield* issueClaudeProviderProxyCredential(modelConfig.endpointProfile, modelConfig.modelSlug ?? modelConfig.effectiveApiModelId ?? "unknown", threadId);
+		if (selectedAccountIdentity !== null && modelConfig.endpointProfile !== void 0) return yield* new ProviderAdapterValidationError({
+			provider: PROVIDER$11,
+			operation: "startSession",
+			issue: "The selected Claude account cannot be used with a custom API endpoint. Choose a subscription model."
+		});
+		const providerProxyCredential = selectedAccountIdentity !== null ? null : yield* issueClaudeProviderProxyCredential(modelConfig.endpointProfile, modelConfig.modelSlug ?? modelConfig.effectiveApiModelId ?? "unknown", threadId);
 		const permissionMode = permissionModeForRuntimeMode(input.runtimeMode);
 		const settings = claudeQuerySettings(modelConfig.thinking, modelConfig.fastMode);
 		const workspacePreflight = input.cwd ? formatWorkspaceEnvironmentPreflightForAgent(runWorkspaceEnvironmentPreflight({ cwd: input.cwd })) : void 0;
@@ -216930,7 +217752,7 @@ const makeClaudeAdapter = fn$1("makeClaudeAdapter")(function* (options) {
 			existingResumeSessionId,
 			newSessionId,
 			canUseTool,
-			env: buildClaudeQueryEnv(process.env, modelConfig.endpointProfile, claudeSettings, providerProxyCredential, claudeCredentialDirectory),
+			env: buildClaudeQueryEnv(process.env, modelConfig.endpointProfile, claudeSettings, providerProxyCredential, claudeCredentialDirectory, selectedAccountIdentity !== null),
 			browserManager,
 			threadId,
 			browserToolEnvironmentId,
@@ -216982,7 +217804,9 @@ const makeClaudeAdapter = fn$1("makeClaudeAdapter")(function* (options) {
 		});
 		attachClaudeStreamFiber(context$4, runFork);
 		return { ...session };
-	});
+	}, (effect, input) => effect.pipe(onExit((exit) => sync$1(() => {
+		if (exit._tag === "Failure") selectedClaudeCredentialStore(serverConfig.baseDir).release(input.threadId);
+	}))));
 	const sendTurn = fn$1("sendTurn")(function* (input) {
 		const context = yield* requireSession(input.threadId);
 		const modelSelection = input.modelSelection?.provider === "claudeAgent" || input.modelSelection?.provider === "apex" || input.modelSelection?.provider === "cmmd" ? input.modelSelection : void 0;
@@ -231264,6 +232088,9 @@ const ProviderRollbackConversationInput = Struct({
 	threadId: ThreadId,
 	numTurns: NonNegativeInt
 });
+function selectedAccountGuardFields(providerAccountId) {
+	return providerAccountId === void 0 ? {} : { providerAccountId };
+}
 function cursorRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : {};
 }
@@ -231356,9 +232183,13 @@ const makeProviderService = fn$1("makeProviderService")(function* (options) {
 	const runtimeEventPubSub = yield* unbounded$1();
 	const assertProviderExecutable = options?.assertProviderExecutable ?? (() => succeed(null));
 	const assertCurrentProviderDelivery = fn$1("assertCurrentProviderDelivery")(function* (input) {
-		const currentBinding = yield* assertProviderExecutable(input);
-		if (!currentBinding) return;
 		const persistedBinding = getOrUndefined(yield* directory.getBinding(input.threadId));
+		const providerAccountId = readPersistedProviderAccountId(persistedBinding?.runtimePayload);
+		const currentBinding = yield* assertProviderExecutable({
+			...input,
+			...selectedAccountGuardFields(providerAccountId)
+		});
+		if (!currentBinding) return;
 		if (!persistedBinding || persistedBinding.provider !== input.provider) return yield* toValidationError(input.operation, `Cannot verify the delivered provider identity for thread '${input.threadId}'.`);
 		yield* bindProviderDeliveryToResumeCursor({
 			operation: input.operation,
@@ -231413,10 +232244,12 @@ const makeProviderService = fn$1("makeProviderService")(function* (options) {
 			if (!hasResumeCursor) return yield* toValidationError(input.operation, `Cannot recover thread '${input.binding.threadId}' because no provider resume state is persisted.`);
 			const persistedCwd = readPersistedCwd(input.binding.runtimePayload);
 			const persistedModelSelection = readPersistedModelSelection(input.binding.runtimePayload);
+			const persistedProviderAccountId = readProviderAccountIdFromModelSelection(persistedModelSelection);
 			const currentDeliveryBinding = yield* assertProviderExecutable({
 				threadId: input.binding.threadId,
 				provider: input.binding.provider,
-				operation: input.operation
+				operation: input.operation,
+				...selectedAccountGuardFields(persistedProviderAccountId)
 			});
 			const boundResumeCursor = yield* bindProviderDeliveryToResumeCursor({
 				operation: input.operation,
@@ -231541,7 +232374,8 @@ const makeProviderService = fn$1("makeProviderService")(function* (options) {
 				currentBinding: yield* assertProviderExecutable({
 					threadId,
 					provider: effectiveProvider,
-					operation: "ProviderService.startSession"
+					operation: "ProviderService.startSession",
+					...selectedAccountGuardFields(requestedAccountId)
 				})
 			});
 			const session = yield* adapter.startSession({
@@ -231607,6 +232441,8 @@ const makeProviderService = fn$1("makeProviderService")(function* (options) {
 				allowRecovery: true
 			});
 			const persistedBinding = getOrUndefined(yield* directory.getBinding(input.threadId));
+			const persistedModelSelection = readPersistedModelSelection(persistedBinding?.runtimePayload);
+			const nextModelSelection = input.modelSelection ?? persistedModelSelection;
 			yield* assertProviderAccountBoundary({
 				operation: "ProviderService.sendTurn",
 				threadId: input.threadId,
@@ -231631,7 +232467,7 @@ const makeProviderService = fn$1("makeProviderService")(function* (options) {
 				status: "running",
 				...turn.resumeCursor !== void 0 ? { resumeCursor: turn.resumeCursor } : {},
 				runtimePayload: {
-					...input.modelSelection !== void 0 ? { modelSelection: input.modelSelection } : {},
+					...nextModelSelection !== void 0 ? { modelSelection: nextModelSelection } : {},
 					activeTurnId: turn.turnId,
 					lastRuntimeEvent: "provider.sendTurn",
 					lastRuntimeEventAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -231887,6 +232723,201 @@ function makeProviderServiceLive(options) {
 	return effect(ProviderService, makeProviderService(options));
 }
 //#endregion
+//#region src/runtimeAuth/cmmdClaudeSelectedTicket.ts
+const ACCOUNT = /^pai_v1_[A-Za-z0-9_-]{43}$/;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const REVISION_HASH = /^[a-f0-9]{64}$/;
+function hasValidTicketLifetime(claims, payload) {
+	const now = Math.floor(Date.now() / 1e3);
+	const issuedAt = payload.iat;
+	const notBefore = payload.nbf;
+	return typeof issuedAt === "number" && Number.isSafeInteger(issuedAt) && issuedAt <= now + 5 && typeof notBefore === "number" && Number.isSafeInteger(notBefore) && notBefore <= now && Number.isSafeInteger(claims.expiresAtSeconds) && claims.expiresAtSeconds - issuedAt <= 900;
+}
+function hasSelectedCredentialScope(claims) {
+	return claims.scope.length === 1 && claims.scope[0] === "claude-credential-read";
+}
+function hasExpectedSelectedBinding(payload, expected) {
+	return payload.provider_account_id === expected.providerAccountId && ACCOUNT.test(expected.providerAccountId) && payload.thread_id === expected.threadId && payload.operation_id === expected.operationId && UUID.test(expected.operationId);
+}
+function selectedCredentialClaims(payload) {
+	const jti = payload.jti;
+	const generationId = payload.credential_generation_id;
+	const credentialRevisionHash = payload.credential_revision_hash;
+	const accountKind = payload.account_kind;
+	if (typeof jti !== "string" || !jti.trim() || typeof generationId !== "string" || !UUID.test(generationId) || typeof credentialRevisionHash !== "string" || !REVISION_HASH.test(credentialRevisionHash) || accountKind !== "primary" && accountKind !== "linked") return null;
+	return {
+		jti,
+		generationId,
+		credentialRevisionHash,
+		accountKind
+	};
+}
+function verifyCmmdClaudeSelectedTicket(token, expected) {
+	const verified = verifyCmmdScopedRuntimePayload(token, expected, "forge-claude-credential-read");
+	if (!verified) return null;
+	const { claims, payload } = verified;
+	if (!hasValidTicketLifetime(claims, payload)) return null;
+	if (!hasSelectedCredentialScope(claims)) return null;
+	if (!hasExpectedSelectedBinding(payload, expected)) return null;
+	const selected = selectedCredentialClaims(payload);
+	if (!selected) return null;
+	return {
+		...claims,
+		jti: selected.jti,
+		providerAccountId: expected.providerAccountId,
+		generationId: selected.generationId,
+		credentialRevisionHash: selected.credentialRevisionHash,
+		accountKind: selected.accountKind,
+		threadId: expected.threadId,
+		operationId: expected.operationId
+	};
+}
+//#endregion
+//#region src/provider/claudeSelectedCredentialAcquisition.ts
+function readToken(response) {
+	if (typeof response !== "object" || response === null || !("data" in response)) return null;
+	const data = response.data;
+	return typeof data === "object" && data !== null && "token" in data && typeof data.token === "string" ? data.token : null;
+}
+async function acquireSelectedClaudeCredential(expected, transport) {
+	try {
+		const token = readToken(await transport.requestTicket());
+		const claims = token === null ? null : verifyCmmdClaudeSelectedTicket(token, expected);
+		if (!token || !claims) throw new Error("invalid_ticket");
+		const credentialJson = await transport.readCredential(token);
+		if (Buffer.byteLength(credentialJson, "utf8") > 512e3 || !hasUsableClaudeCredentialBlob(credentialJson)) throw new Error("invalid_credential");
+		return {
+			claims,
+			credentialJson
+		};
+	} catch {
+		throw new Error("The selected Claude account could not be prepared. Reconnect the account and try again.");
+	}
+}
+//#endregion
+//#region src/provider/claudeSelectedCredentialPreparer.ts
+const REQUEST_TIMEOUT_MS = 1e4;
+const OWNER_TICKET_PATH = "/api/forge/context/providers/claude/runtime-read-ticket";
+const CREDENTIAL_READ_PATH = "/api/forge/context/auth-runtime-claude-credential";
+function isRuntimeTicketSession$1(sessionId) {
+	return String(sessionId).startsWith("cmmd-runtime:");
+}
+function nonEmptyConfigString(value) {
+	return value?.trim() || null;
+}
+function selectedRuntimeStrings(config) {
+	const values = [
+		nonEmptyConfigString(config.forgeCmmdRuntimeId),
+		nonEmptyConfigString(config.forgeCmmdRuntimeMachineId),
+		nonEmptyConfigString(config.forgeCmmdRuntimeOrgId),
+		nonEmptyConfigString(config.forgeCmmdRuntimeUserId),
+		nonEmptyConfigString(config.forgeCmmdRuntimePublicKey)
+	];
+	if (values.includes(null)) return null;
+	return {
+		runtimeId: values[0],
+		machineId: values[1],
+		orgId: values[2],
+		userId: values[3],
+		publicKeyPem: values[4]
+	};
+}
+function selectedCredentialEpoch(config) {
+	const credentialEpoch = config.forgeCmmdRuntimeCredentialEpoch;
+	return typeof credentialEpoch === "number" && Number.isSafeInteger(credentialEpoch) && credentialEpoch >= 0 ? credentialEpoch : null;
+}
+function selectedConfig(config) {
+	if (config.forgeCmmdRuntimeMode !== true) return null;
+	const strings = selectedRuntimeStrings(config);
+	const credentialEpoch = selectedCredentialEpoch(config);
+	if (strings === null || credentialEpoch === null) return null;
+	return {
+		...strings,
+		credentialEpoch
+	};
+}
+async function boundedRuntimeTicketRequest(grant, runtimeId, request) {
+	const response = await fetch(resolveCommandAppEndpoint(`/api/forge/runtimes/${encodeURIComponent(runtimeId)}/provider/claude/read-ticket`), {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${grant}`,
+			"content-type": "application/json"
+		},
+		body: JSON.stringify(request),
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+	});
+	if (!response.ok) throw new Error("selected_ticket_unavailable");
+	return await response.json();
+}
+async function boundedCredentialRead(token) {
+	const response = await fetch(resolveCommandAppEndpoint(CREDENTIAL_READ_PATH), {
+		headers: {
+			authorization: `Bearer ${token}`,
+			accept: "application/json"
+		},
+		signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+	});
+	if (!response.ok) throw new Error("selected_credential_unavailable");
+	return await response.text();
+}
+function missingAuthority() {
+	throw new Error("selected_authority_unavailable");
+}
+/**
+* Acquires one signed, account-scoped Claude credential for the thread that
+* selected it. Owner and runtime-ticket sessions use different CMMD lanes.
+*/
+function makeClaudeSelectedCredentialPreparer(config, dependencies) {
+	const readRuntimeAuthority = dependencies.readRuntimeAuthority ?? readRuntimeBrokerAuthority;
+	const requestOwnerTicket = dependencies.requestOwnerTicket ?? ((jwt, request) => proxyPost(jwt, OWNER_TICKET_PATH, request, void 0, { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) }));
+	const requestRuntimeTicket = dependencies.requestRuntimeTicket ?? boundedRuntimeTicketRequest;
+	const readCredential = dependencies.readCredential ?? boundedCredentialRead;
+	const prepare = dependencies.prepare ?? ((threadId, acquired) => {
+		if (!config.baseDir) return Promise.reject(/* @__PURE__ */ new Error("selected_store_unavailable"));
+		return selectedClaudeCredentialStore(config.baseDir).prepare(threadId, acquired);
+	});
+	const createOperationId = dependencies.createOperationId ?? randomUUID;
+	return async (input) => {
+		const sealed = selectedConfig(config);
+		const sessionId = input.executionSessionId ?? dependencies.readSessionId(input.threadId);
+		if (sealed === null || sessionId === null) return missingAuthority();
+		const operationId = createOperationId();
+		const request = {
+			providerAccountId: input.providerAccountId,
+			threadId: String(input.threadId),
+			operationId
+		};
+		const acquired = await acquireSelectedClaudeCredential({
+			...sealed,
+			providerAccountId: input.providerAccountId,
+			threadId: String(input.threadId),
+			operationId
+		}, {
+			requestTicket: async () => {
+				if (isRuntimeTicketSession$1(sessionId)) {
+					const grant = readRuntimeAuthority({
+						sessionId,
+						runtimeId: sealed.runtimeId,
+						machineId: sealed.machineId,
+						credentialEpoch: sealed.credentialEpoch,
+						requiredScope: "provider"
+					});
+					if (grant === null) return missingAuthority();
+					return { data: await requestRuntimeTicket(grant, sealed.runtimeId, request) };
+				}
+				const jwt = await dependencies.resolveJwt(sessionId, { forceRefresh: false });
+				if (jwt === null) return missingAuthority();
+				return await requestOwnerTicket(jwt, {
+					...request,
+					runtimeId: sealed.runtimeId
+				});
+			},
+			readCredential
+		});
+		return await prepare(String(input.threadId), acquired);
+	};
+}
+//#endregion
 //#region src/provider/claudeRuntimeReadinessGuard.ts
 const GENERATION_HASH_PATTERN = /^[a-f0-9]{64}$/;
 const RUNTIME_READINESS_TIMEOUT_MS$1 = 1e4;
@@ -232155,7 +233186,22 @@ function makeClaudeRuntimeReadinessGuard(config, dependencies) {
 	return (input) => claudeReadinessGuardEffect(config, dependencies, resolved, input);
 }
 function claudeReadinessGuardEffect(config, dependencies, resolved, input) {
-	if (!requiresNativeClaudeReadiness(config, input.provider)) return succeed(null);
+	if (!requiresNativeClaudeReadiness(config, input.provider, input.providerAccountId)) return succeed(null);
+	if (input.providerAccountId !== void 0) {
+		const prepareSelectedCredential = dependencies.prepareSelectedCredential ?? makeClaudeSelectedCredentialPreparer(config, {
+			resolveJwt: dependencies.resolveJwt,
+			readSessionId: resolved.readSessionId,
+			readRuntimeAuthority: resolved.readRuntimeAuthority
+		});
+		const selectedInput = {
+			...input,
+			providerAccountId: input.providerAccountId
+		};
+		return tryPromise({
+			try: () => prepareSelectedCredential(selectedInput),
+			catch: () => selectedCredentialValidationError(input.operation, selectedInput.providerAccountId)
+		});
+	}
 	const authority = resolveGuardAuthority(config, resolved.readSessionId, input);
 	if (authority === null) return invalidOwnerSessionEffect(input.operation);
 	return tryPromise({
@@ -232163,8 +233209,9 @@ function claudeReadinessGuardEffect(config, dependencies, resolved, input) {
 		catch: (cause) => readinessValidationError(input.operation, cause)
 	});
 }
-function requiresNativeClaudeReadiness(config, provider) {
-	return provider === "claudeAgent" && config.forgeCmmdRuntimeMode === true && personalClaudeInVmEnabled();
+function requiresNativeClaudeReadiness(config, provider, providerAccountId) {
+	if (provider !== "claudeAgent" || config.forgeCmmdRuntimeMode !== true) return false;
+	return providerAccountId !== void 0 || personalClaudeInVmEnabled();
 }
 function resolveGuardAuthority(config, readSessionId, input) {
 	const runtimeId = config.forgeCmmdRuntimeId?.trim();
@@ -232201,6 +233248,12 @@ async function verifyGuardAuthority(config, dependencies, resolved, authority) {
 		fetchReadiness: resolved.fetchReadiness
 	});
 }
+function selectedCredentialValidationError(operation, accountId) {
+	return new ProviderValidationError({
+		operation,
+		issue: `The selected Claude account ${accountId} could not be prepared. Reconnect the account and try again.`
+	});
+}
 function readinessValidationError(operation, cause) {
 	return new ProviderValidationError({
 		operation,
@@ -267698,7 +268751,7 @@ var import_multicast_dns = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMi
 	var dgram = __require("dgram");
 	var thunky = require_thunky();
 	var events = __require("events");
-	var os = __require("os");
+	var os$1 = __require("os");
 	var noop = function() {};
 	module.exports = function(opts) {
 		if (!opts) opts = {};
@@ -267829,14 +268882,14 @@ var import_multicast_dns = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMi
 		return that;
 	};
 	function defaultInterface() {
-		var networks = os.networkInterfaces();
+		var networks = os$1.networkInterfaces();
 		var names = Object.keys(networks);
 		for (var i = 0; i < names.length; i++) {
 			var net = networks[names[i]];
 			for (var j = 0; j < net.length; j++) {
 				var iface = net[j];
 				if (isIPv4(iface.family) && !iface.internal) {
-					if (os.platform() === "darwin" && names[i] === "en0") return iface.address;
+					if (os$1.platform() === "darwin" && names[i] === "en0") return iface.address;
 					return "0.0.0.0";
 				}
 			}
@@ -267844,7 +268897,7 @@ var import_multicast_dns = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMi
 		return "127.0.0.1";
 	}
 	function allInterfaces() {
-		var networks = os.networkInterfaces();
+		var networks = os$1.networkInterfaces();
 		var names = Object.keys(networks);
 		var res = [];
 		for (var i = 0; i < names.length; i++) {
@@ -290898,6 +291951,10 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 				shouldRestartForAccountChange,
 				hasResumeCursor: resumeCursor !== void 0
 			});
+			if (shouldRestartForAccountChange) yield* providerService.stopSession({
+				threadId,
+				preserveResumeState: true
+			});
 			const restartedSession = yield* startProviderSession(resumeCursor !== void 0 ? { resumeCursor } : void 0);
 			yield* logInfo("provider command reactor restarted provider session", {
 				threadId,
@@ -296833,7 +297890,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "05d8568497fdceb5b5d827b142ea4c681bef25ce";
+	return "81ce9360f406bcb5ae9fbdc9f90dd55d33f25f0c";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;
@@ -298246,20 +299303,20 @@ const generatePairingToken = () => {
 	const randomBytes = crypto.getRandomValues(new Uint8Array(PAIRING_TOKEN_LENGTH));
 	return Array.from(randomBytes, (value) => PAIRING_TOKEN_ALPHABET[value & 31]).join("");
 };
+const invalidBootstrapCredentialError = (message) => new BootstrapCredentialError({
+	message,
+	status: 401
+});
+const internalBootstrapCredentialError = (message, cause) => new BootstrapCredentialError({
+	message,
+	status: 500,
+	cause
+});
 const BootstrapCredentialServiceLive = effect(BootstrapCredentialService, gen(function* () {
 	const config = yield* ServerConfig;
 	const pairingLinks = yield* AuthPairingLinkRepository;
 	const seededGrantsRef = yield* make$50(/* @__PURE__ */ new Map());
 	const changesPubSub = yield* unbounded$1();
-	const invalidBootstrapCredentialError = (message) => new BootstrapCredentialError({
-		message,
-		status: 401
-	});
-	const internalBootstrapCredentialError = (message, cause) => new BootstrapCredentialError({
-		message,
-		status: 500,
-		cause
-	});
 	const seedGrant = (credential, grant) => update$4(seededGrantsRef, (current) => {
 		const next = new Map(current);
 		next.set(credential, grant);
@@ -298274,19 +299331,19 @@ const BootstrapCredentialServiceLive = effect(BootstrapCredentialService, gen(fu
 		id
 	}).pipe(asVoid);
 	if (config.desktopBootstrapToken) {
-		const now$2 = yield* now;
+		const now$3 = yield* now;
 		yield* seedGrant(config.desktopBootstrapToken, {
 			method: "desktop-bootstrap",
 			role: "owner",
 			subject: "desktop-bootstrap",
-			expiresAt: add$3(now$2, { milliseconds: toMillis(DESKTOP_BOOTSTRAP_TOKEN_TTL) }),
+			expiresAt: add$3(now$3, { milliseconds: toMillis(DESKTOP_BOOTSTRAP_TOKEN_TTL) }),
 			remainingUses: "unbounded"
 		});
 	}
 	const toBootstrapCredentialError = (message) => (cause) => internalBootstrapCredentialError(message, cause);
 	const listActive = () => gen(function* () {
-		const now$5 = yield* now;
-		return (yield* pairingLinks.listActive({ now: now$5 })).map((row) => row.label ? {
+		const now$2 = yield* now;
+		return (yield* pairingLinks.listActive({ now: now$2 })).map((row) => row.label ? {
 			id: row.id,
 			credential: row.credential,
 			role: row.role,
@@ -298316,8 +299373,8 @@ const BootstrapCredentialServiceLive = effect(BootstrapCredentialService, gen(fu
 		const id = crypto.randomUUID();
 		const credential = generatePairingToken();
 		const ttl = input?.ttl ?? DEFAULT_ONE_TIME_TOKEN_TTL_MINUTES;
-		const now$4 = yield* now;
-		const expiresAt = add$3(now$4, { milliseconds: toMillis(ttl) });
+		const now$5 = yield* now;
+		const expiresAt = add$3(now$5, { milliseconds: toMillis(ttl) });
 		const issued = {
 			id,
 			credential,
@@ -298331,7 +299388,7 @@ const BootstrapCredentialServiceLive = effect(BootstrapCredentialService, gen(fu
 			role: input?.role ?? "client",
 			subject: input?.subject ?? "one-time-token",
 			label: input?.label ?? null,
-			createdAt: now$4,
+			createdAt: now$5,
 			expiresAt
 		});
 		yield* emitUpsert({
@@ -298340,13 +299397,13 @@ const BootstrapCredentialServiceLive = effect(BootstrapCredentialService, gen(fu
 			role: input?.role ?? "client",
 			subject: input?.subject ?? "one-time-token",
 			...input?.label ? { label: input.label } : {},
-			createdAt: now$4,
+			createdAt: now$5,
 			expiresAt
 		});
 		return issued;
 	}).pipe(mapError(toBootstrapCredentialError("Failed to issue pairing credential.")));
 	const consume = (credential) => gen(function* () {
-		const now$3 = yield* now;
+		const now$4 = yield* now;
 		const seededResult = yield* modify$3(seededGrantsRef, (current) => {
 			const grant = current.get(credential);
 			if (!grant) return [{
@@ -298355,7 +299412,7 @@ const BootstrapCredentialServiceLive = effect(BootstrapCredentialService, gen(fu
 				error: invalidBootstrapCredentialError("Unknown bootstrap credential.")
 			}, current];
 			const next = new Map(current);
-			if (isGreaterThanOrEqualTo$1(now$3, grant.expiresAt)) {
+			if (isGreaterThanOrEqualTo$1(now$4, grant.expiresAt)) {
 				next.delete(credential);
 				return [{
 					_tag: "error",
@@ -298384,8 +299441,8 @@ const BootstrapCredentialServiceLive = effect(BootstrapCredentialService, gen(fu
 		if (seededResult.reason !== "not-found") return yield* seededResult.error;
 		const consumed = yield* pairingLinks.consumeAvailable({
 			credential,
-			consumedAt: now$3,
-			now: now$3
+			consumedAt: now$4,
+			now: now$4
 		});
 		if (isSome(consumed)) {
 			yield* emitRemoved(consumed.value.id);
@@ -298401,9 +299458,9 @@ const BootstrapCredentialServiceLive = effect(BootstrapCredentialService, gen(fu
 		if (isNone(matching)) return yield* invalidBootstrapCredentialError("Unknown bootstrap credential.");
 		if (matching.value.revokedAt !== null) return yield* invalidBootstrapCredentialError("Bootstrap credential is no longer available.");
 		if (matching.value.consumedAt !== null) return yield* invalidBootstrapCredentialError("Unknown bootstrap credential.");
-		if (isGreaterThanOrEqualTo$1(now$3, matching.value.expiresAt)) return yield* invalidBootstrapCredentialError("Bootstrap credential expired.");
+		if (isGreaterThanOrEqualTo$1(now$4, matching.value.expiresAt)) return yield* invalidBootstrapCredentialError("Bootstrap credential expired.");
 		return yield* invalidBootstrapCredentialError("Bootstrap credential is no longer available.");
-	}).pipe(mapError((cause) => cause instanceof BootstrapCredentialError ? cause : internalBootstrapCredentialError("Failed to consume bootstrap credential.", cause)));
+	}).pipe(mapError((cause) => cause instanceof BootstrapCredentialError ? cause : internalBootstrapCredentialError("Failed to consume bootstrap credential.", cause)), tapError((error) => error.status === 401 ? logWarning$1("Rejected bootstrap credential exchange.", { reason: error.message }) : void_$1));
 	return {
 		issueOneTimeToken,
 		listActive,
@@ -298458,6 +299515,10 @@ const SetAuthSessionLastConnectedAtInput = Struct({
 	sessionId: AuthSessionId,
 	lastConnectedAt: DateTimeUtcFromString
 });
+const ExtendAuthSessionExpiryInput = Struct({
+	sessionId: AuthSessionId,
+	expiresAt: DateTimeUtcFromString
+});
 var AuthSessionRepository = class extends Service$1()("forge/persistence/Services/AuthSessions/AuthSessionRepository") {};
 //#endregion
 //#region src/persistence/Layers/AuthSessions.ts
@@ -298609,6 +299670,17 @@ const AuthSessionRepositoryLive = effect(AuthSessionRepository, gen(function* ()
         WHERE session_id = ${sessionId}
           AND revoked_at IS NULL
         RETURNING session_id AS "sessionId"
+      `
+	});
+	const extendSessionExpiryRows = findAll({
+		Request: ExtendAuthSessionExpiryInput,
+		Result: Struct({ sessionId: AuthSessionId }),
+		execute: ({ sessionId, expiresAt }) => sql`
+        UPDATE auth_sessions
+        SET expires_at = ${expiresAt}
+        WHERE session_id = ${sessionId}
+          AND revoked_at IS NULL
+        RETURNING session_id AS "sessionId"
       `
 	});
 	const revokeOtherSessionRows = findAll({
@@ -298631,13 +299703,15 @@ const AuthSessionRepositoryLive = effect(AuthSessionRepository, gen(function* ()
 	const revoke = (input) => revokeSessionRows(input).pipe(mapError(toPersistenceSqlOrDecodeError$3("AuthSessionRepository.revoke:query", "AuthSessionRepository.revoke:decodeRows")), map$3((rows) => rows.length > 0));
 	const revokeAllExcept = (input) => revokeOtherSessionRows(input).pipe(mapError(toPersistenceSqlOrDecodeError$3("AuthSessionRepository.revokeAllExcept:query", "AuthSessionRepository.revokeAllExcept:decodeRows")), map$3((rows) => rows.map((row) => row.sessionId)));
 	const setLastConnectedAt = (input) => setLastConnectedAtRow(input).pipe(mapError(toPersistenceSqlOrDecodeError$3("AuthSessionRepository.setLastConnectedAt:query", "AuthSessionRepository.setLastConnectedAt:encodeRequest")));
+	const extendExpiry = (input) => extendSessionExpiryRows(input).pipe(mapError(toPersistenceSqlOrDecodeError$3("AuthSessionRepository.extendExpiry:query", "AuthSessionRepository.extendExpiry:decodeRows")), map$3((rows) => rows.length > 0));
 	return {
 		create,
 		getById,
 		listActive,
 		revoke,
 		revokeAllExcept,
-		setLastConnectedAt
+		setLastConnectedAt,
+		extendExpiry
 	};
 }));
 //#endregion
@@ -298645,6 +299719,20 @@ const AuthSessionRepositoryLive = effect(AuthSessionRepository, gen(function* ()
 const SIGNING_SECRET_NAME = "server-signing-key";
 const DEFAULT_SESSION_TTL = days(30);
 const DEFAULT_WEBSOCKET_TOKEN_TTL = minutes(5);
+/**
+* Whether a session presented at `nowMs` has used up half its own lifetime.
+*
+* A phone that opens the app daily should never hit the 30-day wall, but a
+* lost phone's session should still die on schedule if it is never presented
+* again. Sliding the expiry forward only when the session is already more
+* than half spent gives an active phone many chances to renew before expiry
+* while keeping a dormant session's remaining lifetime bounded by the last
+* time it was actually used.
+*/
+function isPastHalfLife(input) {
+	const halfLifeMarkMs = input.issuedAtMs + (input.expiresAtMs - input.issuedAtMs) / 2;
+	return input.nowMs >= halfLifeMarkMs;
+}
 const toSessionCredentialError = (message) => (cause) => new SessionCredentialError({
 	message,
 	cause
@@ -298805,6 +299893,42 @@ const SessionCredentialServiceLive = effect(SessionCredentialService, gen(functi
 			role: claims.role
 		};
 	}).pipe(mapError(toSessionCredentialError("Failed to issue session credential.")));
+	/**
+	* Slide a session's expiry forward when the token it just verified is past
+	* half its own lifetime, so a phone that keeps using the app never runs
+	* into the 30-day wall.
+	*
+	* The session id, subject, role and method carry over unchanged — only the
+	* signature-bearing `iat`/`exp` differ — which is what lets the DB row be
+	* extended in place (`extendExpiry`) rather than replaced: everything keyed
+	* by session id, most importantly the `command_access_tokens` row holding
+	* this session's CMMD credential, needs no migration.
+	*/
+	const renewIfPastHalfLife = (input) => gen(function* () {
+		const nowMs = yield* currentTimeMillis;
+		if (!isPastHalfLife({
+			issuedAtMs: input.row.issuedAt.epochMilliseconds,
+			expiresAtMs: input.row.expiresAt.epochMilliseconds,
+			nowMs
+		})) return void 0;
+		const newIssuedAt = yield* now;
+		const newExpiresAt = add$3(newIssuedAt, { milliseconds: toMillis(DEFAULT_SESSION_TTL) });
+		const newClaims = {
+			...input.claims,
+			iat: newIssuedAt.epochMilliseconds,
+			exp: newExpiresAt.epochMilliseconds
+		};
+		const newEncodedPayload = base64UrlEncode(JSON.stringify(newClaims));
+		const newSignature = signPayload(newEncodedPayload, signingSecret);
+		if (!(yield* authSessions.extendExpiry({
+			sessionId: input.claims.sid,
+			expiresAt: newExpiresAt
+		}).pipe(orElseSucceed(() => false)))) return void 0;
+		return {
+			token: `${newEncodedPayload}.${newSignature}`,
+			expiresAt: newExpiresAt
+		};
+	});
 	const verify = (token) => gen(function* () {
 		const [encodedPayload, signature] = token.split(".");
 		if (!encodedPayload || !signature) return yield* new SessionCredentialError({ message: "Malformed session token." });
@@ -298819,14 +299943,19 @@ const SessionCredentialServiceLive = effect(SessionCredentialService, gen(functi
 		if (isSome(row)) {
 			if (row.value.revokedAt !== null) return yield* new SessionCredentialError({ message: "Session token revoked." });
 		} else if (!(statelessCookieSessions && claims.method === "browser-session-cookie")) return yield* new SessionCredentialError({ message: "Unknown session token." });
+		const renewed = isSome(row) ? yield* renewIfPastHalfLife({
+			claims,
+			row: row.value
+		}) : void 0;
 		return {
 			sessionId: claims.sid,
 			token,
 			method: claims.method,
 			client: isSome(row) ? toClientMetadata(row.value.client) : createDefaultClientMetadata(),
-			expiresAt: makeUnsafe$5(claims.exp),
+			expiresAt: renewed?.expiresAt ?? makeUnsafe$5(claims.exp),
 			subject: claims.sub,
-			role: claims.role
+			role: claims.role,
+			...renewed ? { renewed } : {}
 		};
 	}).pipe(mapError((cause) => cause instanceof SessionCredentialError ? cause : new SessionCredentialError({
 		message: "Failed to verify session credential.",
@@ -299318,7 +300447,10 @@ const ServerAuthLive = effect(ServerAuth, gen(function* () {
 		subject: session.subject,
 		method: session.method,
 		role: session.role,
-		...session.expiresAt ? { expiresAt: session.expiresAt } : {}
+		...session.renewed ? {
+			expiresAt: session.renewed.expiresAt,
+			renewedSessionToken: session.renewed.token
+		} : session.expiresAt ? { expiresAt: session.expiresAt } : {}
 	})), mapError((cause) => new AuthError({
 		message: "Unauthorized request.",
 		status: 401,
@@ -299353,6 +300485,7 @@ const ServerAuthLive = effect(ServerAuth, gen(function* () {
 		role: session.role,
 		sessionMethod: session.method,
 		...session.expiresAt ? { expiresAt: toUtc(session.expiresAt) } : {},
+		...session.renewedSessionToken ? { renewedSessionToken: session.renewedSessionToken } : {},
 		cmmdIdentity
 	})))), tapError((e) => {
 		if (e._tag === "AuthError" && (e.status ?? 500) < 500) return void_$1;
@@ -305679,6 +306812,82 @@ const orchestrationAutomationTerminalReconcileRouteLayer = add$1("POST", "/api/o
 	}, { status: 200 });
 }).pipe(catchTag("OrchestrationDispatchCommandError", respondToWorkRunEventError)));
 //#endregion
+//#region src/orchestration/threadSnapshotRoute.ts
+/**
+* `GET /api/orchestration/threads/:threadId`, one thread's detail snapshot,
+* optionally windowed to a page of recent turns.
+*
+* Forge never served this route. The mobile client has asked for it on every
+* thread open since it shipped, fell through to the socket-embedded snapshot on
+* the 404, and its "load earlier" control had nowhere to fetch from, so a long
+* thread was only ever loadable in full. Serving it here gives the initial read
+* a body the transport can gzip, off the RPC socket, and gives older turns a
+* cursor to arrive on.
+*
+* The window is applied by the same pure function the WebSocket fallback
+* snapshot uses, so the two reads cannot disagree about what a page is.
+*/
+/**
+* Reads the window out of the query string.
+*
+* Returns null for a malformed value rather than ignoring it. A client that
+* asked for 10 turns and silently received 4,000 has no way to tell, and the
+* failure would show up as a slow app rather than as an error.
+*/
+function parseThreadSnapshotWindow(searchParams) {
+	const rawTurnLimit = searchParams.get("turnLimit");
+	const rawBeforeCursor = searchParams.get("beforeCursor");
+	let turnLimit;
+	if (rawTurnLimit !== null) {
+		const parsed = Number(rawTurnLimit);
+		if (!Number.isSafeInteger(parsed) || parsed < 1) return null;
+		turnLimit = parsed;
+	}
+	let beforeCursor;
+	if (rawBeforeCursor !== null) {
+		const trimmed = rawBeforeCursor.trim();
+		if (trimmed.length === 0) return null;
+		beforeCursor = trimmed;
+	}
+	return {
+		...turnLimit === void 0 ? {} : { turnLimit },
+		...beforeCursor === void 0 ? {} : { beforeCursor }
+	};
+}
+const orchestrationThreadSnapshotRouteLayer = add$1("GET", "/api/orchestration/threads/:threadId", gen(function* () {
+	const request = yield* HttpServerRequest;
+	yield* (yield* ServerAuth).authenticateHttpRequest(request);
+	const rawThreadId = (yield* params)["threadId"];
+	if (rawThreadId === void 0 || rawThreadId.length === 0) return jsonUnsafe({ error: "Missing thread id." }, { status: 400 });
+	const url = toURL(request);
+	const window = isNone(url) ? {} : parseThreadSnapshotWindow(url.value.searchParams);
+	if (window === null) return jsonUnsafe({ error: "Invalid turnLimit or beforeCursor." }, { status: 400 });
+	const threadId = ThreadId.make(decodeURIComponent(rawThreadId));
+	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
+	const orchestrationEngine = yield* OrchestrationEngineService;
+	const [threadDetail, snapshotSequence] = yield* all([projectionSnapshotQuery.getThreadDetailById(threadId).pipe(mapError((cause) => new OrchestrationGetSnapshotError({
+		message: `Failed to load thread ${threadId}`,
+		cause
+	}))), orchestrationEngine.getReadModel().pipe(map$3((readModel) => readModel.snapshotSequence))]);
+	if (isNone(threadDetail)) return jsonUnsafe({ error: "Thread not found." }, { status: 404 });
+	const windowed = windowThreadDetail({
+		thread: threadDetail.value,
+		window,
+		snapshotSequence
+	});
+	return jsonUnsafe({
+		snapshotSequence,
+		thread: windowed.thread,
+		...windowed.page === void 0 ? {} : { page: windowed.page }
+	}, { status: 200 });
+}).pipe(catchTag("AuthError", respondToAuthError), catchTag("OrchestrationGetSnapshotError", (error) => gen(function* () {
+	yield* logError("thread snapshot route failed", {
+		message: error.message,
+		cause: error.cause
+	});
+	return jsonUnsafe({ error: error.message }, { status: 500 });
+}))));
+//#endregion
 //#region src/localAutomations/scheduling.ts
 const MINUTE_MS = 6e4;
 const HOUR_MS = 60 * MINUTE_MS;
@@ -317547,7 +318756,7 @@ function makeProjectLeadControllerClientLive(options = {}) {
 		const sql = yield* SqlClient;
 		const fetchFn = options.fetchFn ?? fetch;
 		const baseUrl = options.baseUrl ?? resolveCommandAppUrl();
-		const resolveStoredJwt = (forceRefresh) => gen(function* () {
+		const resolveStoredJwt = (forceRefresh, staleJwt) => gen(function* () {
 			const owner = yield* readMostRecentOwnerCommandAuthSession.pipe(provideService(SqlClient, sql), mapError((cause) => new ProjectLeadControllerClientError({
 				kind: "unavailable",
 				operation: "resolve-owner-session",
@@ -317561,7 +318770,8 @@ function makeProjectLeadControllerClientLive(options = {}) {
 				sessionId: owner.sessionId,
 				subject: owner.subject,
 				logPrefix: "project-lead-scheduler",
-				forceRefresh
+				forceRefresh,
+				staleAccessToken: staleJwt
 			}).pipe(provideService(SqlClient, sql));
 			if (!jwt) return yield* new ProjectLeadControllerClientError({
 				kind: "unauthenticated",
@@ -317604,7 +318814,7 @@ function makeProjectLeadControllerClientLive(options = {}) {
 			}));
 			if (first._tag === "Success") return first.success;
 			if (first.failure.kind !== "unauthenticated") return yield* first.failure;
-			const refreshed = yield* resolveJwt(true);
+			const refreshed = yield* resolveJwt(true, jwt);
 			return yield* requestAttempt({
 				...input,
 				jwt: refreshed
@@ -319998,12 +321208,12 @@ const gitUrlCloneRouteLayer = add$1("POST", "/api/cloud/git/clone-url", gen(func
 //#region src/server.ts
 const PtyAdapterLive = unwrap(gen(function* () {
 	if (typeof Bun !== "undefined") return (yield* promise(() => import("./BunPTY-DkAIzLIx.mjs"))).layer;
-	else return (yield* promise(() => import("./NodePTY-B1u6RHXk.mjs"))).layer;
+	else return (yield* promise(() => import("./NodePTY-BhezYy9H.mjs"))).layer;
 }));
 const HttpServerLive = unwrap(gen(function* () {
 	const config = yield* ServerConfig;
-	if (typeof Bun !== "undefined") return (yield* promise(() => import("./BunHttpServer-CVPGkizx.mjs"))).layer(bunHttpServerOptions(config));
-	const [NodeHttpServer, NodeHttp] = yield* all([promise(() => import("./NodeHttpServer-UQnvZnmu.mjs")), promise(() => import("node:http"))]);
+	if (typeof Bun !== "undefined") return (yield* promise(() => import("./BunHttpServer-FbbQmsl_.mjs"))).layer(bunHttpServerOptions(config));
+	const [NodeHttpServer, NodeHttp] = yield* all([promise(() => import("./NodeHttpServer-BJ4l15f-.mjs")), promise(() => import("node:http"))]);
 	return NodeHttpServer.layer(NodeHttp.createServer, {
 		host: config.host,
 		port: config.port
@@ -320011,10 +321221,10 @@ const HttpServerLive = unwrap(gen(function* () {
 }));
 const PlatformServicesLive = unwrap(gen(function* () {
 	if (typeof Bun !== "undefined") {
-		const { layer } = yield* promise(() => import("./BunServices-CPrZSIfE.mjs"));
+		const { layer } = yield* promise(() => import("./BunServices-DC7nhA3w.mjs"));
 		return layer;
 	} else {
-		const { layer } = yield* promise(() => import("./NodeServices-z1Ac4lEO.mjs").then((n) => n.t));
+		const { layer } = yield* promise(() => import("./NodeServices-D3IxOzHl.mjs").then((n) => n.t));
 		return layer;
 	}
 }));
@@ -320079,7 +321289,7 @@ const MiscRuntimeLayerLive = mergeAll(AnalyticsServiceLayerLive, OpenLive, Serve
 const RuntimeDependenciesWithoutPullRequestsLive = ReactorLayerLive.pipe(provideMerge(CheckpointingLayerLive), provideMerge(GitLayerLive), provideMerge(OrchestrationLayerLive), provideMerge(ProviderLayerLive), provideMerge(TerminalLayerLive), provideMerge(AgentBrowserManagerLive), provideMerge(mergeAll(ThreadDevRuntimeLive, DevTunnelLive.pipe(provide$1(ThreadDevRuntimeLive)))), provideMerge(PersistenceLayerLive), provideMerge(KeybindingsLive), provideMerge(ProviderRegistryLive), provideMerge(mergeAll(ServerSettingsLive, UsageServiceLive.pipe(provide$1(ServerSettingsLive), provide$1(UsageSessionLookupLive), provide$1(UsageRecordedSourceLive.pipe(provide$1(OrchestrationLayerLive), provide$1(RuntimeReplicationOutboxLive), provide$1(ProviderSessionRuntimeRepositoryLive), provide$1(TextGenerationSessionRepositoryLive)))))), provideMerge(WorkspaceLayerLive), provideMerge(WorkspaceReadinessStateLive), provideMerge(ProjectFaviconResolverLive), provideMerge(RepositoryIdentityResolverLive), provideMerge(ServerEnvironmentLive), provideMerge(AuthLayerLive), provideMerge(ServerSecretStoreLayerLive), provideMerge(mergeAll(CloudRedisCoordinationLive, CloudStateSyncLive.pipe(provide$1(PersistenceLayerLive)))), provideMerge(MiscRuntimeLayerLive));
 const RuntimeDependenciesLive = pullRequestServiceFactoryLayer.pipe(provideMerge(RuntimeDependenciesWithoutPullRequestsLive), provideMerge(cmmdProjectIdentityResolverLive.pipe(provide$1(RuntimeDependenciesWithoutPullRequestsLive))), provideMerge(pullRequestProviderRuntimeLive));
 const RuntimeServicesLive = ServerRuntimeStartupLive.pipe(provideMerge(RuntimeDependenciesLive));
-const makeRoutesLayer = mergeAll(attachmentUploadRouteLayer, authBearerBootstrapRouteLayer, authBootstrapRouteLayer, authCommandBearerBootstrapRouteLayer, authCommandBootstrapRouteLayer, authOAuthTokenExchangeRouteLayer, authWebSocketTicketRouteLayer, authCmmdOAuthDeviceRouteLayer, authCmmdOAuthTokenRouteLayer, authCmmdPasswordTokenRouteLayer, authClientsRevokeOthersRouteLayer, authClientsRevokeRouteLayer, authClientsRouteLayer, authLogoutRouteLayer, authPairingLinksRevokeRouteLayer, authPairingLinksRouteLayer, authPairingCredentialRouteLayer, authSessionRouteLayer, authWebSocketTokenRouteLayer, authWebLoginRouteLayer, authWebCallbackRouteLayer, desktopLocalWebBridgePublishRouteLayer, desktopLocalWebBridgeBootstrapRouteLayer, desktopRelayControlPlaneRouteLayer, apiDocsHtmlRouteLayer, apiDocsOpenApiRouteLayer, pulseSignalStateListRouteLayer, pulseSignalStateUpsertRouteLayer, cmmdProfileRouteLayer, ...cmmdProxyRouteLayers, cmmdWorkIntakeRouteLayer, cmmdWsTokenRouteLayer, cmmdGetProjectCommentsRouteLayer, cmmdAddProjectCommentRouteLayer, cmmdUpdateProjectRouteLayer, cmmdUploadTaskAttachmentRouteLayer, cmmdUpdateTaskCommentRouteLayer, cmmdListWorkspaceMembersRouteLayer, cmmdAddProjectMemberRouteLayer, cmmdUpdateProjectAgentMemberAvatarRouteLayer, runtimeReplicationStatusRouteLayer, cmmdRefreshProviderUsageRouteLayer, cmmdForgeCloudProjectsListRouteLayer, cmmdForgeCloudProjectsEventsRouteLayer, cmmdForgeRuntimesEnsureRouteLayer, cmmdForgeRuntimesConnectRouteLayer, ownerRuntimeCodexReadinessRouteLayer, cmmdForgeRuntimesStatusRouteLayer, cmmdForgeRuntimesStartRouteLayer, cmmdForgeRuntimesStopRouteLayer, cmmdForgeRuntimesRecycleRouteLayer, cmmdForgeRuntimesUpdateCommitRouteLayer, cmmdForgeRuntimesDestroyRouteLayer, mobileProviderCatalogRouteLayer, attachmentsRouteLayer, orchestrationDispatchRouteLayer, orchestrationCmmdWorkRunEventRouteLayer, orchestrationAutomationStartThreadRouteLayer, orchestrationAutomationRebindRouteLayer, orchestrationAutomationTerminalReconcileRouteLayer, mobileGitRunStackedActionRouteLayer, pullRequestDiffRouteLayer, orchestrationSnapshotRouteLayer, localAutomationListRouteLayer, localAutomationCreateRouteLayer, localAutomationUpdateRouteLayer, localAutomationDeleteRouteLayer, localAutomationRunRouteLayer, otlpTracesProxyRouteLayer, devTunnelProxyRouteLayer, devTunnelLocalPortProxyRouteLayer, projectFaviconRouteLayer, serverEnvironmentRouteLayer, browserWebRtcReadinessRouteLayer, staticAndDevRouteLayer, githubStatusRouteLayer, githubAuthorizeUrlRouteLayer, githubDisconnectRouteLayer, githubReposRouteLayer, githubCloneRouteLayer, githubCloneJobStartRouteLayer, githubCloneJobStatusRouteLayer, githubRefreshCredentialsRouteLayer, githubToolConfirmationApproveRouteLayer, projectLinkGetRouteLayer, projectLinkListRouteLayer, projectLinkSetRouteLayer, projectLinkDeleteRouteLayer, cmmdWorkspacesRouteLayer, cmmdCampaignsRouteLayer, cmmdProjectLinksRouteLayer, cmmdEnsureGitHubProjectContextRouteLayer, cmmdProjectRepositoryEnsureRouteLayer, cmmdProjectsGetRouteLayer, cmmdProjectsCreateRouteLayer, workspaceReadinessRouteLayer, runtimeLivenessRouteLayer, runtimeFilesystemHealthRouteLayer, claudeNativeGenerationProofRouteLayer, claudeUsageRouteLayer, codexRuntimeProviderReadinessRouteLayer, runtimeDiagnosticsRouteLayer, cloudFoldersRouteLayer, cloudProjectCreateRouteLayer, gitUrlCloneRouteLayer, websocketRpcRouteLayer).pipe(provide$1(browserApiCorsLayer));
+const makeRoutesLayer = mergeAll(attachmentUploadRouteLayer, authBearerBootstrapRouteLayer, authBootstrapRouteLayer, authCommandBearerBootstrapRouteLayer, authCommandBootstrapRouteLayer, authOAuthTokenExchangeRouteLayer, authWebSocketTicketRouteLayer, authCmmdOAuthDeviceRouteLayer, authCmmdOAuthTokenRouteLayer, authCmmdPasswordTokenRouteLayer, authClientsRevokeOthersRouteLayer, authClientsRevokeRouteLayer, authClientsRouteLayer, authLogoutRouteLayer, authPairingLinksRevokeRouteLayer, authPairingLinksRouteLayer, authPairingCredentialRouteLayer, authSessionRenewRouteLayer, authSessionRouteLayer, authWebSocketTokenRouteLayer, authWebLoginRouteLayer, authWebCallbackRouteLayer, desktopLocalWebBridgePublishRouteLayer, desktopLocalWebBridgeBootstrapRouteLayer, desktopRelayControlPlaneRouteLayer, apiDocsHtmlRouteLayer, apiDocsOpenApiRouteLayer, pulseSignalStateListRouteLayer, pulseSignalStateUpsertRouteLayer, cmmdProfileRouteLayer, ...cmmdProxyRouteLayers, cmmdWorkIntakeRouteLayer, cmmdWsTokenRouteLayer, cmmdGetProjectCommentsRouteLayer, cmmdAddProjectCommentRouteLayer, cmmdUpdateProjectRouteLayer, cmmdUploadTaskAttachmentRouteLayer, cmmdUpdateTaskCommentRouteLayer, cmmdListWorkspaceMembersRouteLayer, cmmdAddProjectMemberRouteLayer, cmmdUpdateProjectAgentMemberAvatarRouteLayer, runtimeReplicationStatusRouteLayer, cmmdRefreshProviderUsageRouteLayer, cmmdForgeCloudProjectsListRouteLayer, cmmdForgeCloudProjectsEventsRouteLayer, cmmdForgeRuntimesEnsureRouteLayer, cmmdForgeRuntimesConnectRouteLayer, ownerRuntimeCodexReadinessRouteLayer, cmmdForgeRuntimesStatusRouteLayer, cmmdForgeRuntimesStartRouteLayer, cmmdForgeRuntimesStopRouteLayer, cmmdForgeRuntimesRecycleRouteLayer, cmmdForgeRuntimesUpdateCommitRouteLayer, cmmdForgeRuntimesDestroyRouteLayer, mobileProviderCatalogRouteLayer, attachmentsRouteLayer, orchestrationDispatchRouteLayer, orchestrationCmmdWorkRunEventRouteLayer, orchestrationAutomationStartThreadRouteLayer, orchestrationAutomationRebindRouteLayer, orchestrationAutomationTerminalReconcileRouteLayer, mobileGitRunStackedActionRouteLayer, pullRequestDiffRouteLayer, orchestrationSnapshotRouteLayer, orchestrationThreadSnapshotRouteLayer, localAutomationListRouteLayer, localAutomationCreateRouteLayer, localAutomationUpdateRouteLayer, localAutomationDeleteRouteLayer, localAutomationRunRouteLayer, otlpTracesProxyRouteLayer, devTunnelProxyRouteLayer, devTunnelLocalPortProxyRouteLayer, projectFaviconRouteLayer, serverEnvironmentRouteLayer, browserWebRtcReadinessRouteLayer, staticAndDevRouteLayer, githubStatusRouteLayer, githubAuthorizeUrlRouteLayer, githubDisconnectRouteLayer, githubReposRouteLayer, githubCloneRouteLayer, githubCloneJobStartRouteLayer, githubCloneJobStatusRouteLayer, githubRefreshCredentialsRouteLayer, githubToolConfirmationApproveRouteLayer, projectLinkGetRouteLayer, projectLinkListRouteLayer, projectLinkSetRouteLayer, projectLinkDeleteRouteLayer, cmmdWorkspacesRouteLayer, cmmdCampaignsRouteLayer, cmmdProjectLinksRouteLayer, cmmdEnsureGitHubProjectContextRouteLayer, cmmdProjectRepositoryEnsureRouteLayer, cmmdProjectsGetRouteLayer, cmmdProjectsCreateRouteLayer, workspaceReadinessRouteLayer, runtimeLivenessRouteLayer, runtimeFilesystemHealthRouteLayer, claudeNativeGenerationProofRouteLayer, claudeUsageRouteLayer, codexRuntimeProviderReadinessRouteLayer, runtimeDiagnosticsRouteLayer, cloudFoldersRouteLayer, cloudProjectCreateRouteLayer, gitUrlCloneRouteLayer, websocketRpcRouteLayer).pipe(provide$1(browserApiCorsLayer));
 const runServer = launch$1(unwrap(gen(function* () {
 	const config = yield* ServerConfig;
 	fixPath({ preferProcessPath: config.forgeCmmdRuntimeMode === true });
@@ -321009,7 +322219,7 @@ const connectLoginCommand = make$34("login", {
 			})).json();
 		},
 		openBrowser: async (url) => {
-			const open = (await import("./open-D8mGyWmt.mjs")).default;
+			const open = (await import("./open-FIgTDosf.mjs")).default;
 			await open(url);
 			return true;
 		},