@cmmd-center/forge 0.13.77 → 0.13.79

package/dist/bin.mjs

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 
 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 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-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 { $ as encodeEffect, $a as make$39, $i as spaced, $n as filterMapOrFail, $r as runPromise, $s as max, $t as stringifyJson, Aa as Scope$1, Ai as void_$1, An as cached$3, Ar as match$1, As as uninterruptibleMask, At as withConstructorDefault, Ba as CurrentLogSpans, Bi as counter, Bn as catch_, Bo as addFinalizer, Br as orDie, Bs as make$42, Bt as head, C as Record, Ca as mergeAll, Cc as map$4, 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, Ec as sort, 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 fail$1, Fi as withParentSpan, Fn as catchFilter, Fr as onError$1, Fs as MinimumTraceLevel, G as decodeExit, Ga as done, Gc as empty$1, Gi as withAttributes, Gl as hasProperty, Gn as die$1, Gr as provideService, Gs as format$1, Gt as Transformation, H as declare, Hc as Reference$1, Hi as snapshotUnsafe, 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, Ji as exponential, Jl as isNotUndefined, Jn as exit, Jr as repeat, Js as hours, Jt as transformOrFail, K as decodeSync, Kc as get$3, Ki as addDelay, Kl as isNotNull, Ko as consolePretty$1, Kr as race, Ks as fromInput, L as Unknown, La as makeUnsafe$4, 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, Ml as NodeInspectSymbol, Mn as callback, Mo as pretty, Ms as void_$2, Na as close, Ni as withFiber$1, Nl as toJson, Nn as catchCause, No as prettyErrors, Nr as matchEffect, O as TemplateLiteral, Oa as sync$2, Ol as isEffect$1, On as asSome, Or as mapError, Os as sync, Ot as toJsonSchemaDocument, P as Undefined, Pa as closeUnsafe, Pl as format, Pn as catchDefect, Po as squash, Pr as never$1, Q as encode$4, Qc as merge$2, Qi as recurs, Qn as filter$1, Qr as runForkWith, R as UnknownFromJsonString$1, Ra as provide$2, Rc as isFailure$1, Ri as yieldNow, Rl as equals, Rn as catchTag, Rr as onInterrupt, Rs as Tracer, Rt as drop$1, S as Option, Sa as merge$3, Si as try_, Sn as all, Sr as logFatal, Ss as scopeAddFinalizerExit, St as optional$4, T as Struct, Ta as provideMerge, Tc as reverse, Ti as undefined_, Tn as annotateLogs, To as hasInterruptsOnly, Tr as makeSpanScoped, Tt as tag, Ua as TracerTimingEnabled, Uc as Service$1, Ui as timer, Un as currentSpan, Ur as provide, Ut as toArray, V as brand, Va as MinimumLogLevel, Vc as succeed$1, Vi as gauge, Vn as context, Vo as andThen$1, Vr as orElseSucceed, Vt as isEmpty$2, W as decodeEffect, Wa as _await, Wc as add$2, Wi as update$3, Wl as compose$1, Wr as provideContext, Ws as days, X as decodeUnknownOption, Xc as make$35, Xl as isObject$1, Xn as failCause$1, Xr as retry, Xt as onSome, Y as decodeUnknownExit, Yc as getUnsafe$1, Yi as forever$2, Yl as isNullish, Yn as fail, Yr as result, Z as decodeUnknownSync, Za as isDeferred, Zc as makeUnsafe$3, Zi as passthrough$1, Zl as isTagged, Zr as runFork, Zs as isGreaterThan$1, Zt as parseJson$1, _ as NonEmptyArray, _a as effectContext, _i as tapErrorTag, _n as toUtc, _t as isSchemaError, a as DateTimeUtc, aa as Random$1, ac as sum$1, al as getOrElse, an as value, ao as interrupt$3, ar as fnUntraced, at as isBetween, au as constVoid, b as NullOr, bi as timeoutOrElse, bl as PipeInspectableProto, bn as acquireUseRelease, br as logDebug, bs as reportCauseUnsafe, bt as makeFilter, c as Defect, ca as Clock, cc as toSeconds, ci as sleep$4, cl as isNone, cn as add$3, co as match$2, cr as forkChild, cs as flatMap$1, ct as isGreaterThanOrEqualTo, d as Exit, dc as empty$3, di as succeedSome, dl as match, dn as isGreaterThanOrEqualTo$1, dr as forkScoped, ds as forkDetach, dt as isMaxLength, du as pipeArguments, ea as catchDone, ec as millis, el as firstSomeOf, er as filterOrFail, et as encodeSync, eu as cast, fa as TaggedError, fc as ensure, fi as suspend$1, fl as none$4, fn as make$38, fr as gen, ft as isMaxProperties, g as Never, ga as effect, gi as tapError, gn as toEpochMillis, gr as interruptible, gt as isSchema, h as Literals, ha as buildWithMemoMap, hc as fromIterable, hi as tapCause, hl as make$41, hn as toDate, hr as interrupt$1, ht as isPattern, i as Class, ic as subtract, ii as scoped, il as fromUndefinedOr, in as make$40, io as failCause$2, ir as fn$1, it as is$1, iu as constUndefined, ja as addFinalizer$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 withFiber, kn as asVoid, ks as tracerLogger$1, kt as toType, l as Duration, la as currentTimeMillis, lc as zero, li as succeed, ll as isSome, ln as distance, lr as forkDetach$1, ls as fnUntraced$1, lt as isInt, lu as identity, m as Literal, ma as build, mc as flatMapNullishOr, mi as tap, ml as Number$2, mn as now, mo as StackTrace, mr as ignoreCause, ms as loggerMake, mt as isNonEmpty, n as ArraySchema, nc as minutes, nl as flatten$1, no as die$2, nt as encodeUnknownExit, o as DateTimeUtcFromString, oa as clamp, oc as times, oi as service, ol as getOrNull, oo as isFailure, or as forEach, ot as isFinite$1, ou as constant, p as Int$1, pa as CurrentMemoMap, pc as filter, pi as sync$1, pl as some, pn as makeUnsafe$5, po as NoSuchElementError, pr as ignore, pt as isMinLength, q as decodeTo, qa as fail$3, qi as both, ql as isNotNullish, qn as ensuring, qr as raceFirst, qs as fromInputUnsafe, r as Boolean$1, ra as isDoneCause, rc as seconds, ri as scope$1, rl as fromNullishOr, rn as makeFormatterDefault, ro as fail$2, rr as flatten$2, rt as fromJsonString, ru as constTrue, sa as parse$6, sc as toMillis, si as serviceOption, sl as getOrUndefined, sn as encodeBase64Url$2, so as isSuccess, sr as forever$1, st as isGreaterThan, su as dual, t as Any, tc as min, ti as runPromiseWith, tl as flatMap$2, tn as InvalidValue$1, to as succeed$3, tr as flatMap, ts as fiberInterrupt, tt as encodeUnknownEffect, tu as compose, u as ErrorClass, ua as Class$1, uc as allocate, ui as succeedNone, ul as map$5, un as formatIso, uo as void_$3, ur as forkIn, us as forever, ut as isLessThanOrEqualTo, uu as pipe$1, v as NonEmptyString, va as effectDiscard, vc as isArrayNonEmpty, 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, wn as annotateCurrentSpan, wo as hasInterrupts, wr as logWarning$1, wt as suspend$2, x as Number$1, xa as launch$1, xi as tryPromise, xl as YieldableProto, xn as addFinalizer$2, xr as logError, xs as scope, xt as mutable, y as Null, ya as empty$4, yc as isReadonlyArrayNonEmpty, 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 isSuccess$1, zi as zipWith, zn as catchTags, zr as option, zs as externalSpan, zt as empty$2 } from "./Schema-Ay3DUM83.mjs";
+import { $t as interrupt$4, A as fromSubscription, At as end, B as onExit$1, Bt as sliding, C as fromChannel, Ct as fromSubscriptionArray, D as fromPull, Dt as make$44, E as fromPubSub, F as mapEffect$1, Ft as offer$1, G as runCollect, Gt as shutdown$2, Ht as takeAll, I as mapError$1, It as offerAll, J as runForEach, K as runDrain, Kt as subscribe$1, L as merge$4, Lt as offerUnsafe, M as make$43, Mt as failCause$4, N as map$7, O as fromQueue, Ot as makeUnsafe$6, P as mapAccum, Pt as make$45, Q as succeed$4, Qt as getCurrent, S as fromAsyncIterable, T as fromIterable$1, U as provideContext$1, Ut as unbounded$2, Vt as take$1, W as run$2, Wt as publish, X as runHead, Xt as makeUnsafe$7, Y as runForEachArray, Zt as await_, _t as drain, b as flatMap$3, c as callback$1, ct as get$4, d as debounce$1, dt as make$47, et as takeWhile, f as decodeText$1, g as ensuring$1, h as encodeText, j as isStream, kt as bounded, l as catchCause$1, lt as make$46, m as empty$5, nt as toAsyncIterable, q as runFold, qt as unbounded$1, r as FileSystem, rt as toPull, st as unwrap$1, t as Path$2, tn as runIn, tt as tick, u as concat$2, ut as get$5, v as failCause$5, vt as forEach$1, w as fromEffect, wt as fromTransform, x as fromArray, xt as mapInput, y as filter$2, zt as shutdown$1 } from "./Path-BIaGSU2M.mjs";
+import { _ as ChildProcessSpawner, a as Stdio, g as make$48, o as make$49, r as isQuitError } from "./NodeTerminal-CeaWke6-.mjs";
+import { n as layer$7 } from "./NodeServices-Bt1GwPBR.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-5UTabe01.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-BnFFyBjD.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-DOwpGEYJ.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-BBR7DPrQ.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 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-DpRIoWqP.mjs";
-import { n as PtySpawnError, t as PtyAdapter } from "./PTY-BzdbZ0Ym.mjs";
+import { n as PtySpawnError, t as PtyAdapter } from "./PTY-BRT13Y8S.mjs";
 import { t as settleValueWithin } from "./settle-BJcmpbvq.mjs";
 import { createRequire } from "node:module";
 import * as HE from "node:child_process";
@@ -65979,7 +65979,7 @@ function normalizeNumberish(value) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.13.77";
+var version$1 = "0.13.79";
 //#endregion
 //#region src/sentry.ts
 const SERVER_APP_NAME = "forge-server";
@@ -118820,8 +118820,8 @@ effectDiscard(runMigrations());
 //#endregion
 //#region src/persistence/Layers/Sqlite.ts
 const defaultSqliteClientLoaders = {
-	bun: () => import("./SqliteClient-Bgo_s5sA.mjs"),
-	node: () => import("./NodeSqliteClient-D29w60zZ.mjs")
+	bun: () => import("./SqliteClient-DQYXFVMu.mjs"),
+	node: () => import("./NodeSqliteClient-BpmyZDcj.mjs")
 };
 const makeRuntimeSqliteLayer = fn$1("makeRuntimeSqliteLayer")(function* (config) {
 	const loader = defaultSqliteClientLoaders[process.versions.bun !== void 0 ? "bun" : "node"];
@@ -213493,6 +213493,7 @@ function categorizePublicProviderError(message) {
 	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.";
+	if (/_credential_reconnect_required\b/.test(m)) return "The workspace AI credential needs to be reconnected. Reconnect it in Settings > Providers, then retry.";
 	if (/\b(unauthorized|forbidden|authentication\s+(failed|error|required)|invalid\s+api\s+key|expired\s+(token|credential))\b/.test(m) || /\b40[13]\b/.test(m)) return "Workspace AI authentication failed. Reconnect the workspace and retry.";
 	if (/\b(timed?\s*out|timeout|overloaded|service\s+unavailable)\b/.test(m) || /\b50[234]\b/.test(m)) return "The AI service is temporarily overloaded. Retry in a moment.";
 	return null;
@@ -292016,6 +292017,52 @@ function applyThreadGoalPreamble(goal, input) {
 	return trimmedInput.length > 0 ? `${preamble}\n\n${trimmedInput}` : preamble;
 }
 //#endregion
+//#region src/orchestration/providerRetryableFailure.ts
+/**
+* Classifies a provider turn-start failure as a retryable rate-limit or
+* transient-availability failure (429/503), a terminal failure that names why
+* it will never clear on its own, or unrecognized (null).
+*
+* CMMD-Center/forge#3558: a 429 from CMMD's provider egress used to leave no
+* trace at all, because nothing in the turn-start path recognized it as a
+* distinct, retryable failure. `ProviderCommandReactor` uses this to decide
+* whether to retry a turn start with backoff, and to name the provider,
+* status and Retry-After in the `provider.turn.start.failed` activity CMMD's
+* watchdog reads once retries are exhausted.
+*
+* Reuses `isProviderRateOrQuotaError` (the same predicate the public-copy
+* sanitizer uses to recognize a rate-limit message) rather than restating its
+* word list here.
+*/
+const SERVICE_UNAVAILABLE_PATTERN = /\b(503|service\s+unavailable)\b/i;
+const RATE_LIMITED_PAST_TENSE_PATTERN = /\brate[\s-]?limit(?:ed|ing)?\b/i;
+const QUOTA_OR_USAGE_LIMIT_PATTERN = /\b(usage[ _-]limit|usage_limit_reached|quota|insufficient_quota)\b/i;
+const EXPLICIT_429_PATTERN = /\b429\b/;
+const RETRY_AFTER_SECONDS_PATTERN = /retry-after[^0-9]{0,10}(\d+)|(?:try again|retry)\s+in\s+(\d+)\s*(?:s\b|sec(?:onds?)?\b)?/i;
+function parseRetryAfterSeconds(detail) {
+	const match = detail.match(RETRY_AFTER_SECONDS_PATTERN);
+	if (!match) return null;
+	const raw = match[1] ?? match[2];
+	const seconds = raw ? Number(raw) : NaN;
+	return Number.isFinite(seconds) ? seconds : null;
+}
+function classifyRetryableProviderFailure(detail) {
+	if (!detail || detail.trim().length === 0) return null;
+	if (QUOTA_OR_USAGE_LIMIT_PATTERN.test(detail) && !EXPLICIT_429_PATTERN.test(detail)) return {
+		kind: "terminal",
+		reason: "quota",
+		message: detail
+	};
+	const isRateLimited = isProviderRateOrQuotaError(detail) || RATE_LIMITED_PAST_TENSE_PATTERN.test(detail);
+	const isUnavailable = SERVICE_UNAVAILABLE_PATTERN.test(detail);
+	if (!isRateLimited && !isUnavailable) return null;
+	return {
+		kind: "retryable",
+		status: isRateLimited ? 429 : 503,
+		retryAfterSeconds: parseRetryAfterSeconds(detail)
+	};
+}
+//#endregion
 //#region src/orchestration/Layers/ProviderCommandReactor.ts
 function toNonEmptyProviderInput(value) {
 	const normalized = value?.trim();
@@ -292036,6 +292083,40 @@ const HANDLED_TURN_START_KEY_MAX = 1e4;
 const HANDLED_TURN_START_KEY_TTL = minutes(30);
 const DEFAULT_RUNTIME_MODE = "full-access";
 const DEFAULT_THREAD_TITLE = "New thread";
+/**
+* Bounds retrying a turn-start ack (`turn/start`) that failed with a
+* retryable status (429/503). Kept well under `withProviderTurnStartTimeout`'s
+* 45 s budget: a Retry-After longer than fits here would otherwise blow that
+* timeout and end the turn as an unreplicated `provider.turn.start.timeout`
+* instead of the replicated `provider.turn.start.failed` CMMD's watchdog reads
+* (CMMD-Center/forge#3558).
+*/
+const PROVIDER_RETRY_MAX_ATTEMPTS = 3;
+const PROVIDER_RETRY_BASE_DELAY = millis(100);
+/** The longest this loop will ever wait for a single attempt's Retry-After. */
+const PROVIDER_RETRY_MAX_DELAY_PER_ATTEMPT = seconds(20);
+/**
+* The longest this loop will ever sleep in total, across every attempt,
+* counted from the first failure. Two sleeps at the per-attempt cap above
+* would already reach 40s on their own, leaving nothing for the
+* `ensureSessionForThread` preamble work and the `sendTurn` round trips that
+* share `withProviderTurnStartTimeout`'s 45s budget with this loop. 30s keeps
+* 15s of headroom for that other work. A Retry-After that would need more
+* than what remains fails the turn immediately and names the real ask,
+* rather than sleeping a truncated amount and 429ing again anyway once it
+* wakes up (CMMD-Center/forge#3558 review item 4).
+*/
+const PROVIDER_RETRY_TOTAL_SLEEP_BUDGET = seconds(30);
+/**
+* How long the reactor watches for `turn.started` (or a terminal failure)
+* after a turn-start ack succeeds, before treating silence as a failure.
+* Codex retries a 429 internally and reports every attempt as a bare `error`
+* notification with `willRetry`, none of which reach CMMD on their own
+* (mapped to `runtime.warning`, which does not replicate) — this is the
+* budget for those internal retries to either land or report a final failure
+* (CMMD-Center/forge#3558).
+*/
+const PROVIDER_TURN_START_WATCH_BUDGET = minutes(3);
 const isProviderValidationError = is$1(ProviderValidationError);
 const isProviderKind = is$1(ProviderKind);
 function isPathInsideRoot(candidatePath, rootPath) {
@@ -292180,6 +292261,176 @@ function takeValidatedContinuationSession(input) {
 function discardOwnedContinuationSession(staged, threadId) {
 	if (staged?.threadId === threadId) takeExactThreadContinuationSession(staged);
 }
+/** The message text and, when the error carries one, the provider name it named. */
+function sendTurnFailureDetail(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	const provider = error !== null && typeof error === "object" && "provider" in error && typeof error.provider === "string" ? error.provider : void 0;
+	return provider !== void 0 ? {
+		message,
+		provider
+	} : { message };
+}
+/**
+* The delay before the next `sendTurn` attempt: the provider's own
+* Retry-After when it gave one, otherwise exponential backoff from
+* `PROVIDER_RETRY_BASE_DELAY`. Deliberately not capped here --
+* `sendTurnWithRetry` decides whether the desired delay fits the per-attempt
+* and total budgets, and fails outright rather than silently sleeping less
+* than the provider asked for (CMMD-Center/forge#3558 review item 4).
+*/
+function desiredRetryDelay(input) {
+	if (input.retryAfterSeconds !== null) return seconds(input.retryAfterSeconds);
+	return times(PROVIDER_RETRY_BASE_DELAY, 2 ** (input.attempt - 1));
+}
+/**
+* The `provider.turn.start.failed` detail once retries are exhausted. Names
+* the provider, the status every attempt answered, how many attempts ran, and
+* the Retry-After the provider asked for, so CMMD's watchdog (and whoever
+* reads the failed Work Session) knows this was a rate limit rather than an
+* unspecified refusal.
+*/
+function retryExhaustedFailureDetail(input) {
+	const providerLabel = input.provider ? `The ${input.provider} provider` : "The provider";
+	const retryAfter = input.classified.retryAfterSeconds !== null ? ` It asked to retry after ${input.classified.retryAfterSeconds}s.` : "";
+	return `${providerLabel} responded ${input.classified.status} on every attempt (${input.attempts} of ${input.attempts}).${retryAfter} ${input.underlyingMessage}`;
+}
+/**
+* The `provider.turn.start.failed` detail when honoring the provider's own
+* Retry-After would need more time than `PROVIDER_RETRY_MAX_DELAY_PER_ATTEMPT`
+* or the loop's remaining `PROVIDER_RETRY_TOTAL_SLEEP_BUDGET` allow. Fails the
+* turn immediately and names the real ask, rather than sleeping a truncated
+* amount and 429ing again once it wakes up (CMMD-Center/forge#3558 review
+* item 4).
+*/
+function retryBudgetExceededFailureDetail(input) {
+	return `${input.provider ? `The ${input.provider} provider` : "The provider"} asked to retry after ${input.classified.retryAfterSeconds !== null ? `${input.classified.retryAfterSeconds}s` : "an unspecified time"}, longer than Forge allows for a turn-start retry (stopped after ${input.attempts} of ${PROVIDER_RETRY_MAX_ATTEMPTS} attempts). ${input.underlyingMessage}`;
+}
+/**
+* The `provider.turn.start.failed` detail when the turn-start ack succeeded
+* but no `turn.started`, no terminal failure, and (past the watch budget) no
+* event at all ever arrived for it — Codex retrying a 429 with no observable
+* progress until it either recovers or gives up.
+*/
+function turnStartWatchTimedOutDetail(lastRetrySignal) {
+	if (lastRetrySignal === null) return "The provider accepted the turn but never reported it starting, and reported no error either.";
+	if (lastRetrySignal.kind === "terminal") return `The provider reported a failure that will not clear by retrying, and never started the turn. ${lastRetrySignal.message}`;
+	const retryAfter = lastRetrySignal.retryAfterSeconds !== null ? ` It last asked to retry after ${lastRetrySignal.retryAfterSeconds}s.` : "";
+	return `The provider kept answering ${lastRetrySignal.status} without ever starting the turn or reporting a final error.${retryAfter}`;
+}
+/**
+* The events that end the watch started after a turn-start ack: the turn
+* actually starting, that same turn completing (a Codex retry loop can settle
+* `turn/completed` with no `turn/started` in between), or a runtime error for
+* THIS turn (Codex's final `error` notification once `willRetry` turns false
+* — see `mapCodexRuntimeErrorEvent`).
+*
+* `runtime.error` matches when it carries no turn id at all (a genuine
+* session-level error) or carries this exact turn's id. This buffer starts
+* before the ack (`openTurnStartEventBuffer`), so a `runtime.error` for a
+* DIFFERENT, still-in-flight turn on the same thread is now visible to this
+* watch too; without the turn id check, that event would wrongly end this
+* turn's watch (forge-runtime-supervision's async-hold-and-refresh interleaving
+* review).
+*/
+function isTurnStartWatchTerminalEvent(event, turnId) {
+	if (event.type === "turn.started") return event.turnId === turnId;
+	if (event.type === "turn.completed") return event.turnId === turnId;
+	return event.type === "runtime.error" && (event.turnId === void 0 || event.turnId === turnId);
+}
+/**
+* Retries `sendTurn` on a retryable ack failure (429/503), with backoff
+* bounded by `PROVIDER_RETRY_MAX_ATTEMPTS`, `PROVIDER_RETRY_MAX_DELAY_PER_ATTEMPT`
+* and `PROVIDER_RETRY_TOTAL_SLEEP_BUDGET`. A non-retryable failure (401, the
+* #3552 broker-authority miss, quota exhaustion, an unrelated adapter error)
+* fails on the first attempt.
+*
+* Never resubmits after an ack succeeds: codex has already created the turn
+* by then, and a second `turn/start` would duplicate it and resend the
+* user's message. Once retries are exhausted — or the provider's own
+* Retry-After would need more time than this loop allows — the failure this
+* raises names the provider, the status, and the real Retry-After, rather
+* than whatever the underlying adapter error happened to say.
+*
+* Exported and kept at module scope (out of `ProviderCommandReactor`'s
+* `make`) so it can be tested directly against a fake clock, without a real
+* 20-30s wait (CMMD-Center/forge#3558 review item 4).
+*/
+const sendTurnWithRetry = fn$1("sendTurnWithRetry")(function* (input) {
+	let attempt = 1;
+	let totalSlept = zero;
+	while (true) {
+		const outcome = yield* result(input.sendTurn(input.turnInput));
+		if (outcome._tag === "Success") return outcome.success;
+		const { message, provider } = sendTurnFailureDetail(outcome.failure);
+		const classified = classifyRetryableProviderFailure(message);
+		if (classified === null || classified.kind === "terminal") return yield* outcome.failure;
+		const desired = desiredRetryDelay({
+			attempt,
+			retryAfterSeconds: classified.retryAfterSeconds
+		});
+		const remainingBudget = subtract(PROVIDER_RETRY_TOTAL_SLEEP_BUDGET, totalSlept);
+		const exceedsBudget = isGreaterThan$1(desired, PROVIDER_RETRY_MAX_DELAY_PER_ATTEMPT) || isGreaterThan$1(desired, remainingBudget);
+		if (attempt >= PROVIDER_RETRY_MAX_ATTEMPTS || exceedsBudget) return yield* new ProviderAdapterRequestError({
+			provider: provider ?? "provider",
+			method: "turn/start",
+			detail: exceedsBudget ? retryBudgetExceededFailureDetail({
+				provider,
+				classified,
+				attempts: attempt,
+				underlyingMessage: message
+			}) : retryExhaustedFailureDetail({
+				provider,
+				classified,
+				attempts: attempt,
+				underlyingMessage: message
+			}),
+			cause: outcome.failure
+		});
+		yield* sleep$4(desired);
+		totalSlept = sum$1(totalSlept, desired);
+		attempt += 1;
+	}
+});
+/**
+* Runs the flow after a turn-start ack attempt. On a failed or skipped ack,
+* closes the event buffer and reports through `onFailure`/`onSkipped`; on a
+* successful ack, hands off to `onSent`, which forks the turn-start watch
+* that then owns the buffer for the rest of its life.
+*
+* Wrapped in its own `Effect.onInterrupt` covering `send` through `onSent`:
+* an interrupt landing anywhere in that span — mid-ack, mid the retry's own
+* backoff, or in the gap between a successful ack and the watch actually
+* being forked — still closes the buffer. Once `onSent` returns (the watch
+* has been forked), this effect has completed normally and the wrapper no
+* longer applies from there on; the watch's own `Effect.ensuring` owns the
+* buffer from that point (CodeRabbit on CMMD-Center/forge#3558: the buffer
+* never closed on a pre-fork interrupt).
+*
+* Deliberately does not release the turn-start hold: that stays the
+* caller's job. `recoverProviderTurnStartTimeout`'s `releaseHold` and
+* `processDomainEventSafely`'s own `Effect.onInterrupt` already cover every
+* path that can end this attempt (review items 3 and 7), and releasing here
+* too would let the hold go before a failure activity this same interrupt
+* is still writing has landed.
+*
+* Extracted to module scope — like `sendTurnWithRetry` above — so this
+* interrupt-safety claim can be exercised directly with `Deferred` and
+* `Fiber.interrupt`, without the full reactor test harness.
+*/
+const runTurnStartAckOutcome = (input) => gen(function* () {
+	const sendExit = yield* input.send.pipe(exit);
+	if (isFailure(sendExit)) {
+		yield* input.close;
+		yield* input.onFailure(sendExit.cause);
+		return;
+	}
+	if (sendExit.value._tag === "skipped") {
+		yield* input.close;
+		yield* input.onSkipped;
+		return;
+	}
+	yield* input.onSent(sendExit.value.turnId);
+}).pipe(onInterrupt(() => input.close));
 function buildGeneratedWorktreeBranchName(raw) {
 	const normalized = raw.trim().toLowerCase().replace(/^refs\/heads\//, "").replace(/['"`]/g, "");
 	const branchFragment = (normalized.startsWith(`forge/`) ? normalized.slice(`${WORKTREE_BRANCH_PREFIX}/`.length) : normalized).replace(/[^a-z0-9/_-]+/g, "-").replace(/\/+/g, "/").replace(/-+/g, "-").replace(/^[./_-]+|[./_-]+$/g, "").slice(0, 64).replace(/[./_-]+$/g, "");
@@ -292194,12 +292445,48 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 	const serverSettingsService = yield* ServerSettingsService;
 	const serverConfig = yield* ServerConfig;
 	const runtimeDrainState = yield* RuntimeDrainState;
+	const spriteTaskHoldReactor = yield* serviceOption(SpriteTaskHoldReactor);
+	const holdTurnStart = (key) => isSome(spriteTaskHoldReactor) ? spriteTaskHoldReactor.value.holdTurnStart(key) : void_$1;
+	const releaseTurnStart = (key) => isSome(spriteTaskHoldReactor) ? spriteTaskHoldReactor.value.releaseTurnStart(key) : void_$1;
 	const handledTurnStartKeys = yield* make$51({
 		capacity: HANDLED_TURN_START_KEY_MAX,
 		timeToLive: HANDLED_TURN_START_KEY_TTL,
 		lookup: () => succeed(true)
 	});
 	const hasHandledTurnStartRecently = (key) => getOption(handledTurnStartKeys, key).pipe(flatMap((cached) => set$4(handledTurnStartKeys, key, true).pipe(as$3(isSome(cached)))));
+	/**
+	* Per-attempt buffers of `providerService.streamEvents`, keyed by the same
+	* turn-start attempt key `holdTurnStart` uses — not by thread id: two
+	* overlapping turn-start attempts on one thread each need their own buffer,
+	* fed from before each one's own ack (see the doc comment on `holdTurnStart`
+	* calls below, and forge-runtime-supervision's interleaving review).
+	* `startTurnStartEventRouter` is the one place that ever reads
+	* `providerService.streamEvents` for this purpose, subscribed once for the
+	* reactor's whole lifetime, exactly like `SpriteTaskHoldReactor.start`, so no
+	* attempt ever races to open its own subscription in time for its ack
+	* (CMMD-Center/forge#3558 review item 1).
+	*/
+	const turnStartEventBuffers = /* @__PURE__ */ new Map();
+	const openTurnStartEventBuffer = (key, threadId) => gen(function* () {
+		const queue = yield* unbounded$2();
+		turnStartEventBuffers.set(key, {
+			threadId,
+			queue
+		});
+		return queue;
+	});
+	const closeTurnStartEventBuffer = (key, queue) => sync$1(() => {
+		if (turnStartEventBuffers.get(key)?.queue === queue) turnStartEventBuffers.delete(key);
+	}).pipe(andThen(shutdown$1(queue)));
+	/**
+	* Started once from `start()`. Fans out every provider event to every
+	* currently-open buffer for its thread — plural, not a single lookup,
+	* because two turn-start attempts can be in flight on the same thread at
+	* once (CMMD-Center/forge#3558 review item 1).
+	*/
+	const startTurnStartEventRouter = fn$1("startTurnStartEventRouter")(function* () {
+		yield* forkScoped(runForEach(providerService.streamEvents, (event) => forEach(Array.from(turnStartEventBuffers.values()).filter((entry) => entry.threadId === event.threadId), (entry) => offer$1(entry.queue, event), { discard: true })));
+	});
 	const threadModelSelections = /* @__PURE__ */ new Map();
 	/**
 	* The providerAccountId each LIVE provider session was actually started with.
@@ -292356,9 +292643,87 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 		yield* bindSessionToThread(startedSession);
 		return startedSession.threadId;
 	});
+	/**
+	* Waits for a turn-start ack to either start (or complete) or fail, after
+	* the provider has already accepted it. Codex's own 429 retries surface as
+	* an `error` notification with `willRetry`, mapped to `runtime.warning`
+	* while retries continue and to `runtime.error` only once they stop
+	* (`mapCodexRuntimeErrorEvent`); `runtime.warning` never replicates to CMMD,
+	* so without this a turn that fails this way never told CMMD anything
+	* happened at all (CMMD-Center/forge#3558).
+	*
+	* Reads from `events`, a per-attempt buffer opened by
+	* `openTurnStartEventBuffer` BEFORE the ack was sent, rather than
+	* subscribing to `providerService.streamEvents` directly here: a fresh
+	* subscription opened only now would miss a `turn.started` published in the
+	* gap between the ack and this call (review item 1).
+	*/
+	const watchTurnStartOutcome = fn$1("watchTurnStartOutcome")(function* (input) {
+		const lastRetrySignal = yield* make$50(null);
+		const terminalEvent = yield* fromQueue(input.events).pipe(mapEffect$1((event) => gen(function* () {
+			if (event.type === "runtime.warning") {
+				const classified = classifyRetryableProviderFailure(event.payload.message);
+				if (classified) yield* set$3(lastRetrySignal, classified);
+			}
+			return event;
+		})), filter$2((event) => isTurnStartWatchTerminalEvent(event, input.turnId)), runHead).pipe(timeout$1(PROVIDER_TURN_START_WATCH_BUDGET), catchTag("TimeoutError", () => succeed(none$4())));
+		if (isNone(terminalEvent)) return {
+			_tag: "TimedOut",
+			lastRetrySignal: yield* get$6(lastRetrySignal)
+		};
+		const event = terminalEvent.value;
+		if (event.type === "turn.started") return { _tag: "Started" };
+		if (event.type === "turn.completed") return {
+			_tag: "Failed",
+			detail: event.payload.errorMessage ?? "The provider ended the turn with no error detail."
+		};
+		return {
+			_tag: "Failed",
+			detail: event.payload.message
+		};
+	});
+	/**
+	* Finalizes a turn-start watch: releases the turn-start hold and closes its
+	* event buffer, only AFTER the outcome is durably handled — either the turn
+	* started, or the `provider.turn.start.failed` activity has actually been
+	* persisted. No blanket `Effect.ensuring` for the release: if
+	* `appendProviderFailureActivity` itself fails, the hold stays held rather
+	* than being released with no durable record of why the turn failed
+	* (review item 2). `Effect.onInterrupt` covers the one case that ordering
+	* cannot: a shutdown while this watch is still waiting. A write mid-shutdown
+	* is not reliable, so that path only releases the hold; the turn is left
+	* for CMMD's own sweep rather than ended with an event here (review item 7).
+	* The event buffer itself always closes, via `Effect.ensuring`: it is a
+	* local resource with nothing durable riding on its cleanup order.
+	*/
+	const watchTurnStartAndFinalize = (input) => gen(function* () {
+		const outcome = yield* watchTurnStartOutcome({
+			threadId: input.threadId,
+			turnId: input.turnId,
+			events: input.events
+		});
+		if (outcome._tag === "Started") {
+			yield* releaseTurnStart(input.holdKey);
+			return;
+		}
+		const detail = outcome._tag === "Failed" ? outcome.detail : turnStartWatchTimedOutDetail(outcome.lastRetrySignal);
+		yield* appendProviderFailureActivity({
+			threadId: input.threadId,
+			kind: "provider.turn.start.failed",
+			summary: "Provider turn start failed",
+			detail: publicProviderFailureDetail(detail),
+			turnId: input.turnId,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		yield* releaseTurnStart(input.holdKey);
+	}).pipe(catchCause((cause) => hasInterruptsOnly(cause) ? void_$1 : logWarning$1("provider command reactor turn-start watch failed", {
+		threadId: input.threadId,
+		turnId: input.turnId,
+		cause: pretty(cause)
+	})), onInterrupt(() => releaseTurnStart(input.holdKey)), ensuring(closeTurnStartEventBuffer(input.holdKey, input.events)));
 	const sendTurnForThread = fn$1("sendTurnForThread")(function* (input) {
 		const thread = yield* resolveThread(input.threadId);
-		if (!thread) return;
+		if (!thread) return { _tag: "skipped" };
 		if (yield* runtimeDrainState.isDraining) {
 			yield* appendProviderFailureActivity({
 				threadId: input.threadId,
@@ -292368,7 +292733,7 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 				turnId: null,
 				createdAt: (/* @__PURE__ */ new Date()).toISOString()
 			});
-			return;
+			return { _tag: "skipped" };
 		}
 		yield* ensureSessionForThread(input.threadId, input.createdAt, input.modelSelection !== void 0 ? { modelSelection: input.modelSelection } : {});
 		if (input.modelSelection !== void 0) threadModelSelections.set(input.threadId, input.modelSelection);
@@ -292392,13 +292757,19 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 			...requestedModelSelection,
 			model: activeSession.model
 		} : requestedModelSelection : input.modelSelection;
-		yield* providerService.sendTurn({
-			threadId: input.threadId,
-			...normalizedInput ? { input: normalizedInput } : {},
-			...normalizedAttachments.length > 0 ? { attachments: normalizedAttachments } : {},
-			...modelForTurn !== void 0 ? { modelSelection: modelForTurn } : {},
-			...input.interactionMode !== void 0 ? { interactionMode: input.interactionMode } : {}
-		});
+		return {
+			_tag: "sent",
+			turnId: (yield* sendTurnWithRetry({
+				sendTurn: providerService.sendTurn,
+				turnInput: {
+					threadId: input.threadId,
+					...normalizedInput ? { input: normalizedInput } : {},
+					...normalizedAttachments.length > 0 ? { attachments: normalizedAttachments } : {},
+					...modelForTurn !== void 0 ? { modelSelection: modelForTurn } : {},
+					...input.interactionMode !== void 0 ? { interactionMode: input.interactionMode } : {}
+				}
+			})).turnId
+		};
 	});
 	const maybeGenerateAndRenameWorktreeBranchForFirstTurn = fn$1("maybeGenerateAndRenameWorktreeBranchForFirstTurn")(function* (input) {
 		if (!input.branch || !input.worktreePath) return;
@@ -292577,7 +292948,8 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 		});
 	});
 	const processTurnStartRequested = fn$1("processTurnStartRequested")(function* (event) {
-		if (yield* hasHandledTurnStartRecently(turnStartKeyForEvent(event))) return;
+		const key = turnStartKeyForEvent(event);
+		if (yield* hasHandledTurnStartRecently(key)) return;
 		const thread = yield* resolveThread(event.payload.threadId);
 		if (!thread) return;
 		const message = thread.messages.find((entry) => entry.id === event.payload.messageId);
@@ -292628,21 +293000,35 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 				...generationInput
 			}).pipe(forkScoped);
 		}
-		yield* sendTurnForThread({
-			threadId: event.payload.threadId,
-			messageText: message.text,
-			...message.attachments !== void 0 ? { attachments: message.attachments } : {},
-			...event.payload.modelSelection !== void 0 ? { modelSelection: event.payload.modelSelection } : {},
-			interactionMode: event.payload.interactionMode,
-			createdAt: event.payload.createdAt
-		}).pipe(catchCause((cause) => appendProviderFailureActivity({
-			threadId: event.payload.threadId,
-			kind: "provider.turn.start.failed",
-			summary: "Provider turn start failed",
-			detail: publicProviderFailureDetailFromCause(cause),
-			turnId: null,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
-		})));
+		const turnStartHoldKey = key;
+		yield* uninterruptible(holdTurnStart(turnStartHoldKey));
+		const turnStartEvents = yield* openTurnStartEventBuffer(turnStartHoldKey, event.payload.threadId);
+		yield* runTurnStartAckOutcome({
+			send: sendTurnForThread({
+				threadId: event.payload.threadId,
+				messageText: message.text,
+				...message.attachments !== void 0 ? { attachments: message.attachments } : {},
+				...event.payload.modelSelection !== void 0 ? { modelSelection: event.payload.modelSelection } : {},
+				interactionMode: event.payload.interactionMode,
+				createdAt: event.payload.createdAt
+			}),
+			close: closeTurnStartEventBuffer(turnStartHoldKey, turnStartEvents),
+			onFailure: (cause) => appendProviderFailureActivity({
+				threadId: event.payload.threadId,
+				kind: "provider.turn.start.failed",
+				summary: "Provider turn start failed",
+				detail: publicProviderFailureDetailFromCause(cause),
+				turnId: null,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			}).pipe(andThen(releaseTurnStart(turnStartHoldKey))),
+			onSkipped: releaseTurnStart(turnStartHoldKey),
+			onSent: (turnId) => watchTurnStartAndFinalize({
+				threadId: event.payload.threadId,
+				turnId,
+				holdKey: turnStartHoldKey,
+				events: turnStartEvents
+			}).pipe(forkScoped)
+		});
 	});
 	const processTurnInterruptRequested = fn$1("processTurnInterruptRequested")(function* (event) {
 		const thread = yield* resolveThread(event.payload.threadId);
@@ -292864,6 +293250,7 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 	});
 	const recoverTimedOutProviderTurnStart = (event) => recoverProviderTurnStartTimeout({
 		cleanup: stopTimedOutProviderSession(event),
+		releaseHold: releaseTurnStart(turnStartKeyForEvent(event)),
 		markRecoverable: appendRecoverableTurnStartTimeout(event),
 		markCleanupFailed: (cause) => appendProviderFailureActivity({
 			threadId: event.payload.threadId,
@@ -292876,7 +293263,7 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 	});
 	const processDomainEventSafely = (event) => {
 		const operation = processDomainEvent(event);
-		return (event.type === "thread.turn-start-requested" ? withProviderTurnStartTimeout(operation, recoverTimedOutProviderTurnStart(event)) : operation).pipe(catchCause((cause) => {
+		return (event.type === "thread.turn-start-requested" ? withProviderTurnStartTimeout(operation, recoverTimedOutProviderTurnStart(event)).pipe(onInterrupt(() => releaseTurnStart(turnStartKeyForEvent(event)))) : operation).pipe(catchCause((cause) => {
 			if (hasInterruptsOnly(cause)) return failCause$1(cause);
 			return logWarning$1("provider command reactor failed to process event", {
 				eventType: event.type,
@@ -292919,6 +293306,7 @@ const ProviderCommandReactorLive = effect(ProviderCommandReactor, gen(function*
 				if (event.type === "thread.meta-updated" && event.payload.regenerateTitle === true) return yield* titleRegenerationWorker.enqueue(event);
 			});
 			yield* clearInterruptedThreadTitleRegenerations().pipe(catchCause((cause) => logWarning$1("provider command reactor failed to sweep interrupted title regenerations", { cause: pretty(cause) })));
+			yield* startTurnStartEventRouter();
 			yield* forkScoped(runForEach(orchestrationEngine.streamDomainEvents, processEvent));
 		}),
 		drain: all([worker.drain, titleRegenerationWorker.drain], {
@@ -292934,7 +293322,7 @@ function recoverProviderTurnStartTimeout(input) {
 	return input.cleanup.pipe(matchEffect({
 		onFailure: input.markCleanupFailed,
 		onSuccess: () => input.markRecoverable
-	}));
+	}), ensuring(input.releaseHold));
 }
 (() => {
 	try {
@@ -294179,6 +294567,16 @@ const CheckpointReactorLive = effect(CheckpointReactor, gen(function* () {
 const LAUNCH_HOLD_MAX_REFRESHES = 10;
 /** The hold id of a pending turn start. The thread names it until turn.started arrives. */
 const launchHoldId = (threadId) => `launch-${threadId}`;
+/**
+* Refresh budget for a turn-start hold (`holdTurnStart`): about ten minutes, matching the launch
+* hold's own budget. `ProviderCommandReactor` bounds its own retry-and-watch window well inside
+* this; the budget here is the backstop if that watch is itself interrupted (a server restart, a
+* bug) without releasing the hold.
+*/
+const TURN_START_HOLD_MAX_REFRESHES = 10;
+/** The hold id for `holdTurnStart` / `releaseTurnStart`. Distinct from `launchHoldId` on purpose:
+* see the shape's doc comment on `holdTurnStart`. */
+const turnStartHoldId = (key) => `turn-start-${key}`;
 const SpriteTaskHoldReactorLive = effect(SpriteTaskHoldReactor, gen(function* () {
 	const providerService = yield* ProviderService;
 	const manager = makeSpriteTaskHoldManager(process.env, (message, cause) => {
@@ -294241,10 +294639,21 @@ const SpriteTaskHoldReactorLive = effect(SpriteTaskHoldReactor, gen(function* ()
 		launchCallers.delete(threadId);
 		await manager.release(launchHoldId(threadId));
 	});
+	/** Takes a turn-start hold. Registered with no thread id: see the shape's doc comment. */
+	const holdTurnStart = (key) => promise(async () => {
+		if (manager === null) return;
+		await manager.acquire(turnStartHoldId(key), null, { maxRefreshes: TURN_START_HOLD_MAX_REFRESHES });
+	});
+	const releaseTurnStart = (key) => promise(async () => {
+		if (manager === null) return;
+		await manager.release(turnStartHoldId(key));
+	});
 	return {
 		start,
 		holdLaunch,
 		releaseLaunch,
+		holdTurnStart,
+		releaseTurnStart,
 		releaseAll: onManager((taskHolds) => taskHolds.releaseAll())
 	};
 }));
@@ -298359,7 +298768,7 @@ function resolveBuildCommitFromEnv(env) {
 * environment descriptor down instead of reporting an honest "unknown".
 */
 function readBakedBuildCommit() {
-	return "8a3582256f668ba9a5af98e78fd83977c7fd34c9";
+	return "61b334c338ab47d92fe5f27155bf40ab9c7e3fed";
 }
 async function resolveServerBuildCommit(input) {
 	if (isFullCommitSha(input.baked)) return input.baked;
@@ -321976,13 +322385,13 @@ const gitUrlCloneRouteLayer = add$1("POST", "/api/cloud/git/clone-url", gen(func
 //#endregion
 //#region src/server.ts
 const PtyAdapterLive = unwrap(gen(function* () {
-	if (typeof Bun !== "undefined") return (yield* promise(() => import("./BunPTY-Csgwhbi5.mjs"))).layer;
-	else return (yield* promise(() => import("./NodePTY-DgXWLtWp.mjs"))).layer;
+	if (typeof Bun !== "undefined") return (yield* promise(() => import("./BunPTY-DsRB6_t-.mjs"))).layer;
+	else return (yield* promise(() => import("./NodePTY-Dduv48Vi.mjs"))).layer;
 }));
 const HttpServerLive = unwrap(gen(function* () {
 	const config = yield* ServerConfig;
-	if (typeof Bun !== "undefined") return (yield* promise(() => import("./BunHttpServer-DjilmGOM.mjs"))).layer(bunHttpServerOptions(config));
-	const [NodeHttpServer, NodeHttp] = yield* all([promise(() => import("./NodeHttpServer-Ds3Gp1Gp.mjs")), promise(() => import("node:http"))]);
+	if (typeof Bun !== "undefined") return (yield* promise(() => import("./BunHttpServer-BpaVqxli.mjs"))).layer(bunHttpServerOptions(config));
+	const [NodeHttpServer, NodeHttp] = yield* all([promise(() => import("./NodeHttpServer-DePOzmYy.mjs")), promise(() => import("node:http"))]);
 	return NodeHttpServer.layer(NodeHttp.createServer, {
 		host: config.host,
 		port: config.port
@@ -321990,10 +322399,10 @@ const HttpServerLive = unwrap(gen(function* () {
 }));
 const PlatformServicesLive = unwrap(gen(function* () {
 	if (typeof Bun !== "undefined") {
-		const { layer } = yield* promise(() => import("./BunServices-BZKzHdrG.mjs"));
+		const { layer } = yield* promise(() => import("./BunServices-ZpOiNNsP.mjs"));
 		return layer;
 	} else {
-		const { layer } = yield* promise(() => import("./NodeServices-D3IxOzHl.mjs").then((n) => n.t));
+		const { layer } = yield* promise(() => import("./NodeServices-Bt1GwPBR.mjs").then((n) => n.t));
 		return layer;
 	}
 }));