chatroom-cli 1.55.5 → 1.55.6

package/dist/index.js

@@ -16656,13 +16656,15 @@ var init_fiberRefs = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/esm/FiberRefs.js
-var get9, getOrDefault2, joinAs2, setAll2, updateManyAs2, empty20;
+var delete_2, get9, getOrDefault2, joinAs2, setAll2, updateAs2, updateManyAs2, empty20;
 var init_FiberRefs = __esm(() => {
   init_fiberRefs();
+  delete_2 = delete_;
   get9 = get8;
   getOrDefault2 = getOrDefault;
   joinAs2 = joinAs;
   setAll2 = setAll;
+  updateAs2 = updateAs;
   updateManyAs2 = updateManyAs;
   empty20 = empty19;
 });
@@ -21657,12 +21659,13 @@ var init_ScheduleDecision = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/esm/Scope.js
-var Scope, close, fork2;
+var Scope, close, extend2, fork2;
 var init_Scope = __esm(() => {
   init_core();
   init_fiberRuntime();
   Scope = scopeTag;
   close = scopeClose;
+  extend2 = scopeExtend;
   fork2 = scopeFork;
 });
 
@@ -22156,13 +22159,13 @@ var makeDual = (f) => function() {
   const error = new AsyncFiberExceptionImpl(fiber);
   Error.stackTraceLimit = limit;
   return error;
-}, FiberFailureId, FiberFailureCauseId, FiberFailureImpl, fiberFailure = (cause2) => {
+}, isAsyncFiberException = (u) => isTagged(u, "AsyncFiberException") && ("fiber" in u), FiberFailureId, FiberFailureCauseId, FiberFailureImpl, fiberFailure = (cause2) => {
   const limit = Error.stackTraceLimit;
   Error.stackTraceLimit = 0;
   const error = new FiberFailureImpl(cause2);
   Error.stackTraceLimit = limit;
   return error;
-}, fastPath = (effect) => {
+}, isFiberFailure = (u) => hasProperty(u, FiberFailureId), fastPath = (effect) => {
   const op = effect;
   switch (op._op) {
     case "Failure":
@@ -22182,7 +22185,7 @@ var makeDual = (f) => function() {
       return exitFail(new NoSuchElementException);
     }
   }
-}, unsafeRunSyncExit, unsafeRunPromise, unsafeRunPromiseExit, make36 = (options) => new RuntimeImpl(options.context, options.runtimeFlags, options.fiberRefs), runtime2 = () => withFiberRuntime((state, status3) => succeed(new RuntimeImpl(state.getFiberRef(currentContext), status3.runtimeFlags, state.getFiberRefs()))), defaultRuntimeFlags, defaultRuntime, unsafeRunEffect, unsafeForkEffect, unsafeRunPromiseEffect, unsafeRunPromiseExitEffect, unsafeRunSyncEffect, unsafeRunSyncExitEffect, asyncEffect = (register) => suspend(() => {
+}, unsafeRunSyncExit, unsafeRunPromise, unsafeRunPromiseExit, make36 = (options) => new RuntimeImpl(options.context, options.runtimeFlags, options.fiberRefs), runtime2 = () => withFiberRuntime((state, status3) => succeed(new RuntimeImpl(state.getFiberRef(currentContext), status3.runtimeFlags, state.getFiberRefs()))), defaultRuntimeFlags, defaultRuntime, updateRuntimeFlags2, disableRuntimeFlag, enableRuntimeFlag, updateContext2, provideService2, updateFiberRefs2, setFiberRef, deleteFiberRef, unsafeRunEffect, unsafeForkEffect, unsafeRunPromiseEffect, unsafeRunPromiseExitEffect, unsafeRunSyncEffect, unsafeRunSyncExitEffect, asyncEffect = (register) => suspend(() => {
   let cleanup = undefined;
   return flatMap7(deferredMake(), (deferred) => flatMap7(runtime2(), (runtime3) => uninterruptibleMask((restore) => zipRight(fork(restore(matchCauseEffect(register((cb) => unsafeRunCallback(runtime3)(intoDeferred(cb, deferred))), {
     onFailure: (cause2) => deferredFailCause(deferred, cause2),
@@ -22203,6 +22206,7 @@ var init_runtime = __esm(() => {
   init_Inspectable();
   init_Option();
   init_Pipeable();
+  init_Predicate();
   init_Scheduler();
   init_Scope();
   init_cause();
@@ -22355,6 +22359,30 @@ var init_runtime = __esm(() => {
     runtimeFlags: defaultRuntimeFlags,
     fiberRefs: /* @__PURE__ */ empty20()
   });
+  updateRuntimeFlags2 = /* @__PURE__ */ dual(2, (self2, f) => make36({
+    context: self2.context,
+    runtimeFlags: f(self2.runtimeFlags),
+    fiberRefs: self2.fiberRefs
+  }));
+  disableRuntimeFlag = /* @__PURE__ */ dual(2, (self2, flag) => updateRuntimeFlags2(self2, disable2(flag)));
+  enableRuntimeFlag = /* @__PURE__ */ dual(2, (self2, flag) => updateRuntimeFlags2(self2, enable2(flag)));
+  updateContext2 = /* @__PURE__ */ dual(2, (self2, f) => make36({
+    context: f(self2.context),
+    runtimeFlags: self2.runtimeFlags,
+    fiberRefs: self2.fiberRefs
+  }));
+  provideService2 = /* @__PURE__ */ dual(3, (self2, tag, service) => updateContext2(self2, add4(tag, service)));
+  updateFiberRefs2 = /* @__PURE__ */ dual(2, (self2, f) => make36({
+    context: self2.context,
+    runtimeFlags: self2.runtimeFlags,
+    fiberRefs: f(self2.fiberRefs)
+  }));
+  setFiberRef = /* @__PURE__ */ dual(3, (self2, fiberRef, value) => updateFiberRefs2(self2, updateAs2({
+    fiberId: none4,
+    fiberRef,
+    value
+  })));
+  deleteFiberRef = /* @__PURE__ */ dual(2, (self2, fiberRef) => updateFiberRefs2(self2, delete_2(fiberRef)));
   unsafeRunEffect = /* @__PURE__ */ unsafeRunCallback(defaultRuntime);
   unsafeForkEffect = /* @__PURE__ */ unsafeFork2(defaultRuntime);
   unsafeRunPromiseEffect = /* @__PURE__ */ unsafeRunPromise(defaultRuntime);
@@ -23824,7 +23852,7 @@ var ScheduleSymbolKey = "effect/Schedule", ScheduleTypeId, isSchedule = (u) => h
   const end3 = endOfMinute(minute0);
   const interval = make33(start3, end3);
   return succeed([[end3, n + 1], n, continueWith2(interval)]);
-}), modifyDelay, modifyDelayEffect, onDecision, passthrough2 = (self2) => makeWithState(self2.initial, (now, input, state) => pipe(self2.step(now, input, state), map9(([state2, _, decision]) => [state2, input, decision]))), provideContext3, provideService2, recurUntil = (f) => untilInput(identity2(), f), recurUntilEffect = (f) => untilInputEffect(identity2(), f), recurUntilOption = (pf) => untilOutput(map14(identity2(), pf), isSome2), recurUpTo = (durationInput) => {
+}), modifyDelay, modifyDelayEffect, onDecision, passthrough2 = (self2) => makeWithState(self2.initial, (now, input, state) => pipe(self2.step(now, input, state), map9(([state2, _, decision]) => [state2, input, decision]))), provideContext3, provideService3, recurUntil = (f) => untilInput(identity2(), f), recurUntilEffect = (f) => untilInputEffect(identity2(), f), recurUntilOption = (pf) => untilOutput(map14(identity2(), pf), isSome2), recurUpTo = (durationInput) => {
   const duration2 = decode(durationInput);
   return whileOutput(elapsed, (elapsed) => lessThan2(elapsed, duration2));
 }, recurWhile = (f) => whileInput(identity2(), f), recurWhileEffect = (f) => whileInputEffect(identity2(), f), recurs = (n) => whileOutput(forever2, (out) => out < n), reduce10, reduceEffect2, repetitions = (self2) => reduce10(self2, 0, (n, _) => n + 1), resetAfter, resetWhen, run, runLoop = (self2, now, inputs, state, acc) => {
@@ -24160,7 +24188,7 @@ var init_schedule = __esm(() => {
   })));
   onDecision = /* @__PURE__ */ dual(2, (self2, f) => makeWithState(self2.initial, (now, input, state) => flatMap7(self2.step(now, input, state), ([state2, out, decision]) => as2(f(out, decision), [state2, out, decision]))));
   provideContext3 = /* @__PURE__ */ dual(2, (self2, context3) => makeWithState(self2.initial, (now, input, state) => provideContext(self2.step(now, input, state), context3)));
-  provideService2 = /* @__PURE__ */ dual(3, (self2, tag, service2) => makeWithState(self2.initial, (now, input, state) => contextWithEffect((env) => provideContext(self2.step(now, input, state), add4(env, tag, service2)))));
+  provideService3 = /* @__PURE__ */ dual(3, (self2, tag, service2) => makeWithState(self2.initial, (now, input, state) => contextWithEffect((env) => provideContext(self2.step(now, input, state), add4(env, tag, service2)))));
   reduce10 = /* @__PURE__ */ dual(3, (self2, zero2, f) => reduceEffect2(self2, zero2, (z, out) => sync(() => f(z, out))));
   reduceEffect2 = /* @__PURE__ */ dual(3, (self2, zero2, f) => makeWithState([self2.initial, zero2], (now, input, [s, z]) => flatMap7(self2.step(now, input, s), ([s2, out, decision]) => isDone4(decision) ? succeed([[s2, z], z, decision]) : map9(f(z, out), (z2) => [[s2, z2], z, decision]))));
   resetAfter = /* @__PURE__ */ dual(2, (self2, durationInput) => {
@@ -25051,7 +25079,7 @@ __export(exports_Effect, {
   using: () => using2,
   useSpan: () => useSpan2,
   updateService: () => updateService2,
-  updateFiberRefs: () => updateFiberRefs2,
+  updateFiberRefs: () => updateFiberRefs3,
   unsandbox: () => unsandbox2,
   unsafeMakeSemaphore: () => unsafeMakeSemaphore2,
   unsafeMakeLatch: () => unsafeMakeLatch2,
@@ -25140,7 +25168,7 @@ __export(exports_Effect, {
   raceAll: () => raceAll2,
   race: () => race2,
   provideServiceEffect: () => provideServiceEffect2,
-  provideService: () => provideService3,
+  provideService: () => provideService4,
   provide: () => provide2,
   promise: () => promise2,
   patchRuntimeFlags: () => patchRuntimeFlags,
@@ -25391,7 +25419,7 @@ ${endStackCall}`;
   };
   return withSpan3(effect, options.spanName, opts);
 }
-var EffectTypeId3, isEffect2, cachedWithTTL, cachedInvalidateWithTTL2, cached3, cachedFunction2, once3, all6, allWith2, allSuccesses2, dropUntil2, dropWhile2, takeUntil2, takeWhile2, every5, exists2, filter7, filterMap4, findFirst4, forEach5, head4, mergeAll5, partition4, reduce11, reduceWhile2, reduceRight3, reduceEffect3, replicate2, replicateEffect2, validateAll2, validateFirst2, async, asyncEffect2, custom2, withFiberRuntime2, fail9, failSync3, failCause8, failCauseSync3, die5, dieMessage2, dieSync3, gen2, never4, none9, promise2, succeed9, succeedNone2, succeedSome2, suspend3, sync4, _void, yieldNow4, _catch2, catchAll3, catchAllCause3, catchAllDefect2, catchIf2, catchSome2, catchSomeCause2, catchSomeDefect2, catchTag2, catchTags2, cause2, eventually2, ignore2, ignoreLogged2, parallelErrors2, sandbox2, retry2, withExecutionPlan2, retryOrElse, try_2, tryMap2, tryMapPromise2, tryPromise2, unsandbox2, allowInterrupt2, checkInterruptible2, disconnect2, interrupt7, interruptWith2, interruptible4, interruptibleMask2, onInterrupt2, uninterruptible2, uninterruptibleMask3, liftPredicate2, as5, asSome2, asSomeError2, asVoid3, flip2, flipWith2, map15, mapAccum3, mapBoth3, mapError3, mapErrorCause2, merge7, negate2, acquireRelease2, acquireReleaseInterruptible2, acquireUseRelease2, addFinalizer2, ensuring3, onError2, onExit3, parallelFinalizers2, sequentialFinalizers2, finalizersMask2, scope3, scopeWith2, scopedWith2, scoped3, using2, withEarlyRelease2, awaitAllChildren2, daemonChildren2, descriptor2, descriptorWith2, diffFiberRefs2, ensuringChild2, ensuringChildren2, fiberId2, fiberIdWith2, fork3, forkDaemon2, forkAll2, forkIn2, forkScoped2, forkWithErrorHandler2, fromFiber2, fromFiberEffect2, supervised2, transplant2, withConcurrency2, withScheduler2, withSchedulingPriority2, withMaxOpsBeforeYield2, clock2, clockWith4, withClockScoped2, withClock2, console3, consoleWith2, withConsoleScoped2, withConsole2, delay2, sleep4, timed2, timedWith2, timeout2, timeoutOption2, timeoutFail2, timeoutFailCause2, timeoutTo2, configProviderWith2, withConfigProvider2, withConfigProviderScoped2, context3, contextWith2, contextWithEffect2, mapInputContext3, provide2, provideService3, provideServiceEffect2, serviceFunction2, serviceFunctionEffect2, serviceFunctions2, serviceConstants2, serviceMembers2, serviceOption2, serviceOptional2, updateService2, Do2, bind3, bindAll2, bindTo3, let_3, option2, either4, exit2, intoDeferred2, if_2, filterOrDie2, filterOrDieMessage2, filterOrElse2, filterOrFail2, filterEffectOrElse2, filterEffectOrFail2, unless2, unlessEffect2, when2, whenEffect2, whenFiberRef2, whenRef2, flatMap11, andThen6, flatten8, race2, raceAll2, raceFirst2, raceWith2, summarized2, tap3, tapBoth2, tapDefect2, tapError3, tapErrorTag2, tapErrorCause3, forever3, iterate2, loop2, repeat, repeatN2, repeatOrElse, schedule, scheduleForked2, scheduleFrom, whileLoop2, getFiberRefs, inheritFiberRefs2, locally, locallyWith, locallyScoped, locallyScopedWith, patchFiberRefs2, setFiberRefs2, updateFiberRefs2, isFailure4, isSuccess3, match15, matchCause3, matchCauseEffect3, matchEffect2, log3, logWithLevel2 = (level, ...message) => logWithLevel(level)(...message), logTrace2, logDebug2, logInfo2, logWarning2, logError2, logFatal2, withLogSpan2, annotateLogs3, annotateLogsScoped2, logAnnotations2, withUnhandledErrorLogLevel2, whenLogLevel2, orDie3, orDieWith2, orElse5, orElseFail2, orElseSucceed2, firstSuccessOf2, random3, randomWith2, withRandom2, withRandomFixed, withRandomScoped2, runtime3, getRuntimeFlags, patchRuntimeFlags, withRuntimeFlagsPatch, withRuntimeFlagsPatchScoped, tagMetrics2, labelMetrics2, tagMetricsScoped2, labelMetricsScoped2, metricLabels2, withMetric2, unsafeMakeSemaphore2, makeSemaphore2, unsafeMakeLatch2, makeLatch2, runFork2, runCallback, runPromise, runPromiseExit, runSync, runSyncExit, validate2, validateWith2, zip5, zipLeft4, zipRight4, zipWith7, ap, blocked2, runRequestBlock2, step3, request, cacheRequestResult, withRequestBatching2, withRequestCaching2, withRequestCache2, tracer2, tracerWith4, withTracer2, withTracerScoped2, withTracerEnabled2, withTracerTiming2, annotateSpans3, annotateCurrentSpan2, currentSpan2, currentPropagatedSpan2, currentParentSpan2, spanAnnotations2, spanLinks2, linkSpans2, linkSpanCurrent2, makeSpan2, makeSpanScoped2, useSpan2, withSpan3, functionWithSpan2, withSpanScoped2, withParentSpan3, fromNullable3, optionFromOptional2, transposeOption = (self2) => {
+var EffectTypeId3, isEffect2, cachedWithTTL, cachedInvalidateWithTTL2, cached3, cachedFunction2, once3, all6, allWith2, allSuccesses2, dropUntil2, dropWhile2, takeUntil2, takeWhile2, every5, exists2, filter7, filterMap4, findFirst4, forEach5, head4, mergeAll5, partition4, reduce11, reduceWhile2, reduceRight3, reduceEffect3, replicate2, replicateEffect2, validateAll2, validateFirst2, async, asyncEffect2, custom2, withFiberRuntime2, fail9, failSync3, failCause8, failCauseSync3, die5, dieMessage2, dieSync3, gen2, never4, none9, promise2, succeed9, succeedNone2, succeedSome2, suspend3, sync4, _void, yieldNow4, _catch2, catchAll3, catchAllCause3, catchAllDefect2, catchIf2, catchSome2, catchSomeCause2, catchSomeDefect2, catchTag2, catchTags2, cause2, eventually2, ignore2, ignoreLogged2, parallelErrors2, sandbox2, retry2, withExecutionPlan2, retryOrElse, try_2, tryMap2, tryMapPromise2, tryPromise2, unsandbox2, allowInterrupt2, checkInterruptible2, disconnect2, interrupt7, interruptWith2, interruptible4, interruptibleMask2, onInterrupt2, uninterruptible2, uninterruptibleMask3, liftPredicate2, as5, asSome2, asSomeError2, asVoid3, flip2, flipWith2, map15, mapAccum3, mapBoth3, mapError3, mapErrorCause2, merge7, negate2, acquireRelease2, acquireReleaseInterruptible2, acquireUseRelease2, addFinalizer2, ensuring3, onError2, onExit3, parallelFinalizers2, sequentialFinalizers2, finalizersMask2, scope3, scopeWith2, scopedWith2, scoped3, using2, withEarlyRelease2, awaitAllChildren2, daemonChildren2, descriptor2, descriptorWith2, diffFiberRefs2, ensuringChild2, ensuringChildren2, fiberId2, fiberIdWith2, fork3, forkDaemon2, forkAll2, forkIn2, forkScoped2, forkWithErrorHandler2, fromFiber2, fromFiberEffect2, supervised2, transplant2, withConcurrency2, withScheduler2, withSchedulingPriority2, withMaxOpsBeforeYield2, clock2, clockWith4, withClockScoped2, withClock2, console3, consoleWith2, withConsoleScoped2, withConsole2, delay2, sleep4, timed2, timedWith2, timeout2, timeoutOption2, timeoutFail2, timeoutFailCause2, timeoutTo2, configProviderWith2, withConfigProvider2, withConfigProviderScoped2, context3, contextWith2, contextWithEffect2, mapInputContext3, provide2, provideService4, provideServiceEffect2, serviceFunction2, serviceFunctionEffect2, serviceFunctions2, serviceConstants2, serviceMembers2, serviceOption2, serviceOptional2, updateService2, Do2, bind3, bindAll2, bindTo3, let_3, option2, either4, exit2, intoDeferred2, if_2, filterOrDie2, filterOrDieMessage2, filterOrElse2, filterOrFail2, filterEffectOrElse2, filterEffectOrFail2, unless2, unlessEffect2, when2, whenEffect2, whenFiberRef2, whenRef2, flatMap11, andThen6, flatten8, race2, raceAll2, raceFirst2, raceWith2, summarized2, tap3, tapBoth2, tapDefect2, tapError3, tapErrorTag2, tapErrorCause3, forever3, iterate2, loop2, repeat, repeatN2, repeatOrElse, schedule, scheduleForked2, scheduleFrom, whileLoop2, getFiberRefs, inheritFiberRefs2, locally, locallyWith, locallyScoped, locallyScopedWith, patchFiberRefs2, setFiberRefs2, updateFiberRefs3, isFailure4, isSuccess3, match15, matchCause3, matchCauseEffect3, matchEffect2, log3, logWithLevel2 = (level, ...message) => logWithLevel(level)(...message), logTrace2, logDebug2, logInfo2, logWarning2, logError2, logFatal2, withLogSpan2, annotateLogs3, annotateLogsScoped2, logAnnotations2, withUnhandledErrorLogLevel2, whenLogLevel2, orDie3, orDieWith2, orElse5, orElseFail2, orElseSucceed2, firstSuccessOf2, random3, randomWith2, withRandom2, withRandomFixed, withRandomScoped2, runtime3, getRuntimeFlags, patchRuntimeFlags, withRuntimeFlagsPatch, withRuntimeFlagsPatchScoped, tagMetrics2, labelMetrics2, tagMetricsScoped2, labelMetricsScoped2, metricLabels2, withMetric2, unsafeMakeSemaphore2, makeSemaphore2, unsafeMakeLatch2, makeLatch2, runFork2, runCallback, runPromise, runPromiseExit, runSync, runSyncExit, validate2, validateWith2, zip5, zipLeft4, zipRight4, zipWith7, ap, blocked2, runRequestBlock2, step3, request, cacheRequestResult, withRequestBatching2, withRequestCaching2, withRequestCache2, tracer2, tracerWith4, withTracer2, withTracerScoped2, withTracerEnabled2, withTracerTiming2, annotateSpans3, annotateCurrentSpan2, currentSpan2, currentPropagatedSpan2, currentParentSpan2, spanAnnotations2, spanLinks2, linkSpans2, linkSpanCurrent2, makeSpan2, makeSpanScoped2, useSpan2, withSpan3, functionWithSpan2, withSpanScoped2, withParentSpan3, fromNullable3, optionFromOptional2, transposeOption = (self2) => {
   return isNone(self2) ? succeedNone2 : map15(self2.value, some);
 }, transposeMapOption, makeTagProxy = (TagClass) => {
   const cache = new Map;
@@ -25777,7 +25805,7 @@ var init_Effect = __esm(() => {
   contextWithEffect2 = contextWithEffect;
   mapInputContext3 = mapInputContext;
   provide2 = effect_provide;
-  provideService3 = provideService;
+  provideService4 = provideService;
   provideServiceEffect2 = provideServiceEffect;
   serviceFunction2 = serviceFunction;
   serviceFunctionEffect2 = serviceFunctionEffect;
@@ -25841,7 +25869,7 @@ var init_Effect = __esm(() => {
   locallyScopedWith = fiberRefLocallyScopedWith;
   patchFiberRefs2 = patchFiberRefs;
   setFiberRefs2 = setFiberRefs;
-  updateFiberRefs2 = updateFiberRefs;
+  updateFiberRefs3 = updateFiberRefs;
   isFailure4 = isFailure3;
   isSuccess3 = isSuccess;
   match15 = match9;
@@ -26133,6 +26161,160 @@ var init_Layer = __esm(() => {
   updateService3 = /* @__PURE__ */ dual(3, (layer, tag, f) => provide3(layer, map16(context4(), (c) => add4(c, tag, f(unsafeGet4(c, tag))))));
 });
 
+// ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/esm/internal/managedRuntime.js
+function provide4(managed, effect2) {
+  return flatMap7(managed.runtimeEffect, (rt) => withFiberRuntime((fiber) => {
+    fiber.setFiberRefs(rt.fiberRefs);
+    fiber.currentRuntimeFlags = rt.runtimeFlags;
+    return provideContext(effect2, rt.context);
+  }));
+}
+var isManagedRuntime = (u) => hasProperty(u, TypeId12), ManagedRuntimeProto, make39 = (layer, memoMap) => {
+  memoMap = memoMap ?? unsafeMakeMemoMap();
+  const scope5 = unsafeRunSyncEffect(scopeMake());
+  let buildFiber;
+  const runtimeEffect = suspend(() => {
+    if (!buildFiber) {
+      const scheduler = new SyncScheduler;
+      buildFiber = unsafeForkEffect(tap(extend2(toRuntimeWithMemoMap(layer, memoMap), scope5), (rt) => {
+        self2.cachedRuntime = rt;
+      }), {
+        scope: scope5,
+        scheduler
+      });
+      scheduler.flush();
+    }
+    return flatten4(buildFiber.await);
+  });
+  const self2 = Object.assign(Object.create(ManagedRuntimeProto), {
+    memoMap,
+    scope: scope5,
+    runtimeEffect,
+    cachedRuntime: undefined,
+    runtime() {
+      return self2.cachedRuntime === undefined ? unsafeRunPromiseEffect(self2.runtimeEffect) : Promise.resolve(self2.cachedRuntime);
+    },
+    dispose() {
+      return unsafeRunPromiseEffect(self2.disposeEffect);
+    },
+    disposeEffect: suspend(() => {
+      self2.runtimeEffect = die2("ManagedRuntime disposed");
+      self2.cachedRuntime = undefined;
+      return close(self2.scope, exitVoid);
+    }),
+    runFork(effect2, options) {
+      return self2.cachedRuntime === undefined ? unsafeForkEffect(provide4(self2, effect2), options) : unsafeFork2(self2.cachedRuntime)(effect2, options);
+    },
+    runSyncExit(effect2) {
+      return self2.cachedRuntime === undefined ? unsafeRunSyncExitEffect(provide4(self2, effect2)) : unsafeRunSyncExit(self2.cachedRuntime)(effect2);
+    },
+    runSync(effect2) {
+      return self2.cachedRuntime === undefined ? unsafeRunSyncEffect(provide4(self2, effect2)) : unsafeRunSync(self2.cachedRuntime)(effect2);
+    },
+    runPromiseExit(effect2, options) {
+      return self2.cachedRuntime === undefined ? unsafeRunPromiseExitEffect(provide4(self2, effect2), options) : unsafeRunPromiseExit(self2.cachedRuntime)(effect2, options);
+    },
+    runCallback(effect2, options) {
+      return self2.cachedRuntime === undefined ? unsafeRunCallback(defaultRuntime)(provide4(self2, effect2), options) : unsafeRunCallback(self2.cachedRuntime)(effect2, options);
+    },
+    runPromise(effect2, options) {
+      return self2.cachedRuntime === undefined ? unsafeRunPromiseEffect(provide4(self2, effect2), options) : unsafeRunPromise(self2.cachedRuntime)(effect2, options);
+    }
+  });
+  return self2;
+};
+var init_managedRuntime = __esm(() => {
+  init_Effectable();
+  init_Pipeable();
+  init_Predicate();
+  init_Scheduler();
+  init_Scope();
+  init_core();
+  init_fiberRuntime();
+  init_layer();
+  init_circular2();
+  init_runtime();
+  ManagedRuntimeProto = {
+    ...CommitPrototype2,
+    [TypeId12]: TypeId12,
+    pipe() {
+      return pipeArguments(this, arguments);
+    },
+    commit() {
+      return this.runtimeEffect;
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/esm/ManagedRuntime.js
+var exports_ManagedRuntime = {};
+__export(exports_ManagedRuntime, {
+  make: () => make40,
+  isManagedRuntime: () => isManagedRuntime2,
+  TypeId: () => TypeId17
+});
+var TypeId17, isManagedRuntime2, make40;
+var init_ManagedRuntime = __esm(() => {
+  init_managedRuntime();
+  init_circular2();
+  TypeId17 = TypeId12;
+  isManagedRuntime2 = isManagedRuntime;
+  make40 = make39;
+});
+
+// ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/esm/Runtime.js
+var exports_Runtime = {};
+__export(exports_Runtime, {
+  updateRuntimeFlags: () => updateRuntimeFlags3,
+  updateFiberRefs: () => updateFiberRefs4,
+  updateContext: () => updateContext3,
+  setFiberRef: () => setFiberRef2,
+  runSyncExit: () => runSyncExit2,
+  runSync: () => runSync2,
+  runPromiseExit: () => runPromiseExit2,
+  runPromise: () => runPromise2,
+  runFork: () => runFork3,
+  runCallback: () => runCallback2,
+  provideService: () => provideService5,
+  makeFiberFailure: () => makeFiberFailure,
+  make: () => make41,
+  isFiberFailure: () => isFiberFailure2,
+  isAsyncFiberException: () => isAsyncFiberException2,
+  enableRuntimeFlag: () => enableRuntimeFlag2,
+  disableRuntimeFlag: () => disableRuntimeFlag2,
+  deleteFiberRef: () => deleteFiberRef2,
+  defaultRuntimeFlags: () => defaultRuntimeFlags2,
+  defaultRuntime: () => defaultRuntime2,
+  FiberFailureId: () => FiberFailureId2,
+  FiberFailureCauseId: () => FiberFailureCauseId2
+});
+var runFork3, runSyncExit2, runSync2, runCallback2, runPromise2, runPromiseExit2, defaultRuntime2, defaultRuntimeFlags2, make41, FiberFailureId2, FiberFailureCauseId2, isAsyncFiberException2, isFiberFailure2, makeFiberFailure, updateRuntimeFlags3, enableRuntimeFlag2, disableRuntimeFlag2, updateContext3, provideService5, updateFiberRefs4, setFiberRef2, deleteFiberRef2;
+var init_Runtime = __esm(() => {
+  init_runtime();
+  runFork3 = unsafeFork2;
+  runSyncExit2 = unsafeRunSyncExit;
+  runSync2 = unsafeRunSync;
+  runCallback2 = unsafeRunCallback;
+  runPromise2 = unsafeRunPromise;
+  runPromiseExit2 = unsafeRunPromiseExit;
+  defaultRuntime2 = defaultRuntime;
+  defaultRuntimeFlags2 = defaultRuntimeFlags;
+  make41 = make36;
+  FiberFailureId2 = /* @__PURE__ */ Symbol.for("effect/Runtime/FiberFailure");
+  FiberFailureCauseId2 = FiberFailureCauseId;
+  isAsyncFiberException2 = isAsyncFiberException;
+  isFiberFailure2 = isFiberFailure;
+  makeFiberFailure = fiberFailure;
+  updateRuntimeFlags3 = updateRuntimeFlags2;
+  enableRuntimeFlag2 = enableRuntimeFlag;
+  disableRuntimeFlag2 = disableRuntimeFlag;
+  updateContext3 = updateContext2;
+  provideService5 = provideService2;
+  updateFiberRefs4 = updateFiberRefs2;
+  setFiberRef2 = setFiberRef;
+  deleteFiberRef2 = deleteFiberRef;
+});
+
 // ../../node_modules/.pnpm/effect@3.21.2/node_modules/effect/dist/esm/Schedule.js
 var exports_Schedule = {};
 __export(exports_Schedule, {
@@ -26173,7 +26355,7 @@ __export(exports_Schedule, {
   recurUntilOption: () => recurUntilOption2,
   recurUntilEffect: () => recurUntilEffect2,
   recurUntil: () => recurUntil2,
-  provideService: () => provideService4,
+  provideService: () => provideService6,
   provideContext: () => provideContext4,
   passthrough: () => passthrough4,
   once: () => once4,
@@ -26238,7 +26420,7 @@ __export(exports_Schedule, {
   ScheduleDriverTypeId: () => ScheduleDriverTypeId2,
   CurrentIterationMetadata: () => CurrentIterationMetadata2
 });
-var ScheduleTypeId2, ScheduleDriverTypeId2, makeWithState2, isSchedule2, addDelay2, addDelayEffect2, andThen7, andThenEither2, as6, asVoid4, bothInOut2, check2, checkEffect2, collectAllInputs2, collectAllOutputs2, collectUntil2, collectUntilEffect2, collectWhile2, collectWhileEffect2, compose2, mapInput4, mapInputEffect2, mapInputContext4, count2, cron2, secondOfMinute2, minuteOfHour2, hourOfDay2, dayOfMonth2, dayOfWeek2, delayed2, delayedEffect2, delayedSchedule2, delays2, mapBoth4, mapBothEffect2, driver2, duration2, either5, eitherWith2, elapsed2, ensuring4, exponential3, fibonacci2, fixed4, forever4, fromDelay2, fromDelays2, fromFunction4, identity3, passthrough4, intersect6, intersectWith2, jittered2, jitteredWith2, linear2, map17, mapEffect4, modifyDelay2, modifyDelayEffect2, onDecision2, once4, provideContext4, provideService4, recurUntil2, recurUntilEffect2, recurUntilOption2, recurUpTo2, recurWhile2, recurWhileEffect2, recurs2, reduce12, reduceEffect4, repeatForever, repetitions2, resetAfter2, resetWhen2, run2, spaced2, stop2, succeed11, sync6, tapInput2, tapOutput2, unfold3, union9, unionWith3, untilInput2, untilInputEffect2, untilOutput2, untilOutputEffect2, upTo2, whileInput2, whileInputEffect2, whileOutput2, whileOutputEffect2, windowed2, zipLeft5, zipRight5, zipWith9, CurrentIterationMetadata2;
+var ScheduleTypeId2, ScheduleDriverTypeId2, makeWithState2, isSchedule2, addDelay2, addDelayEffect2, andThen7, andThenEither2, as6, asVoid4, bothInOut2, check2, checkEffect2, collectAllInputs2, collectAllOutputs2, collectUntil2, collectUntilEffect2, collectWhile2, collectWhileEffect2, compose2, mapInput4, mapInputEffect2, mapInputContext4, count2, cron2, secondOfMinute2, minuteOfHour2, hourOfDay2, dayOfMonth2, dayOfWeek2, delayed2, delayedEffect2, delayedSchedule2, delays2, mapBoth4, mapBothEffect2, driver2, duration2, either5, eitherWith2, elapsed2, ensuring4, exponential3, fibonacci2, fixed4, forever4, fromDelay2, fromDelays2, fromFunction4, identity3, passthrough4, intersect6, intersectWith2, jittered2, jitteredWith2, linear2, map17, mapEffect4, modifyDelay2, modifyDelayEffect2, onDecision2, once4, provideContext4, provideService6, recurUntil2, recurUntilEffect2, recurUntilOption2, recurUpTo2, recurWhile2, recurWhileEffect2, recurs2, reduce12, reduceEffect4, repeatForever, repetitions2, resetAfter2, resetWhen2, run2, spaced2, stop2, succeed11, sync6, tapInput2, tapOutput2, unfold3, union9, unionWith3, untilInput2, untilInputEffect2, untilOutput2, untilOutputEffect2, upTo2, whileInput2, whileInputEffect2, whileOutput2, whileOutputEffect2, windowed2, zipLeft5, zipRight5, zipWith9, CurrentIterationMetadata2;
 var init_Schedule = __esm(() => {
   init_schedule();
   ScheduleTypeId2 = ScheduleTypeId;
@@ -26304,7 +26486,7 @@ var init_Schedule = __esm(() => {
   onDecision2 = onDecision;
   once4 = once2;
   provideContext4 = provideContext3;
-  provideService4 = provideService2;
+  provideService6 = provideService3;
   recurUntil2 = recurUntil;
   recurUntilEffect2 = recurUntilEffect;
   recurUntilOption2 = recurUntilOption;
@@ -26352,7 +26534,9 @@ var init_esm = __esm(() => {
   init_Effect();
   init_Fiber();
   init_Layer();
+  init_ManagedRuntime();
   init_Ref();
+  init_Runtime();
   init_Schedule();
 });
 
@@ -27281,21 +27465,30 @@ var init_pi_agent_service = __esm(() => {
     async resumeFromDaemonMemory(options, stored) {
       const { prompt, systemPrompt, model, context: context5 } = options;
       const modelForSession = model ?? stored.model;
-      const childProcess = this.spawnPiRpcProcess({
-        workingDir: stored.workingDir,
-        systemPrompt,
-        model: modelForSession,
-        sessionId: stored.harnessSessionId
-      });
-      await this.waitForSpawnReady(childProcess);
-      await this.writePrompt(childProcess, prompt);
-      return this.wireRpcProcess({
-        childProcess,
-        context: context5,
-        workingDir: stored.workingDir,
-        model: modelForSession,
-        harnessSessionId: stored.harnessSessionId
-      });
+      let childProcess;
+      try {
+        childProcess = this.spawnPiRpcProcess({
+          workingDir: stored.workingDir,
+          systemPrompt,
+          model: modelForSession,
+          sessionId: stored.harnessSessionId
+        });
+        await this.waitForSpawnReady(childProcess);
+        await this.writePrompt(childProcess, prompt);
+        return this.wireRpcProcess({
+          childProcess,
+          context: context5,
+          workingDir: stored.workingDir,
+          model: modelForSession,
+          harnessSessionId: stored.harnessSessionId
+        });
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[${new Date().toISOString()}] role:${context5.role} daemon-resume-fallback] ${reason} — cold spawning
+`);
+        childProcess?.kill();
+        return this.spawn(options);
+      }
     }
     async resumeTurn(pid, prompt) {
       const child = this.childProcesses.get(pid);
@@ -28901,9 +29094,12 @@ ${options.prompt}`;
           local: { cwd: stored.workingDir, settingSources: [] }
         }), AGENT_CREATE_TIMEOUT_MS, "Agent.resume");
       } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[${new Date().toISOString()}] role:${context5.role} daemon-resume-fallback] ${reason} — cold spawning
+`);
         keeper.kill();
         this.deleteProcess(pid);
-        throw err;
+        return this.spawn(options);
       }
       return this.startRunningSession({
         pid,
@@ -31184,13 +31380,23 @@ function writeLogLine(target, options, kind, payload) {
 `);
   options.onLogLine?.(line);
 }
-function isUsageLimitError(error) {
-  if (!error || typeof error !== "object")
+function isTerminalProviderError(error) {
+  if (!error || typeof error !== "object") {
+    if (typeof error === "string") {
+      return matchesTerminalProviderErrorText(error);
+    }
     return false;
+  }
   const e = error;
   const name = String(e.name ?? e.type ?? "").toLowerCase();
-  const message = String(e.data?.message ?? e.message ?? "").toLowerCase();
-  return name.includes("usagelimit") || message.includes("usage limit") || message.includes("enable usage from your available balance");
+  const message = String(e.data?.message ?? e.message ?? e.responseBody ?? "").toLowerCase();
+  const blob = `${name}
+${message}`;
+  return matchesTerminalProviderErrorText(blob);
+}
+function matchesTerminalProviderErrorText(blob) {
+  const text = blob.toLowerCase();
+  return text.includes("usagelimit") || text.includes("usage limit") || text.includes("enable usage from your available balance") || text.includes("rate limit") || text.includes("ratelimit") || text.includes("too many requests") || text.includes("x-ratelimit-exceeded") || text.includes("weekly rate limit") || text.includes("exceeded your weekly");
 }
 function eventSessionId(event) {
   const p = event.properties;
@@ -31325,8 +31531,8 @@ function startSessionEventForwarder(client4, options) {
               payload += ` [command: ${props.command}]`;
             }
             writeLogLine(errorTarget, options, "error", payload);
-            if (isUsageLimitError(err)) {
-              writeLogLine(target, options, "agent_end", "reason: usage_limit_reached");
+            if (isTerminalProviderError(err)) {
+              writeLogLine(target, options, "agent_end", "reason: provider_rate_limit");
               for (const cb of agentEndCallbacks)
                 cb();
             }
@@ -31339,6 +31545,11 @@ function startSessionEventForwarder(client4, options) {
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       writeLogLine(errorTarget, options, "error", message);
+      if (isTerminalProviderError(err)) {
+        writeLogLine(target, options, "agent_end", "reason: provider_rate_limit");
+        for (const cb of agentEndCallbacks)
+          cb();
+      }
     } finally {
       doneResolve();
     }
@@ -31424,6 +31635,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
   init_parse_listening_url();
   init_session_metadata_store();
   OpenCodeSdkAgentService = class OpenCodeSdkAgentService extends BaseCLIAgentService {
+    agentEndCallbacksByPid = new Map;
     id = "opencode-sdk";
     displayName = "OpenCode (SDK)";
     command = OPENCODE_COMMAND2;
@@ -31462,8 +31674,8 @@ var init_opencode_sdk_agent_service = __esm(() => {
           } catch (err) {
             console.warn(`[opencode-sdk] session.abort for pid=${pid} sessionId=${meta.sessionId} failed (continuing with SIGTERM):`, err instanceof Error ? err.message : err);
           }
+          this.sessionStore.remove(meta.sessionId);
         }
-        this.sessionStore.remove(meta.sessionId);
       }
       await super.stop(pid);
     }
@@ -31548,6 +31760,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
               this.forwarders.delete(pid);
             }
             this.sessionStore.remove(sessionId);
+            this.agentEndCallbacksByPid.delete(pid);
             this.deleteProcess(pid);
             cb({ code: code2, signal, context: context5 });
           });
@@ -31556,6 +31769,9 @@ var init_opencode_sdk_agent_service = __esm(() => {
           outputCallbacks.push(cb);
         },
         onAgentEnd: (cb) => {
+          const callbacks = this.agentEndCallbacksByPid.get(pid) ?? [];
+          callbacks.push(cb);
+          this.agentEndCallbacksByPid.set(pid, callbacks);
           forwarder?.onAgentEnd(cb);
         },
         onLogLine: (cb) => {
@@ -31573,6 +31789,54 @@ var init_opencode_sdk_agent_service = __esm(() => {
         }
       };
     }
+    async startFreshSessionOnServe(args2) {
+      const existingForwarder = this.forwarders.get(args2.pid);
+      existingForwarder?.stop();
+      this.forwarders.delete(args2.pid);
+      const client4 = createOpencodeClient({ baseUrl: args2.baseUrl });
+      const sessionCreateResult = await withTimeout2(client4.session.create({ body: {} }), SESSION_CREATE_TIMEOUT_MS, "session.create");
+      if (!sessionCreateResult.data?.id) {
+        throw new Error("Failed to create session during resume fallback");
+      }
+      const newSessionId2 = sessionCreateResult.data.id;
+      const forwarder = startSessionEventForwarder(client4, {
+        sessionId: newSessionId2,
+        role: args2.context.role
+      });
+      const callbacks = this.agentEndCallbacksByPid.get(args2.pid) ?? [];
+      for (const cb of callbacks) {
+        forwarder.onAgentEnd(cb);
+      }
+      this.forwarders.set(args2.pid, forwarder);
+      if (args2.oldSessionId) {
+        this.sessionStore.remove(args2.oldSessionId);
+      }
+      this.sessionStore.upsert({
+        sessionId: newSessionId2,
+        machineId: args2.context.machineId,
+        chatroomId: args2.context.chatroomId,
+        role: args2.context.role,
+        agentName: args2.agentName,
+        ...args2.model ? { model: args2.model } : {},
+        pid: args2.pid,
+        createdAt: new Date().toISOString(),
+        baseUrl: args2.baseUrl
+      });
+      const modelParts = args2.model ? parseModelId(args2.model) : undefined;
+      await withTimeout2(client4.session.promptAsync({
+        path: { id: newSessionId2 },
+        body: {
+          agent: args2.agentName,
+          parts: [{ type: "text", text: args2.prompt }],
+          ...modelParts ? { model: modelParts } : {},
+          tools: {
+            task: false,
+            question: false,
+            external_directory: false
+          }
+        }
+      }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
+    }
     async resumeFromDaemonMemory(options, session2) {
       const { prompt, systemPrompt, model, context: context5 } = options;
       const sessionId = session2.harnessSessionId;
@@ -31624,11 +31888,11 @@ var init_opencode_sdk_agent_service = __esm(() => {
         }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[${new Date().toISOString()}] role:${context5.role} resume-error] ${reason}
+        process.stderr.write(`[${new Date().toISOString()}] role:${context5.role} daemon-resume-fallback] ${reason} — cold spawning
 `);
         forwarder?.stop();
         childProcess.kill();
-        throw err;
+        return this.spawn(options);
       }
       return this.registerRunningSession({
         childProcess,
@@ -31733,23 +31997,45 @@ var init_opencode_sdk_agent_service = __esm(() => {
     async resumeTurn(pid, prompt) {
       const meta = this.sessionStore.findByPid(pid);
       if (!meta) {
-        throw new Error(`No opencode-sdk session metadata for pid=${pid}`);
+        process.stderr.write(`[${new Date().toISOString()}] opencode-sdk resumeTurn: no metadata for pid=${pid}, skipping
+`);
+        return;
       }
       const client4 = createOpencodeClient({ baseUrl: meta.baseUrl });
       const modelParts = meta.model ? parseModelId(meta.model) : undefined;
-      await withTimeout2(client4.session.promptAsync({
-        path: { id: meta.sessionId },
-        body: {
-          agent: meta.agentName,
-          parts: [{ type: "text", text: prompt }],
-          ...modelParts ? { model: modelParts } : {},
-          tools: {
-            task: false,
-            question: false,
-            external_directory: false
+      const context5 = {
+        machineId: meta.machineId,
+        chatroomId: meta.chatroomId,
+        role: meta.role
+      };
+      try {
+        await withTimeout2(client4.session.promptAsync({
+          path: { id: meta.sessionId },
+          body: {
+            agent: meta.agentName,
+            parts: [{ type: "text", text: prompt }],
+            ...modelParts ? { model: modelParts } : {},
+            tools: {
+              task: false,
+              question: false,
+              external_directory: false
+            }
           }
-        }
-      }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
+        }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[${new Date().toISOString()}] role:${meta.role} resume-fallback] ${reason} — starting fresh session
+`);
+        await this.startFreshSessionOnServe({
+          pid,
+          baseUrl: meta.baseUrl,
+          context: context5,
+          agentName: meta.agentName,
+          model: meta.model,
+          prompt,
+          oldSessionId: meta.sessionId
+        });
+      }
     }
   };
 });
@@ -41454,51 +41740,51 @@ var require_resize = __commonJS((exports, module) => {
     }
     return this;
   }
-  function extend2(extend3) {
-    if (is.integer(extend3) && extend3 > 0) {
-      this.options.extendTop = extend3;
-      this.options.extendBottom = extend3;
-      this.options.extendLeft = extend3;
-      this.options.extendRight = extend3;
-    } else if (is.object(extend3)) {
-      if (is.defined(extend3.top)) {
-        if (is.integer(extend3.top) && extend3.top >= 0) {
-          this.options.extendTop = extend3.top;
+  function extend3(extend4) {
+    if (is.integer(extend4) && extend4 > 0) {
+      this.options.extendTop = extend4;
+      this.options.extendBottom = extend4;
+      this.options.extendLeft = extend4;
+      this.options.extendRight = extend4;
+    } else if (is.object(extend4)) {
+      if (is.defined(extend4.top)) {
+        if (is.integer(extend4.top) && extend4.top >= 0) {
+          this.options.extendTop = extend4.top;
         } else {
-          throw is.invalidParameterError("top", "positive integer", extend3.top);
+          throw is.invalidParameterError("top", "positive integer", extend4.top);
         }
       }
-      if (is.defined(extend3.bottom)) {
-        if (is.integer(extend3.bottom) && extend3.bottom >= 0) {
-          this.options.extendBottom = extend3.bottom;
+      if (is.defined(extend4.bottom)) {
+        if (is.integer(extend4.bottom) && extend4.bottom >= 0) {
+          this.options.extendBottom = extend4.bottom;
         } else {
-          throw is.invalidParameterError("bottom", "positive integer", extend3.bottom);
+          throw is.invalidParameterError("bottom", "positive integer", extend4.bottom);
         }
       }
-      if (is.defined(extend3.left)) {
-        if (is.integer(extend3.left) && extend3.left >= 0) {
-          this.options.extendLeft = extend3.left;
+      if (is.defined(extend4.left)) {
+        if (is.integer(extend4.left) && extend4.left >= 0) {
+          this.options.extendLeft = extend4.left;
         } else {
-          throw is.invalidParameterError("left", "positive integer", extend3.left);
+          throw is.invalidParameterError("left", "positive integer", extend4.left);
         }
       }
-      if (is.defined(extend3.right)) {
-        if (is.integer(extend3.right) && extend3.right >= 0) {
-          this.options.extendRight = extend3.right;
+      if (is.defined(extend4.right)) {
+        if (is.integer(extend4.right) && extend4.right >= 0) {
+          this.options.extendRight = extend4.right;
         } else {
-          throw is.invalidParameterError("right", "positive integer", extend3.right);
+          throw is.invalidParameterError("right", "positive integer", extend4.right);
         }
       }
-      this._setBackgroundColourOption("extendBackground", extend3.background);
-      if (is.defined(extend3.extendWith)) {
-        if (is.string(extendWith[extend3.extendWith])) {
-          this.options.extendWith = extendWith[extend3.extendWith];
+      this._setBackgroundColourOption("extendBackground", extend4.background);
+      if (is.defined(extend4.extendWith)) {
+        if (is.string(extendWith[extend4.extendWith])) {
+          this.options.extendWith = extendWith[extend4.extendWith];
         } else {
-          throw is.invalidParameterError("extendWith", "one of: background, copy, repeat, mirror", extend3.extendWith);
+          throw is.invalidParameterError("extendWith", "one of: background, copy, repeat, mirror", extend4.extendWith);
         }
       }
     } else {
-      throw is.invalidParameterError("extend", "integer or object", extend3);
+      throw is.invalidParameterError("extend", "integer or object", extend4);
     }
     return this;
   }
@@ -41554,7 +41840,7 @@ var require_resize = __commonJS((exports, module) => {
   module.exports = (Sharp) => {
     Object.assign(Sharp.prototype, {
       resize,
-      extend: extend2,
+      extend: extend3,
       extract,
       trim
     });
@@ -53499,7 +53785,7 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
   return kind === "formdata" || kind === "object" && isFunction3(thing.toString) && thing.toString() === "[object FormData]";
 }, isURLSearchParams, isReadableStream, isRequest3, isResponse, isHeaders, trim = (str) => {
   return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
-}, _global, isContextDefined = (context5) => !isUndefined(context5) && context5 !== _global, extend2 = (a, b, thisArg, { allOwnKeys } = {}) => {
+}, _global, isContextDefined = (context5) => !isUndefined(context5) && context5 !== _global, extend3 = (a, b, thisArg, { allOwnKeys } = {}) => {
   forEach6(b, (val, key) => {
     if (thisArg && isFunction3(val)) {
       Object.defineProperty(a, key, {
@@ -53753,7 +54039,7 @@ var init_utils = __esm(() => {
     isFileList,
     forEach: forEach6,
     merge: merge9,
-    extend: extend2,
+    extend: extend3,
     trim,
     stripBOM,
     inherits,
@@ -65184,7 +65470,7 @@ var require_common = __commonJS((exports, module) => {
       debug.namespace = namespace;
       debug.useColors = createDebug.useColors();
       debug.color = createDebug.selectColor(namespace);
-      debug.extend = extend3;
+      debug.extend = extend4;
       debug.destroy = createDebug.destroy;
       Object.defineProperty(debug, "enabled", {
         enumerable: true,
@@ -65208,7 +65494,7 @@ var require_common = __commonJS((exports, module) => {
       }
       return debug;
     }
-    function extend3(namespace, delimiter) {
+    function extend4(namespace, delimiter) {
       const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
       newDebug.log = this.log;
       return newDebug;
@@ -82834,15 +83120,10 @@ var init_on_daemon_shutdown = __esm(() => {
     const activeAgents = agentPm.listActive();
     if (activeAgents.length > 0) {
       console.log(`[${formatTimestamp()}] Stopping ${activeAgents.length} agent(s)...`);
-      yield* exports_Effect.promise(() => Promise.allSettled(activeAgents.map(async ({ chatroomId, role, slot }) => {
+      yield* exports_Effect.all(activeAgents.map(({ chatroomId, role, slot }) => {
         const pid = slot.pid;
-        try {
-          await exports_Effect.runPromise(agentPm.stop({ chatroomId, role, reason: "daemon.shutdown" }));
-          console.log(`   Stopped ${role} (PID ${pid})`);
-        } catch (e) {
-          console.log(`   ⚠️  Failed to stop ${role}: ${e.message}`);
-        }
-      })));
+        return agentPm.stop({ chatroomId, role, reason: "daemon.shutdown" }).pipe(exports_Effect.tap(() => exports_Effect.sync(() => console.log(`   Stopped ${role} (PID ${pid})`))), exports_Effect.catchAll((e) => exports_Effect.sync(() => console.log(`   ⚠️  Failed to stop ${role}: ${e.message}`))));
+      }), { concurrency: "unbounded" });
       console.log(`[${formatTimestamp()}] All agents stopped`);
     }
     yield* exports_Effect.promise(() => session2.backend.mutation(api.machines.updateDaemonStatus, {
@@ -84924,36 +85205,45 @@ async function pushSingleWorkspaceGitStateImpl(ctx, workingDir) {
   const stateKey = makeGitStateKey(ctx.machineId, workingDir);
   const isRepo = await isGitRepo(workingDir);
   if (!isRepo) {
-    const stateHash2 = "not_found";
-    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
-      return;
-    await ctx.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      workingDir,
-      status: "not_found"
-    });
-    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    await pushNotFoundGitState(ctx, workingDir, stateKey);
     return;
   }
   const branchResult = await getBranch(workingDir);
   if (branchResult.status === "error") {
-    const stateHash2 = `error:${branchResult.message}`;
-    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
-      return;
-    await ctx.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
-      sessionId: ctx.sessionId,
-      machineId: ctx.machineId,
-      workingDir,
-      status: "error",
-      errorMessage: branchResult.message
-    });
-    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    await pushErrorGitState(ctx, workingDir, stateKey, branchResult.message);
     return;
   }
   if (branchResult.status === "not_found") {
     return;
   }
+  await pushAvailableGitState(ctx, workingDir, stateKey, branchResult);
+}
+async function pushNotFoundGitState(ctx, workingDir, stateKey) {
+  const stateHash = "not_found";
+  if (ctx.lastPushedGitState.get(stateKey) === stateHash)
+    return;
+  await ctx.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    status: "not_found"
+  });
+  ctx.lastPushedGitState.set(stateKey, stateHash);
+}
+async function pushErrorGitState(ctx, workingDir, stateKey, message) {
+  const stateHash = `error:${message}`;
+  if (ctx.lastPushedGitState.get(stateKey) === stateHash)
+    return;
+  await ctx.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    status: "error",
+    errorMessage: message
+  });
+  ctx.lastPushedGitState.set(stateKey, stateHash);
+}
+async function pushAvailableGitState(ctx, workingDir, stateKey, branchResult) {
   const branch = branchResult.branch;
   const allFields = [branchField, ...GIT_STATE_FIELDS, ...makeBranchDependentFields(branch)];
   const pipeline2 = new GitStatePipeline(allFields);
@@ -84990,16 +85280,12 @@ async function pushSingleWorkspaceGitStateImpl(ctx, workingDir) {
     }
   }
 }
-var lastFullPushMs, branchField, GIT_STATE_FIELDS, pushSingleWorkspaceGitSummaryForObservedEffect = (workingDir, reason = "safety-poll") => exports_Effect.gen(function* () {
-  const session2 = yield* DaemonSessionService;
-  const mutable = yield* DaemonMutableStateService;
-  const lastPushedGitState = yield* exports_Ref.get(mutable.lastPushedGitState);
-  const stateKey = makeGitStateKey(session2.machineId, workingDir);
-  const isRepo = yield* exports_Effect.promise(() => isGitRepo(workingDir));
-  if (!isRepo) {
+function pushObservedNotRepoEffect(session2, lastPushedGitState, stateKey, workingDir, reason) {
+  return exports_Effect.gen(function* () {
     const stateHash = "not_found";
-    if (reason !== "refresh" && lastPushedGitState.get(stateKey) === stateHash)
+    if (reason !== "refresh" && lastPushedGitState.get(stateKey) === stateHash) {
       return;
+    }
     yield* exports_Effect.promise(() => session2.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
       sessionId: session2.sessionId,
       machineId: session2.machineId,
@@ -85007,21 +85293,69 @@ var lastFullPushMs, branchField, GIT_STATE_FIELDS, pushSingleWorkspaceGitSummary
       status: "not_found"
     }));
     lastPushedGitState.set(stateKey, stateHash);
-    return;
-  }
-  const branchResult = yield* exports_Effect.promise(() => getBranch(workingDir));
-  if (branchResult.status === "error") {
-    const stateHash = `error:${branchResult.message}`;
-    if (reason !== "refresh" && lastPushedGitState.get(stateKey) === stateHash)
+  });
+}
+function pushObservedBranchErrorEffect(session2, lastPushedGitState, stateKey, workingDir, reason, message) {
+  return exports_Effect.gen(function* () {
+    const stateHash = `error:${message}`;
+    if (reason !== "refresh" && lastPushedGitState.get(stateKey) === stateHash) {
       return;
+    }
     yield* exports_Effect.promise(() => session2.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
       sessionId: session2.sessionId,
       machineId: session2.machineId,
       workingDir,
       status: "error",
-      errorMessage: branchResult.message
+      errorMessage: message
     }));
     lastPushedGitState.set(stateKey, stateHash);
+  });
+}
+function pushObservedFullGitStateEffect(session2, lastPushedGitState, stateKey, workingDir, branch, reason) {
+  return exports_Effect.gen(function* () {
+    yield* exports_Effect.promise(() => pushSingleWorkspaceGitStateImpl(buildGitStateDeps(session2, lastPushedGitState), workingDir));
+    lastFullPushMs.set(stateKey, Date.now());
+    console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed full git state pushed: ${workingDir} (${branch})${reason === "refresh" ? " [refresh]" : ""}`);
+  });
+}
+function pushObservedSlimGitSummaryEffect(session2, lastPushedGitState, stateKey, workingDir, branch, branchResult, reason) {
+  return exports_Effect.gen(function* () {
+    const slimFields = [
+      branchField,
+      ...GIT_STATE_FIELDS.filter((f) => f.includeInSlim),
+      ...makeBranchDependentFields(branch)
+    ];
+    const pipeline2 = new GitStatePipeline(slimFields);
+    const preCollected = new Map([["branch", branchResult]]);
+    const values3 = yield* exports_Effect.promise(() => pipeline2.collect(workingDir, preCollected));
+    const hash2 = pipeline2.computeHash(values3, true);
+    if (reason !== "refresh" && lastPushedGitState.get(stateKey) === hash2) {
+      return;
+    }
+    yield* exports_Effect.promise(() => session2.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      workingDir,
+      status: "available",
+      ...pipeline2.toMutationArgs(values3, true)
+    }));
+    lastPushedGitState.set(stateKey, hash2);
+    console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed git summary pushed: ${workingDir} (${branch}${values3.get("isDirty") ? ", dirty" : ", clean"})${reason === "refresh" ? " [refresh]" : ""}`);
+  });
+}
+var lastFullPushMs, branchField, GIT_STATE_FIELDS, pushSingleWorkspaceGitSummaryForObservedEffect = (workingDir, reason = "safety-poll") => exports_Effect.gen(function* pushObservedGitSummaryForObserved() {
+  const session2 = yield* DaemonSessionService;
+  const mutable = yield* DaemonMutableStateService;
+  const lastPushedGitState = yield* exports_Ref.get(mutable.lastPushedGitState);
+  const stateKey = makeGitStateKey(session2.machineId, workingDir);
+  const isRepo = yield* exports_Effect.promise(() => isGitRepo(workingDir));
+  if (!isRepo) {
+    yield* pushObservedNotRepoEffect(session2, lastPushedGitState, stateKey, workingDir, reason);
+    return;
+  }
+  const branchResult = yield* exports_Effect.promise(() => getBranch(workingDir));
+  if (branchResult.status === "error") {
+    yield* pushObservedBranchErrorEffect(session2, lastPushedGitState, stateKey, workingDir, reason, branchResult.message);
     return;
   }
   if (branchResult.status === "not_found") {
@@ -85031,32 +85365,10 @@ var lastFullPushMs, branchField, GIT_STATE_FIELDS, pushSingleWorkspaceGitSummary
   const now = Date.now();
   const lastFull = lastFullPushMs.get(stateKey) ?? 0;
   if (now - lastFull >= OBSERVED_FULL_PUSH_INTERVAL_MS) {
-    yield* exports_Effect.promise(() => pushSingleWorkspaceGitStateImpl(buildGitStateDeps(session2, lastPushedGitState), workingDir));
-    lastFullPushMs.set(stateKey, now);
-    console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed full git state pushed: ${workingDir} (${branch})${reason === "refresh" ? " [refresh]" : ""}`);
-    return;
-  }
-  const slimFields = [
-    branchField,
-    ...GIT_STATE_FIELDS.filter((f) => f.includeInSlim),
-    ...makeBranchDependentFields(branch)
-  ];
-  const pipeline2 = new GitStatePipeline(slimFields);
-  const preCollected = new Map([["branch", branchResult]]);
-  const values3 = yield* exports_Effect.promise(() => pipeline2.collect(workingDir, preCollected));
-  const hash2 = pipeline2.computeHash(values3, true);
-  if (reason !== "refresh" && lastPushedGitState.get(stateKey) === hash2) {
+    yield* pushObservedFullGitStateEffect(session2, lastPushedGitState, stateKey, workingDir, branch, reason);
     return;
   }
-  yield* exports_Effect.promise(() => session2.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    workingDir,
-    status: "available",
-    ...pipeline2.toMutationArgs(values3, true)
-  }));
-  lastPushedGitState.set(stateKey, hash2);
-  console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed git summary pushed: ${workingDir} (${branch}${values3.get("isDirty") ? ", dirty" : ", clean"})${reason === "refresh" ? " [refresh]" : ""}`);
+  yield* pushObservedSlimGitSummaryEffect(session2, lastPushedGitState, stateKey, workingDir, branch, branchResult, reason);
 }), pushGitStateEffect, pushSingleWorkspaceGitStateEffect = (workingDir) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const mutable = yield* DaemonMutableStateService;
@@ -85272,14 +85584,12 @@ async function processPRAction(deps, req) {
     timeout: EXEC_TIMEOUT_MS
   });
   console.log(`[${formatTimestamp()}] ✅ PR action: ${action} on #${prNumber}${result.stdout ? ` — ${result.stdout.trim()}` : ""}`);
-  await exports_Effect.runPromise(pushGitStateEffect.pipe(exports_Effect.provide(exports_Layer.mergeAll(exports_Layer.succeed(DaemonSessionService, deps), DaemonMutableStateServiceLive({
+  exports_Runtime.runFork(deps.runtime)(pushGitStateEffect.pipe(exports_Effect.provide(exports_Layer.mergeAll(exports_Layer.succeed(DaemonSessionService, deps), DaemonMutableStateServiceLive({
     lastPushedGitState: deps.lastPushedGitState,
     lastPushedModels: null,
     lastPushedHarnessFingerprint: null,
     workspaceListStore: deps.workspaceListStore
-  }))))).catch((err) => {
-    console.warn(`[${formatTimestamp()}] ⚠️  Failed to refresh git state after PR action: ${getErrorMessage(err)}`);
-  });
+  }))), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[${formatTimestamp()}] ⚠️  Failed to refresh git state after PR action: ${getErrorMessage(err)}`)))));
 }
 async function processPRCommits(deps, req) {
   const prNumber = req.prNumber;
@@ -85304,32 +85614,35 @@ async function processCommitDetail(deps, req) {
     getCommitDetail(req.workingDir, req.sha),
     getCommitMetadata(req.workingDir, req.sha)
   ]);
+  await upsertCommitDetailResult(deps, req, result, metadata);
+  if (result.status === "available" || result.status === "truncated") {
+    const compressed = gzipSync2(Buffer.from(result.content));
+    console.log(`[${formatTimestamp()}] \uD83D\uDD0D Commit detail pushed: ${req.sha.slice(0, 7)} in ${req.workingDir} (${(Buffer.byteLength(result.content) / 1024).toFixed(1)}KB → ${(compressed.length / 1024).toFixed(1)}KB gzip)`);
+  }
+}
+async function upsertCommitDetailResult(deps, req, result, metadata) {
+  const baseArgs = {
+    sessionId: deps.sessionId,
+    machineId: deps.machineId,
+    workingDir: req.workingDir,
+    sha: req.sha,
+    message: metadata?.message,
+    body: metadata?.body,
+    author: metadata?.author,
+    date: metadata?.date
+  };
   if (result.status === "not_found") {
     await deps.backend.mutation(api.workspaces.upsertCommitDetailV2, {
-      sessionId: deps.sessionId,
-      machineId: deps.machineId,
-      workingDir: req.workingDir,
-      sha: req.sha,
-      status: "not_found",
-      message: metadata?.message,
-      body: metadata?.body,
-      author: metadata?.author,
-      date: metadata?.date
+      ...baseArgs,
+      status: "not_found"
     });
     return;
   }
   if (result.status === "error") {
     await deps.backend.mutation(api.workspaces.upsertCommitDetailV2, {
-      sessionId: deps.sessionId,
-      machineId: deps.machineId,
-      workingDir: req.workingDir,
-      sha: req.sha,
+      ...baseArgs,
       status: "error",
-      errorMessage: result.message,
-      message: metadata?.message,
-      body: metadata?.body,
-      author: metadata?.author,
-      date: metadata?.date
+      errorMessage: result.message
     });
     return;
   }
@@ -85337,20 +85650,12 @@ async function processCommitDetail(deps, req) {
   const compressed = gzipSync2(Buffer.from(result.content));
   const diffContentCompressed = compressed.toString("base64");
   await deps.backend.mutation(api.workspaces.upsertCommitDetailV2, {
-    sessionId: deps.sessionId,
-    machineId: deps.machineId,
-    workingDir: req.workingDir,
-    sha: req.sha,
+    ...baseArgs,
     status: "available",
     data: { compression: "gzip", content: diffContentCompressed },
     truncated: result.truncated,
-    message: metadata?.message,
-    body: metadata?.body,
-    author: metadata?.author,
-    date: metadata?.date,
     diffStat
   });
-  console.log(`[${formatTimestamp()}] \uD83D\uDD0D Commit detail pushed: ${req.sha.slice(0, 7)} in ${req.workingDir} (${(Buffer.byteLength(result.content) / 1024).toFixed(1)}KB → ${(compressed.length / 1024).toFixed(1)}KB gzip)`);
 }
 async function processMoreCommits(deps, req) {
   const offset = req.offset ?? 0;
@@ -85387,11 +85692,33 @@ async function processRecentCommits(deps, req) {
   });
   console.log(`[${formatTimestamp()}] \uD83D\uDCDC Recent commits pushed: ${req.workingDir} (${commits.length} commits)`);
 }
+function dispatchGitRequest(deps, req) {
+  switch (req.requestType) {
+    case "full_diff":
+      return exports_Effect.promise(() => processFullDiff(deps, req));
+    case "commit_detail":
+      return exports_Effect.promise(() => processCommitDetail(deps, req));
+    case "more_commits":
+      return exports_Effect.promise(() => processMoreCommits(deps, req));
+    case "pr_diff":
+      return exports_Effect.promise(() => processPRDiff(deps, req));
+    case "pr_action":
+      return exports_Effect.promise(() => processPRAction(deps, req));
+    case "pr_commits":
+      return exports_Effect.promise(() => processPRCommits(deps, req));
+    case "all_pull_requests":
+      return exports_Effect.promise(() => processAllPullRequests(deps, req));
+    case "recent_commits":
+      return exports_Effect.promise(() => processRecentCommits(deps, req));
+  }
+}
 var EXEC_TIMEOUT_MS = 60000, startGitRequestSubscriptionEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
+  const runtime4 = yield* exports_Effect.runtime();
   const processedRequestIds = new Map;
   const DEDUP_TTL_MS = 5 * 60 * 1000;
-  let processing = false;
+  const sessionWithRuntime = { ...session2, runtime: runtime4 };
+  const processingState = { isProcessing: false };
   session2.backend.mutation(api.workspaces.resetProcessingRequests, {
     sessionId: session2.sessionId,
     machineId: session2.machineId
@@ -85408,16 +85735,14 @@ var EXEC_TIMEOUT_MS = 60000, startGitRequestSubscriptionEffect = (wsClient2) =>
   }, (requests) => {
     if (!requests || requests.length === 0)
       return;
-    const logger = session2.logger ?? console;
+    const logger = sessionWithRuntime.logger ?? console;
     logger.log(`[${formatTimestamp()}] \uD83D\uDCEC Git subscription: received ${requests.length} pending request(s)`);
-    if (processing)
+    if (processingState.isProcessing)
       return;
-    processing = true;
-    exports_Effect.runPromise(processRequestsEffect(requests, processedRequestIds, DEDUP_TTL_MS).pipe(exports_Effect.provideService(DaemonSessionService, session2))).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️  Git request processing failed: ${getErrorMessage(err)}`);
-    }).finally(() => {
-      processing = false;
-    });
+    processingState.isProcessing = true;
+    exports_Runtime.runFork(runtime4)(processRequestsEffect(requests, processedRequestIds, DEDUP_TTL_MS, runtime4).pipe(exports_Effect.provideService(DaemonSessionService, sessionWithRuntime), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[${formatTimestamp()}] ⚠️  Git request processing failed: ${getErrorMessage(err)}`))), exports_Effect.ensuring(exports_Effect.sync(() => {
+      processingState.isProcessing = false;
+    }))));
   }, (err) => {
     console.warn(`[${formatTimestamp()}] ⚠️  Git request subscription error: ${getErrorMessage(err)}`);
   });
@@ -85428,7 +85753,7 @@ var EXEC_TIMEOUT_MS = 60000, startGitRequestSubscriptionEffect = (wsClient2) =>
       console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git request subscription stopped`);
     }
   };
-}), processRequestsEffect = (requests, processedRequestIds, dedupTtlMs) => exports_Effect.gen(function* () {
+}), processRequestsEffect = (requests, processedRequestIds, dedupTtlMs, runtime4) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const evictBefore = Date.now() - dedupTtlMs;
   for (const [id3, ts] of processedRequestIds) {
@@ -85448,32 +85773,8 @@ var EXEC_TIMEOUT_MS = 60000, startGitRequestSubscriptionEffect = (wsClient2) =>
       }));
       const logger = session2.logger ?? console;
       logger.log(`[${formatTimestamp()}] ⚙️  Processing git request: type=${req.requestType}, id=${requestId}`);
-      switch (req.requestType) {
-        case "full_diff":
-          yield* exports_Effect.promise(() => processFullDiff(session2, req));
-          break;
-        case "commit_detail":
-          yield* exports_Effect.promise(() => processCommitDetail(session2, req));
-          break;
-        case "more_commits":
-          yield* exports_Effect.promise(() => processMoreCommits(session2, req));
-          break;
-        case "pr_diff":
-          yield* exports_Effect.promise(() => processPRDiff(session2, req));
-          break;
-        case "pr_action":
-          yield* exports_Effect.promise(() => processPRAction(session2, req));
-          break;
-        case "pr_commits":
-          yield* exports_Effect.promise(() => processPRCommits(session2, req));
-          break;
-        case "all_pull_requests":
-          yield* exports_Effect.promise(() => processAllPullRequests(session2, req));
-          break;
-        case "recent_commits":
-          yield* exports_Effect.promise(() => processRecentCommits(session2, req));
-          break;
-      }
+      const sessionWithRuntime = { ...session2, runtime: runtime4 };
+      yield* dispatchGitRequest(sessionWithRuntime, req);
       yield* exports_Effect.promise(() => session2.backend.mutation(api.workspaces.updateRequestStatus, {
         sessionId: session2.sessionId,
         requestId: req._id,
@@ -85653,6 +85954,26 @@ function startCommandSubscriber(session2, wsClient2, deps) {
   });
   return { stop: unsub };
 }
+async function dispatchPendingCommand(session2, deps, cmd) {
+  switch (cmd.type) {
+    case "refreshCapabilities":
+      await handleRefreshCapabilities(session2, deps, cmd);
+      break;
+    case "refreshSessionTitle":
+      await handleRefreshSessionTitle(session2, deps, cmd);
+      break;
+    default:
+      await markFailed(session2, cmd._id, `Unknown command type: ${cmd.type}`);
+  }
+}
+async function processPendingCommand(session2, deps, cmd, now) {
+  if (now - cmd.createdAt > DIRECT_HARNESS_COMMAND_TTL_MS) {
+    console.log(`[direct-harness] Discarding stale command ${cmd._id} (type=${cmd.type}, age=${now - cmd.createdAt}ms)`);
+    await markFailed(session2, cmd._id, "Command expired (TTL)");
+    return;
+  }
+  await dispatchPendingCommand(session2, deps, cmd);
+}
 async function drain(session2, deps, processed) {
   const pending3 = await session2.backend.query(api.daemon.directHarness.commands.listPendingCommands, { sessionId: session2.sessionId, machineId: session2.machineId });
   if (!pending3 || pending3.length === 0)
@@ -85663,21 +85984,7 @@ async function drain(session2, deps, processed) {
       continue;
     processed.add(cmd._id);
     try {
-      if (now - cmd.createdAt > DIRECT_HARNESS_COMMAND_TTL_MS) {
-        console.log(`[direct-harness] Discarding stale command ${cmd._id} (type=${cmd.type}, age=${now - cmd.createdAt}ms)`);
-        await markFailed(session2, cmd._id, "Command expired (TTL)");
-        continue;
-      }
-      switch (cmd.type) {
-        case "refreshCapabilities":
-          await handleRefreshCapabilities(session2, deps, cmd);
-          break;
-        case "refreshSessionTitle":
-          await handleRefreshSessionTitle(session2, deps, cmd);
-          break;
-        default:
-          await markFailed(session2, cmd._id, `Unknown command type: ${cmd.type}`);
-      }
+      await processPendingCommand(session2, deps, cmd, now);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       console.warn(`[direct-harness] Command ${cmd._id} failed: ${message}`);
@@ -86500,74 +86807,73 @@ async function drain2(session2, deps) {
     }
   }
 }
-async function processSessionMessages(session2, deps, rowId, messages, info) {
-  let handle = deps.activeSessions.get(rowId);
-  if (!handle) {
-    const opencodeSessionId = info?.opencodeSessionId;
-    if (!opencodeSessionId) {
-      console.warn(`[direct-harness] Session ${rowId} not yet open — waiting for session-subscriber`);
-      return;
-    }
-    const workspaceId = info?.workspaceId;
-    if (!workspaceId) {
-      console.warn(`[direct-harness] Cannot resume session ${rowId}: no workspace info`);
-      return;
-    }
-    let harness = deps.harnesses.get(workspaceId);
-    if (harness && !harness.isAlive()) {
-      harness.close().catch(() => {});
-      deps.harnesses.delete(workspaceId);
-      harness = undefined;
+async function resumeSessionHandle(session2, deps, rowId, info) {
+  const opencodeSessionId = info.opencodeSessionId;
+  if (!opencodeSessionId) {
+    console.warn(`[direct-harness] Session ${rowId} not yet open — waiting for session-subscriber`);
+    return null;
+  }
+  const workspaceId = info.workspaceId;
+  if (!workspaceId) {
+    console.warn(`[direct-harness] Cannot resume session ${rowId}: no workspace info`);
+    return null;
+  }
+  let harness = deps.harnesses.get(workspaceId);
+  if (harness && !harness.isAlive()) {
+    harness.close().catch(() => {});
+    deps.harnesses.delete(workspaceId);
+    harness = undefined;
+  }
+  if (!harness) {
+    const workspace = await session2.backend.query(api.workspaces.getWorkspaceById, {
+      sessionId: session2.sessionId,
+      workspaceId
+    });
+    if (!workspace) {
+      console.warn(`[direct-harness] Cannot resume session ${rowId}: workspace not found`);
+      return null;
     }
-    if (!harness) {
-      const workspace = await session2.backend.query(api.workspaces.getWorkspaceById, {
-        sessionId: session2.sessionId,
-        workspaceId
-      });
-      if (!workspace) {
-        console.warn(`[direct-harness] Cannot resume session ${rowId}: workspace not found`);
-        return;
+    harness = await startOpencodeSdkHarness({
+      type: "opencode",
+      workingDir: workspace.workingDir,
+      workspaceId
+    });
+    deps.harnesses.set(workspaceId, harness);
+  }
+  try {
+    return await resumeSession({
+      harness,
+      journalFactory: deps.journalFactory,
+      chunkExtractor: createOpencodeSdkChunkExtractor()
+    }, { harnessSessionId: rowId, opencodeSessionId, workspaceId });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(`[direct-harness] Cannot resume session ${rowId}: ${message}`);
+    await deps.sessionRepository.markFailed(rowId).catch(() => {});
+    return null;
+  }
+}
+function wireResumedSessionEvents(handle, deps, info) {
+  const idleConfig = {
+    agent: info.lastUsedConfig.agent ?? "build",
+    model: info.lastUsedConfig.model
+  };
+  let lastBoundKey = null;
+  handle.session.onEvent((event) => {
+    const turn = handle.currentTurn;
+    if (turn?.messageId !== null && turn?.messageId !== undefined) {
+      const key = `${turn.turnId}:${turn.messageId}`;
+      if (key !== lastBoundKey) {
+        lastBoundKey = key;
+        deps.sessionRepository.bindTurnMessageId(turn.turnId, turn.messageId).catch((err) => console.warn("[direct-harness] bindTurnMessageId error (resume):", err));
       }
-      harness = await startOpencodeSdkHarness({
-        type: "opencode",
-        workingDir: workspace.workingDir,
-        workspaceId
-      });
-      deps.harnesses.set(workspaceId, harness);
     }
-    try {
-      handle = await resumeSession({
-        harness,
-        journalFactory: deps.journalFactory,
-        chunkExtractor: createOpencodeSdkChunkExtractor()
-      }, { harnessSessionId: rowId, opencodeSessionId, workspaceId });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.warn(`[direct-harness] Cannot resume session ${rowId}: ${message}`);
-      await deps.sessionRepository.markFailed(rowId).catch(() => {});
-      return;
+    if (event.type === "session.idle") {
+      handleSessionIdle(handle, handle.journal, idleConfig, deps.sessionRepository).catch((err) => console.warn("[direct-harness] idle handler error (resume):", err));
     }
-    deps.activeSessions.set(rowId, handle);
-    await deps.sessionRepository.markActive(rowId).catch(() => {});
-    const idleConfig = {
-      agent: info?.lastUsedConfig.agent ?? "build",
-      model: info?.lastUsedConfig.model
-    };
-    let lastBoundKey = null;
-    handle.session.onEvent((event) => {
-      const turn = handle.currentTurn;
-      if (turn?.messageId !== null && turn?.messageId !== undefined) {
-        const key = `${turn.turnId}:${turn.messageId}`;
-        if (key !== lastBoundKey) {
-          lastBoundKey = key;
-          deps.sessionRepository.bindTurnMessageId(turn.turnId, turn.messageId).catch((err) => console.warn("[direct-harness] bindTurnMessageId error (resume):", err));
-        }
-      }
-      if (event.type === "session.idle") {
-        handleSessionIdle(handle, handle.journal, idleConfig, deps.sessionRepository).catch((err) => console.warn("[direct-harness] idle handler error (resume):", err));
-      }
-    });
-  }
+  });
+}
+async function deliverPendingMessages(handle, deps, rowId, messages, info) {
   for (const msg of messages) {
     const override = info?.lastUsedConfig ?? { agent: "build" };
     try {
@@ -86591,6 +86897,24 @@ async function processSessionMessages(session2, deps, rowId, messages, info) {
     }
   }
 }
+async function processSessionMessages(session2, deps, rowId, messages, info) {
+  let handle = deps.activeSessions.get(rowId);
+  if (!handle) {
+    if (!info) {
+      console.warn(`[direct-harness] Session ${rowId} not yet open — waiting for session-subscriber`);
+      return;
+    }
+    const resumed = await resumeSessionHandle(session2, deps, rowId, info);
+    if (!resumed) {
+      return;
+    }
+    handle = resumed;
+    deps.activeSessions.set(rowId, handle);
+    await deps.sessionRepository.markActive(rowId).catch(() => {});
+    wireResumedSessionEvents(handle, deps, info);
+  }
+  await deliverPendingMessages(handle, deps, rowId, messages, info);
+}
 var init_prompt_subscriber = __esm(() => {
   init_idle_handler();
   init_api3();
@@ -86619,6 +86943,60 @@ function startSessionSubscriber(daemonSession, wsClient2, deps) {
   });
   return { stop: unsub };
 }
+async function getOrCreateHarness(daemonSession, deps, session2, workspace) {
+  let harness = deps.harnesses.get(session2.workspaceId);
+  if (harness && !harness.isAlive()) {
+    console.warn(`[direct-harness] Harness for workspace ${session2.workspaceId} is no longer alive — restarting`);
+    harness.close().catch(() => {});
+    deps.harnesses.delete(session2.workspaceId);
+    harness = undefined;
+  }
+  if (!harness) {
+    harness = await startOpencodeSdkHarness({
+      type: "opencode",
+      workingDir: workspace.workingDir,
+      workspaceId: session2.workspaceId
+    });
+    deps.harnesses.set(session2.workspaceId, harness);
+  }
+  return harness;
+}
+function recordLiveSessionChunk(event, handle, journal, extractChunk, deps) {
+  const chunk2 = extractChunk(event);
+  if (chunk2 === null) {
+    return;
+  }
+  journal.record({
+    content: chunk2.content,
+    timestamp: Date.now(),
+    messageId: chunk2.messageId,
+    partType: chunk2.partType
+  });
+  if (handle.currentTurn && handle.currentTurn.messageId === null) {
+    handle.currentTurn.messageId = chunk2.messageId;
+    deps.sessionRepository.bindTurnMessageId(handle.currentTurn.turnId, chunk2.messageId).catch((err) => console.warn("[direct-harness] bindTurnMessageId error:", err));
+  }
+}
+function handleLiveSessionTitleUpdate(event, deps, rowId, liveSession) {
+  if (event.type !== "session.updated") {
+    return;
+  }
+  const info = event.payload.info;
+  const newTitle = info?.title;
+  if (!newTitle || newTitle === liveSession.sessionTitle) {
+    return;
+  }
+  liveSession.setTitle?.(newTitle);
+  deps.sessionRepository.updateSessionTitle(rowId, newTitle).catch((err) => console.warn("[direct-harness] updateSessionTitle error:", err));
+}
+function handleLiveSessionEvent(event, ctx) {
+  const { handle, journal, extractChunk, idleConfig, deps, rowId, liveSession } = ctx;
+  recordLiveSessionChunk(event, handle, journal, extractChunk, deps);
+  if (event.type === "session.idle") {
+    handleSessionIdle(handle, journal, idleConfig, deps.sessionRepository).catch((err) => console.warn("[direct-harness] idle handler error:", err));
+  }
+  handleLiveSessionTitleUpdate(event, deps, rowId, liveSession);
+}
 async function processOne(daemonSession, deps, session2) {
   const rowId = session2._id;
   try {
@@ -86631,21 +87009,7 @@ async function processOne(daemonSession, deps, session2) {
       await deps.sessionRepository.markFailed(rowId);
       return;
     }
-    let harness = deps.harnesses.get(session2.workspaceId);
-    if (harness && !harness.isAlive()) {
-      console.warn(`[direct-harness] Harness for workspace ${session2.workspaceId} is no longer alive — restarting`);
-      harness.close().catch(() => {});
-      deps.harnesses.delete(session2.workspaceId);
-      harness = undefined;
-    }
-    if (!harness) {
-      harness = await startOpencodeSdkHarness({
-        type: "opencode",
-        workingDir: workspace.workingDir,
-        workspaceId: session2.workspaceId
-      });
-      deps.harnesses.set(session2.workspaceId, harness);
-    }
+    const harness = await getOrCreateHarness(daemonSession, deps, session2, workspace);
     const liveSession = await harness.newSession({
       agent: session2.opencode?.lastUsedConfig.agent ?? "build",
       harnessSessionId: rowId
@@ -86677,30 +87041,15 @@ async function processOne(daemonSession, deps, session2) {
       close: close2
     };
     unsubscribeEvents = liveSession.onEvent((event) => {
-      const chunk2 = extractChunk(event);
-      if (chunk2 !== null) {
-        journal.record({
-          content: chunk2.content,
-          timestamp: Date.now(),
-          messageId: chunk2.messageId,
-          partType: chunk2.partType
-        });
-        if (handle.currentTurn && handle.currentTurn.messageId === null) {
-          handle.currentTurn.messageId = chunk2.messageId;
-          deps.sessionRepository.bindTurnMessageId(handle.currentTurn.turnId, chunk2.messageId).catch((err) => console.warn("[direct-harness] bindTurnMessageId error:", err));
-        }
-      }
-      if (event.type === "session.idle") {
-        handleSessionIdle(handle, journal, idleConfig, deps.sessionRepository).catch((err) => console.warn("[direct-harness] idle handler error:", err));
-      }
-      if (event.type === "session.updated") {
-        const info = event.payload.info;
-        const newTitle = info?.title;
-        if (newTitle && newTitle !== liveSession.sessionTitle) {
-          liveSession.setTitle?.(newTitle);
-          deps.sessionRepository.updateSessionTitle(rowId, newTitle).catch((err) => console.warn("[direct-harness] updateSessionTitle error:", err));
-        }
-      }
+      handleLiveSessionEvent(event, {
+        handle,
+        journal,
+        extractChunk,
+        idleConfig,
+        deps,
+        rowId,
+        liveSession
+      });
     });
     deps.activeSessions.set(rowId, handle);
     try {
@@ -87528,16 +87877,14 @@ var init_state_recovery = __esm(() => {
           for (const config3 of configsResult.configs) {
             if (config3.machineId === session2.machineId && config3.workingDir) {
               registeredCount++;
-              exports_Effect.runPromise(exports_Effect.tryPromise(() => session2.backend.mutation(api.workspaces.registerWorkspace, {
+              yield* exports_Effect.forkDaemon(exports_Effect.tryPromise(() => session2.backend.mutation(api.workspaces.registerWorkspace, {
                 sessionId: session2.sessionId,
                 chatroomId,
                 machineId: session2.machineId,
                 workingDir: config3.workingDir,
                 hostname: session2.config?.hostname ?? "unknown",
                 registeredBy: config3.role
-              }))).catch((err) => {
-                console.warn(`[daemon] ⚠️ Failed to register workspace on recovery: ${err.message}`);
-              });
+              })).pipe(exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[daemon] ⚠️ Failed to register workspace on recovery: ${err.message}`)))));
             }
           }
         }), () => exports_Effect.void);
@@ -87608,16 +87955,18 @@ class DaemonEventBus {
 }
 
 // src/events/daemon/agent/on-agent-exited.ts
-async function handleAgentExited(deps, payload) {
-  await deps.handleExit({
+var onAgentExitedEffect = (payload) => exports_Effect.gen(function* () {
+  const apm = yield* DaemonAgentProcessManagerService;
+  yield* apm.handleExit({
     chatroomId: payload.chatroomId,
     role: payload.role,
     pid: payload.pid,
     code: payload.code,
     signal: payload.signal
   });
-}
+});
 var init_on_agent_exited = __esm(() => {
+  init_esm();
   init_daemon_services();
 });
 
@@ -87638,9 +87987,11 @@ var init_on_agent_stopped = () => {};
 // src/events/daemon/register-listeners.ts
 var registerEventListenersEffect = () => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
-  const apm = yield* DaemonAgentProcessManagerService;
+  const runtime4 = yield* exports_Effect.runtime();
   const unsubs = [];
-  unsubs.push(session2.events.on("agent:exited", (payload) => handleAgentExited({ handleExit: (opts) => exports_Effect.runPromise(apm.handleExit(opts)) }, payload)));
+  unsubs.push(session2.events.on("agent:exited", (payload) => {
+    exports_Runtime.runFork(runtime4)(onAgentExitedEffect(payload));
+  }));
   unsubs.push(session2.events.on("agent:started", (payload) => logAgentStarted(payload)));
   unsubs.push(session2.events.on("agent:stopped", (payload) => logAgentStopped(payload)));
   return () => {
@@ -87960,9 +88311,131 @@ var init_decide_resume_path = __esm(() => {
   ]);
 });
 
+// src/domain/agent-lifecycle/entities/agent-slot.ts
+function agentKey2(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+var idleSlot = () => ({ state: "idle" });
+// src/domain/agent-lifecycle/policies/slot-transitions.ts
+function makeError(tag, from, event) {
+  return {
+    ok: false,
+    error: { _tag: tag, from, event }
+  };
+}
+function makeResult(slot) {
+  return { ok: true, slot };
+}
+function transitionFromIdle(slot, event) {
+  if (event.type === "ensure_running_requested") {
+    return makeResult(slot);
+  }
+  if (event.type === "spawn_started") {
+    return makeResult({ ...slot, state: "spawning", pendingOperationKey: event.operationKey });
+  }
+  if (event.type === "process_exited") {
+    return makeResult(slot);
+  }
+  return makeError("InvalidTransition", slot.state, event.type);
+}
+function transitionFromSpawning(slot, event) {
+  if (event.type === "spawn_started") {
+    return makeResult({ ...slot, pendingOperationKey: event.operationKey });
+  }
+  if (event.type === "spawn_succeeded") {
+    return makeResult({ ...slot, state: "running", pid: event.pid });
+  }
+  if (event.type === "spawn_failed" || event.type === "process_exited") {
+    return makeResult({ state: "idle" });
+  }
+  return makeError("InvalidTransition", slot.state, event.type);
+}
+function transitionFromRunning(slot, event) {
+  if (event.type === "stop_requested") {
+    return makeResult({ ...slot, state: "stopping", pendingOperationKey: event.operationKey });
+  }
+  if (event.type === "process_exited") {
+    if (slot.pid !== undefined && slot.pid !== event.pid) {
+      return { ok: false, error: { _tag: "StalePid", expected: slot.pid, got: event.pid } };
+    }
+    return makeResult({ state: "idle" });
+  }
+  if (event.type === "stale_process_detected") {
+    return makeResult({ state: "idle" });
+  }
+  return makeError("InvalidTransition", slot.state, event.type);
+}
+function transitionFromStopping(slot, event) {
+  if (event.type === "stop_completed") {
+    return makeResult({ state: "idle" });
+  }
+  if (event.type === "process_exited") {
+    return { ok: false, error: { _tag: "IgnoredDuplicateExit" } };
+  }
+  return makeError("InvalidTransition", slot.state, event.type);
+}
+function transitionSlot(slot, event) {
+  switch (slot.state) {
+    case "idle":
+      return transitionFromIdle(slot, event);
+    case "spawning":
+      return transitionFromSpawning(slot, event);
+    case "running":
+      return transitionFromRunning(slot, event);
+    case "stopping":
+      return transitionFromStopping(slot, event);
+  }
+}
+function shouldIgnoreProcessExit(slot, exitPid) {
+  if (slot.state === "stopping")
+    return true;
+  if (slot.pid !== undefined && slot.pid !== exitPid)
+    return true;
+  return false;
+}
+
+// src/domain/agent-lifecycle/policies/restart-decision.ts
+function decideRestartAfterExit(input) {
+  if (!shouldAutoRestartAfterProcessExit(input.stopReason)) {
+    return { _tag: "NoRestart", reason: `Intentional stop: ${input.stopReason}` };
+  }
+  if (!input.harness || !input.workingDir) {
+    return { _tag: "NoRestart", reason: "Missing harness or workingDir" };
+  }
+  if (input.isPermanentFailure) {
+    return {
+      _tag: "NoRestart",
+      reason: input.permanentFailureMessage ?? "Permanent failure"
+    };
+  }
+  if (input.backoffWaitMs && input.backoffWaitMs > 0) {
+    return {
+      _tag: "ScheduleRetry",
+      waitMs: input.backoffWaitMs,
+      spawnReason: "platform.crash_recovery",
+      wantResume: input.wantResume
+    };
+  }
+  return {
+    _tag: "RestartNow",
+    spawnReason: "platform.crash_recovery",
+    wantResume: input.wantResume,
+    bypassConcurrentLimit: true
+  };
+}
+var init_restart_decision = __esm(() => {
+  init_decide_resume_path();
+});
+
+// src/domain/agent-lifecycle/policies/spawn-gate.ts
+function shouldBypassConcurrentLimit(spawnReason) {
+  return spawnReason.startsWith("user.") || spawnReason === "platform.crash_recovery";
+}
+
 // src/domain/agent-lifecycle/index.ts
 var init_agent_lifecycle = __esm(() => {
   init_decide_resume_path();
+  init_restart_decision();
 });
 
 // src/domain/agent-lifecycle/policies/append-recent-log-line.ts
@@ -88158,6 +88631,90 @@ class RapidResumeTracker {
 }
 var RAPID_RESUME_WINDOW_MS = 30000, RAPID_RESUME_THRESHOLD = 5;
 
+// src/infrastructure/services/agent-lifecycle/agent-lifecycle-port-adapters.ts
+function createSpawnPort(spawning) {
+  return {
+    shouldAllowSpawn: (chatroomId, reason, options) => spawning.shouldAllowSpawn(chatroomId, reason, options),
+    recordSpawn: (chatroomId) => exports_Effect.sync(() => {
+      spawning.recordSpawn(chatroomId);
+    }),
+    recordExit: (chatroomId) => exports_Effect.sync(() => {
+      spawning.recordExit(chatroomId);
+    })
+  };
+}
+function createHarnessSpawnPort(deps) {
+  return {
+    spawn: (args2) => exports_Effect.tryPromise({
+      try: async () => {
+        const service3 = deps.agentServices.get(args2.harness);
+        if (!service3) {
+          throw new Error(`Unknown agent harness: ${args2.harness}`);
+        }
+        const result = await service3.spawn({
+          workingDir: args2.workingDir,
+          prompt: args2.prompt,
+          systemPrompt: args2.systemPrompt ?? "",
+          model: args2.model,
+          context: {
+            machineId: deps.machineId,
+            chatroomId: args2.chatroomId,
+            role: args2.role
+          }
+        });
+        return {
+          pid: result.pid,
+          harnessSessionId: result.harnessSessionId,
+          onAgentEnd: (cb) => {
+            result.onAgentEnd?.(cb);
+          },
+          onLogLine: result.onLogLine ? (lineCb) => {
+            result.onLogLine?.((line) => {
+              lineCb(line);
+            });
+          } : undefined
+        };
+      },
+      catch: (e) => e instanceof Error ? e : new Error(String(e))
+    }),
+    stop: (pid, opts) => exports_Effect.tryPromise({
+      try: async () => {
+        for (const service3 of deps.agentServices.values()) {
+          try {
+            await service3.stop(pid, opts);
+            return;
+          } catch {}
+        }
+      },
+      catch: (e) => e instanceof Error ? e : new Error(String(e))
+    }),
+    isAlive: (pid) => exports_Effect.sync(() => {
+      return isProcessAlive((p) => process.kill(p, 0), pid);
+    })
+  };
+}
+function createAgentLifecyclePorts(deps) {
+  return {
+    spawn: createSpawnPort(deps.spawning),
+    harness: createHarnessSpawnPort(deps),
+    sessionId: deps.sessionId,
+    machineId: deps.machineId
+  };
+}
+var init_agent_lifecycle_port_adapters = __esm(() => {
+  init_esm();
+});
+
+// src/infrastructure/services/agent-lifecycle/agent-lifecycle-types.ts
+var AgentLifecyclePorts, AgentLifecycleService;
+var init_agent_lifecycle_types = __esm(() => {
+  init_esm();
+  AgentLifecyclePorts = class AgentLifecyclePorts extends exports_Context.Tag("AgentLifecyclePorts")() {
+  };
+  AgentLifecycleService = class AgentLifecycleService extends exports_Context.Tag("AgentLifecycleService")() {
+  };
+});
+
 // src/infrastructure/services/remote-agents/spawn-prompt.ts
 function createSpawnPrompt(raw) {
   const trimmed = raw?.trim();
@@ -88165,8 +88722,264 @@ function createSpawnPrompt(raw) {
 }
 var DEFAULT_TRIGGER_PROMPT = "Please read your system prompt carefully and follow the Getting Started instructions.";
 
+// src/infrastructure/services/agent-lifecycle/agent-lifecycle-service.ts
+var AgentLifecycleServiceLive;
+var init_agent_lifecycle_service = __esm(() => {
+  init_esm();
+  init_agent_lifecycle_types();
+  init_agent_lifecycle();
+  AgentLifecycleServiceLive = exports_Layer.effect(AgentLifecycleService, exports_Effect.gen(function* () {
+    const ports = yield* AgentLifecyclePorts;
+    const slotsRef = yield* exports_Ref.make(new Map);
+    const getSlotFromRef = (key) => exports_Ref.get(slotsRef).pipe(exports_Effect.map((map18) => map18.get(key)));
+    const setSlotInRef = (key, slot) => exports_Ref.update(slotsRef, (map18) => map18.set(key, slot));
+    const removeSlotFromRef = (key) => exports_Ref.update(slotsRef, (map18) => {
+      const next4 = new Map(map18);
+      next4.delete(key);
+      return next4;
+    });
+    const spawnAndRegister = (key, opts) => exports_Effect.gen(function* () {
+      let slot = {
+        ...idleSlot(),
+        harness: opts.agentHarness,
+        model: opts.model,
+        workingDir: opts.workingDir,
+        wantResume: opts.wantResume,
+        _initPrompt: opts.initPrompt ?? "",
+        _systemPrompt: opts.systemPrompt
+      };
+      const startedResult = transitionSlot(slot, {
+        type: "spawn_started",
+        operationKey: opts.reason
+      });
+      if (!startedResult.ok) {
+        return { success: false, error: "spawn_failed" };
+      }
+      slot = startedResult.slot;
+      const spawnHandle = yield* ports.harness.spawn({
+        harness: opts.agentHarness,
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        workingDir: opts.workingDir,
+        model: opts.model,
+        prompt: createSpawnPrompt(opts.initPrompt),
+        systemPrompt: opts.systemPrompt
+      }).pipe(exports_Effect.catchAll(() => exports_Effect.succeed(null)));
+      if (!spawnHandle) {
+        return { success: false, error: "spawn_failed" };
+      }
+      const succeededResult = transitionSlot(slot, {
+        type: "spawn_succeeded",
+        pid: spawnHandle.pid
+      });
+      if (!succeededResult.ok) {
+        return { success: false, error: "spawn_failed" };
+      }
+      slot = succeededResult.slot;
+      yield* ports.spawn.recordSpawn(opts.chatroomId);
+      yield* setSlotInRef(key, slot);
+      if (spawnHandle) {
+        spawnHandle.onAgentEnd(() => {});
+      }
+      if (spawnHandle && spawnHandle.harnessSessionId) {
+        const updatedSlot = { ...slot, harnessSessionId: spawnHandle.harnessSessionId };
+        yield* setSlotInRef(key, updatedSlot);
+      }
+      return { success: true, pid: slot.pid };
+    });
+    const ensureRunning = (opts) => exports_Effect.gen(function* () {
+      const key = agentKey2(opts.chatroomId, opts.role);
+      const currentSlot = yield* getSlotFromRef(key);
+      if (currentSlot && currentSlot.state !== "idle") {
+        return {
+          success: true,
+          pid: currentSlot.pid
+        };
+      }
+      const bypass = shouldBypassConcurrentLimit(opts.reason);
+      const allowResult = ports.spawn.shouldAllowSpawn(opts.chatroomId, opts.reason, bypass ? { bypassConcurrentLimit: true } : undefined);
+      if (!allowResult.allowed) {
+        const error = allowResult.retryAfterMs ? "rate_limited" : "backoff";
+        return { success: false, error };
+      }
+      const result = yield* spawnAndRegister(key, opts);
+      if (!result.success && result.error) {
+        yield* exports_Effect.logError(`Agent spawn failed for ${key}: ${result.error}`);
+      }
+      return result;
+    });
+    const stop4 = (opts) => exports_Effect.gen(function* () {
+      const key = agentKey2(opts.chatroomId, opts.role);
+      const slot = yield* getSlotFromRef(key);
+      if (!slot) {
+        return { success: false };
+      }
+      const stoppingResult = transitionSlot(slot, {
+        type: "stop_requested",
+        operationKey: opts.reason
+      });
+      if (!stoppingResult.ok) {
+        return { success: false };
+      }
+      const stoppingSlot = stoppingResult.slot;
+      yield* setSlotInRef(key, stoppingSlot);
+      if (stoppingSlot.pid) {
+        yield* ports.harness.stop(stoppingSlot.pid, { preserveForResume: false }).pipe(exports_Effect.ignore);
+      }
+      yield* ports.spawn.recordExit(opts.chatroomId);
+      const completedResult = transitionSlot(stoppingSlot, {
+        type: "stop_completed"
+      });
+      if (completedResult.ok) {
+        yield* setSlotInRef(key, completedResult.slot);
+      }
+      return { success: true };
+    });
+    const executeRestart = (slot, chatroomId, role) => exports_Effect.gen(function* () {
+      const restartOutcome = decideRestartAfterExit({
+        stopReason: resolveStopReason(slot._stopReasonCode ?? 0, slot._stopReasonSignal ?? null),
+        harness: slot.harness,
+        workingDir: slot.workingDir,
+        wantResume: slot.wantResume ?? false,
+        isPermanentFailure: false,
+        restartAllowed: true
+      });
+      yield* dispatchRestartOutcome(restartOutcome, slot, chatroomId, role);
+    });
+    const dispatchRestartOutcome = (outcome, slot, chatroomId, role) => exports_Effect.gen(function* () {
+      switch (outcome._tag) {
+        case "RestartNow": {
+          yield* handleRestartNow(slot, chatroomId, role, outcome);
+          break;
+        }
+        case "ScheduleRetry": {
+          yield* handleScheduleRetry(slot, chatroomId, role, outcome);
+          break;
+        }
+        case "NoRestart": {
+          break;
+        }
+      }
+    });
+    const handleRestartNow = (slot, chatroomId, role, outcome) => exports_Effect.gen(function* () {
+      if (!slot.harness) {
+        yield* exports_Effect.logError(`Agent restart failed for ${chatroomId}:${role}: missing harness`);
+        return;
+      }
+      const restartResult = yield* ensureRunning({
+        chatroomId,
+        role,
+        agentHarness: slot.harness,
+        workingDir: slot.workingDir ?? "",
+        reason: outcome.spawnReason,
+        wantResume: outcome.wantResume,
+        initPrompt: slot._initPrompt,
+        systemPrompt: slot._systemPrompt
+      });
+      if (!restartResult.success && restartResult.error) {
+        yield* exports_Effect.logError(`Agent restart failed for ${chatroomId}:${role}: ${restartResult.error}`);
+      }
+    });
+    const handleScheduleRetry = (slot, chatroomId, role, outcome) => exports_Effect.gen(function* () {
+      if (!slot.harness) {
+        yield* exports_Effect.logError(`Agent restart failed for ${chatroomId}:${role}: missing harness`);
+        return;
+      }
+      yield* exports_Effect.forkDaemon(exports_Effect.sleep(exports_Duration.millis(outcome.waitMs)).pipe(exports_Effect.as(ensureRunning({
+        chatroomId,
+        role,
+        agentHarness: slot.harness,
+        workingDir: slot.workingDir ?? "",
+        reason: outcome.spawnReason,
+        wantResume: outcome.wantResume,
+        initPrompt: slot._initPrompt,
+        systemPrompt: slot._systemPrompt
+      }))));
+    });
+    const handleExit = (opts) => exports_Effect.gen(function* () {
+      const key = agentKey2(opts.chatroomId, opts.role);
+      const slot = yield* getSlotFromRef(key);
+      if (!slot) {
+        return;
+      }
+      if (shouldIgnoreProcessExit(slot, opts.pid)) {
+        return;
+      }
+      const stopReason = resolveStopReason(opts.code, opts.signal);
+      const transitionResult = transitionSlot(slot, {
+        type: "process_exited",
+        pid: opts.pid
+      });
+      if (!transitionResult.ok) {
+        return;
+      }
+      const exitedSlot = {
+        ...transitionResult.slot,
+        _stopReasonCode: opts.code,
+        _stopReasonSignal: opts.signal,
+        harness: slot.harness,
+        workingDir: slot.workingDir,
+        wantResume: slot.wantResume,
+        _initPrompt: slot._initPrompt,
+        _systemPrompt: slot._systemPrompt
+      };
+      yield* setSlotInRef(key, exitedSlot);
+      yield* executeRestart(exitedSlot, opts.chatroomId, opts.role);
+      const restartOutcome = decideRestartAfterExit({
+        stopReason,
+        harness: slot.harness,
+        workingDir: slot.workingDir,
+        wantResume: slot.wantResume ?? false,
+        isPermanentFailure: false,
+        restartAllowed: true
+      });
+      if (restartOutcome._tag === "NoRestart") {
+        yield* removeSlotFromRef(key);
+      }
+      yield* ports.spawn.recordExit(opts.chatroomId);
+    });
+    const getSlot = (chatroomId, role) => getSlotFromRef(agentKey2(chatroomId, role));
+    const listActive = () => exports_Ref.get(slotsRef).pipe(exports_Effect.map((map18) => {
+      const results = [];
+      for (const [key, slot] of map18) {
+        if (slot.state !== "idle") {
+          const [chatroomId, role] = key.split(":");
+          results.push({ chatroomId, role, slot });
+        }
+      }
+      return results;
+    }));
+    return {
+      ensureRunning,
+      stop: stop4,
+      handleExit,
+      getSlot,
+      listActive
+    };
+  }));
+});
+
+// src/infrastructure/services/agent-lifecycle/agent-lifecycle-runtime.ts
+function createAgentLifecycleRuntime(deps) {
+  const layer = exports_Layer.provide(AgentLifecycleServiceLive, exports_Layer.succeed(AgentLifecyclePorts, createAgentLifecyclePorts(deps)));
+  const runtime4 = exports_ManagedRuntime.make(layer);
+  return {
+    runtime: runtime4,
+    runPromise(effect2) {
+      return runtime4.runPromise(effect2);
+    },
+    dispose: () => runtime4.dispose()
+  };
+}
+var init_agent_lifecycle_runtime = __esm(() => {
+  init_esm();
+  init_agent_lifecycle_port_adapters();
+  init_agent_lifecycle_service();
+  init_agent_lifecycle_types();
+});
+
 // src/infrastructure/services/agent-process-manager/agent-process-manager.ts
-function agentKey2(chatroomId, role) {
+function agentKey3(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
 }
 
@@ -88177,17 +88990,47 @@ class AgentProcessManager {
   exitRetryQueue = [];
   exitRetryTimer = null;
   turnEndQueue = new TurnEndQueue;
+  lifecycle;
   constructor(deps) {
     this.deps = {
       ...deps,
       resumeStormTracker: deps.resumeStormTracker ?? new RapidResumeTracker
     };
+    const portAdapterDeps = {
+      spawning: this.deps.spawning,
+      agentServices: this.deps.agentServices,
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      onAgentEnd: (args2) => void this.runHandleAgentEnd(args2)
+    };
+    this.lifecycle = createAgentLifecycleRuntime(portAdapterDeps);
+  }
+  updateSlotsMirror(chatroomId, role, slot) {
+    const key = agentKey3(chatroomId, role);
+    const existing = this.slots.get(key);
+    if (!existing || existing.state !== slot.state || existing.pid !== slot.pid) {
+      this.slots.set(key, {
+        state: slot.state,
+        pid: slot.pid,
+        harness: slot.harness,
+        harnessSessionId: slot.harnessSessionId,
+        model: slot.model,
+        workingDir: slot.workingDir,
+        startedAt: slot.startedAt,
+        resumeInFlight: slot.resumeInFlight,
+        recentLogLines: slot.recentLogLines,
+        wantResume: slot.wantResume
+      });
+    }
+  }
+  getSlotFromMirror(chatroomId, role) {
+    return this.slots.get(agentKey3(chatroomId, role));
   }
-  async whenTurnEndsIdle() {
-    await this.turnEndQueue.whenIdle();
+  whenTurnEndsIdle() {
+    return this.turnEndQueue.whenIdle();
   }
   async ensureRunning(opts) {
-    const key = agentKey2(opts.chatroomId, opts.role);
+    const key = agentKey3(opts.chatroomId, opts.role);
     const slot = this.getOrCreateSlot(key);
     if (slot.state === "running" && slot.pid && !isProcessAlive(this.deps.processes.kill, slot.pid)) {
       slot.state = "idle";
@@ -88211,30 +89054,21 @@ class AgentProcessManager {
     return operation;
   }
   async stop(opts) {
-    const key = agentKey2(opts.chatroomId, opts.role);
+    const key = agentKey3(opts.chatroomId, opts.role);
     const slot = this.slots.get(key);
+    const earlyResult = await this.handleStopEarlyReturns(slot, opts, key);
+    if (earlyResult) {
+      return earlyResult;
+    }
+    const actualSlot = slot;
+    if (actualSlot.pendingOperation) {
+      await actualSlot.pendingOperation;
+    }
+    return { success: true };
+  }
+  async handleStopEarlyReturns(slot, opts, key) {
     if (!slot || slot.state === "idle") {
-      const eventPid = opts.pid;
-      if (eventPid && eventPid > 0) {
-        try {
-          this.deps.processes.kill(eventPid, "SIGTERM");
-        } catch {}
-      }
-      const exitArgs1 = {
-        sessionId: this.deps.sessionId,
-        machineId: this.deps.machineId,
-        chatroomId: opts.chatroomId,
-        role: opts.role,
-        pid: eventPid ?? 0,
-        stopReason: opts.reason,
-        exitCode: undefined,
-        signal: undefined,
-        agentHarness: undefined
-      };
-      this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs1).catch((err) => {
-        console.log(`   ⚠️  Failed to record agent exit (idle cleanup): ${err.message}`);
-        this.queueExitRetry({ role: opts.role, args: exitArgs1 });
-      });
+      await this.killAndRecordForIdleSlot(slot, opts);
       return { success: true };
     }
     if (slot.state === "stopping" && slot.pendingOperation) {
@@ -88250,14 +89084,48 @@ class AgentProcessManager {
     slot.state = "stopping";
     const operation = this.doStop(key, slot, pid, opts);
     slot.pendingOperation = operation;
-    await operation;
-    return { success: true };
+    return null;
+  }
+  async killAndRecordForIdleSlot(slot, opts) {
+    const eventPid = opts.pid;
+    if (eventPid && eventPid > 0) {
+      try {
+        this.deps.processes.kill(eventPid, "SIGTERM");
+      } catch {}
+    }
+    const exitArgs1 = {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      pid: eventPid ?? 0,
+      stopReason: opts.reason,
+      exitCode: undefined,
+      signal: undefined,
+      agentHarness: undefined
+    };
+    this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs1).catch((err) => {
+      console.log(`   ⚠️  Failed to record agent exit (idle cleanup): ${err.message}`);
+      this.queueExitRetry({ role: opts.role, args: exitArgs1 });
+    });
   }
   async runHandleAgentEnd(opts) {
-    const slot = this.slots.get(agentKey2(opts.chatroomId, opts.role));
+    const slot = this.slots.get(agentKey3(opts.chatroomId, opts.role));
     const service3 = this.deps.agentServices.get(opts.harness);
     const capabilities = getHarnessCapabilities(opts.harness);
     const supportsSessionResume = capabilities.supportsSessionResume && typeof service3?.resumeTurn === "function";
+    this.updateSlotsMirror(opts.chatroomId, opts.role, {
+      state: slot?.state ?? "idle",
+      pid: slot?.pid,
+      harness: slot?.harness,
+      harnessSessionId: slot?.harnessSessionId,
+      model: slot?.model,
+      workingDir: slot?.workingDir,
+      startedAt: slot?.startedAt,
+      resumeInFlight: slot?.resumeInFlight,
+      recentLogLines: slot?.recentLogLines,
+      wantResume: slot?.wantResume
+    });
     console.log(`[AgentProcessManager] lifecycle.turn.completed: role=${opts.role} pid=${opts.pid} harness=${opts.harness} supportsResume=${supportsSessionResume}`);
     const result = await handleTurnCompleted({
       resumeStormTracker: this.deps.resumeStormTracker,
@@ -88296,37 +89164,76 @@ class AgentProcessManager {
     }
   }
   async handleExit(opts) {
-    const key = agentKey2(opts.chatroomId, opts.role);
+    const key = agentKey3(opts.chatroomId, opts.role);
     const slot = this.slots.get(key);
-    if (!slot || slot.pid !== opts.pid) {
-      return;
-    }
-    if (slot.state === "stopping") {
+    if (!slot || slot.pid !== opts.pid || slot.state === "stopping") {
       return;
     }
     const stopReason = resolveStopReason(opts.code, opts.signal);
     this.deps.spawning.recordExit(opts.chatroomId);
-    const harness = slot.harness;
-    const model = slot.model;
-    const workingDir = slot.workingDir;
-    const harnessSessionId = slot.harnessSessionId;
-    const wantResume = slot.wantResume;
-    const recentLogLines = slot.recentLogLines;
-    if (harness && harnessSessionId && getHarnessCapabilities(harness).supportsSessionResume && shouldRetainHarnessSessionForReconnect(stopReason)) {
-      const service3 = this.deps.agentServices.get(harness);
-      const harnessMeta = service3 ? this.readHarnessReconnectMetadata(service3, opts.pid) : undefined;
-      this.recordLastHarnessSession(key, {
-        harnessSessionId,
-        harness,
-        agentName: harnessMeta?.agentName ?? "",
-        workingDir: workingDir ?? "",
-        model: model ?? harnessMeta?.model
+    const ctx = this.captureExitContext(slot, opts, stopReason);
+    await this.preserveHarnessSessionOnExit(key, slot, ctx);
+    const lifecyclePromise = this.lifecycle.runPromise(exports_Effect.gen(function* () {
+      const svc = yield* AgentLifecycleService;
+      yield* svc.handleExit({
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        pid: opts.pid,
+        code: opts.code,
+        signal: opts.signal
       });
+    }));
+    this.resetSlotAfterExit(slot);
+    await this.emitExitEvent(slot, opts, ctx);
+    try {
+      await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
+    } catch {}
+    this.untrackAllServices(opts.pid);
+    lifecyclePromise.then(() => this.dispatchRestartAfterExit(opts, ctx, key)).catch(() => {});
+  }
+  captureExitContext(slot, opts, stopReason) {
+    return {
+      harness: slot.harness,
+      model: slot.model,
+      workingDir: slot.workingDir,
+      harnessSessionId: slot.harnessSessionId,
+      wantResume: slot.wantResume,
+      recentLogLines: slot.recentLogLines,
+      stopReason
+    };
+  }
+  recordExitHarnessSession(key, slot, harness, harnessSessionId, ctx) {
+    const service3 = this.deps.agentServices.get(harness);
+    const harnessMeta = service3 && slot.pid ? this.readHarnessReconnectMetadata(service3, slot.pid) : undefined;
+    this.recordLastHarnessSession(key, {
+      harnessSessionId,
+      harness,
+      agentName: harnessMeta?.agentName ?? "",
+      workingDir: ctx.workingDir ?? "",
+      model: ctx.model ?? harnessMeta?.model
+    });
+  }
+  async preserveHarnessSessionOnExit(key, slot, ctx) {
+    const { harness, harnessSessionId, stopReason } = ctx;
+    if (!harness || !harnessSessionId) {
+      return;
     }
+    if (!getHarnessCapabilities(harness).supportsSessionResume) {
+      return;
+    }
+    if (!shouldRetainHarnessSessionForReconnect(stopReason)) {
+      return;
+    }
+    this.recordExitHarnessSession(key, slot, harness, harnessSessionId, ctx);
+  }
+  resetSlotAfterExit(slot) {
     slot.state = "idle";
     slot.pid = undefined;
     slot.startedAt = undefined;
     slot.pendingOperation = undefined;
+  }
+  async emitExitEvent(slot, opts, ctx) {
+    const stopReason = ctx.stopReason;
     const exitArgs2 = {
       sessionId: this.deps.sessionId,
       machineId: this.deps.machineId,
@@ -88337,42 +89244,36 @@ class AgentProcessManager {
       stopSignal: stopReason === "agent_process.signal" ? opts.signal ?? undefined : undefined,
       exitCode: opts.code ?? undefined,
       signal: opts.signal ?? undefined,
-      agentHarness: harness
+      agentHarness: ctx.harness
     };
     this.deps.backend.mutation(api.machines.recordAgentExited, exitArgs2).catch((err) => {
       console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
       this.queueExitRetry({ role: opts.role, args: exitArgs2 });
     });
-    try {
-      await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
-    } catch {}
+  }
+  untrackAllServices(pid) {
     for (const service3 of this.deps.agentServices.values()) {
-      service3.untrack(opts.pid);
+      service3.untrack(pid);
     }
-    if (!shouldAutoRestartAfterProcessExit(stopReason)) {
-      if (stopReason === "user.stop" || stopReason === "platform.team_switch" || stopReason === "daemon.shutdown") {
+  }
+  dispatchRestartAfterExit(opts, ctx, _key) {
+    const stopReasonForRestart = resolveStopReason(opts.code, opts.signal);
+    if (!shouldAutoRestartAfterProcessExit(stopReasonForRestart)) {
+      if (stopReasonForRestart === "user.stop" || stopReasonForRestart === "platform.team_switch" || stopReasonForRestart === "daemon.shutdown") {
         this.deps.crashLoop.clear(opts.chatroomId, opts.role);
       }
       return;
     }
+    this.maybeRestartAgent(opts, ctx);
+  }
+  maybeRestartAgent(opts, ctx) {
+    const { harness, model, workingDir, recentLogLines } = ctx;
     if (!harness || !workingDir) {
       console.log(`[AgentProcessManager] ⚠️  Cannot restart — missing harness or workingDir ` + `(role: ${opts.role}, harness: ${harness ?? "none"}, workingDir: ${workingDir ?? "none"})`);
       return;
     }
     if (isPermanentHarnessFailure(recentLogLines ?? [])) {
-      const error = formatPermanentHarnessFailureMessage(recentLogLines ?? []);
-      console.log(`[AgentProcessManager] ⛔ Skipping restart — ${error}`);
-      this.deps.crashLoop.clear(opts.chatroomId, opts.role);
-      this.clearLastHarnessSession(key);
-      this.deps.backend.mutation(api.machines.emitAgentStartFailed, {
-        sessionId: this.deps.sessionId,
-        machineId: this.deps.machineId,
-        chatroomId: opts.chatroomId,
-        role: opts.role,
-        error
-      }).catch((emitErr) => {
-        console.log(`   ⚠️  Failed to emit startFailed event: ${emitErr.message}`);
-      });
+      this.handlePermanentFailureForRestart(opts, recentLogLines);
       return;
     }
     this.ensureRunning({
@@ -88382,22 +89283,39 @@ class AgentProcessManager {
       model,
       workingDir,
       reason: "platform.crash_recovery",
-      wantResume: wantResume ?? true
+      wantResume: ctx.wantResume ?? true
     }).catch((err) => {
       console.log(`   ⚠️  Failed to restart agent: ${err.message}`);
-      this.deps.backend.mutation(api.machines.emitAgentStartFailed, {
-        sessionId: this.deps.sessionId,
-        machineId: this.deps.machineId,
-        chatroomId: opts.chatroomId,
-        role: opts.role,
-        error: err.message
-      }).catch((emitErr) => {
-        console.log(`   ⚠️  Failed to emit startFailed event: ${emitErr.message}`);
-      });
+      this.emitStartFailedEvent(opts.role, opts.chatroomId, err.message);
     });
   }
+  handlePermanentFailureForRestart(opts, recentLogLines) {
+    const error = formatPermanentHarnessFailureMessage(recentLogLines ?? []);
+    console.log(`[AgentProcessManager] ⛔ Skipping restart — ${error}`);
+    this.deps.crashLoop.clear(opts.chatroomId, opts.role);
+    const key = agentKey3(opts.chatroomId, opts.role);
+    this.clearLastHarnessSession(key);
+    this.deps.backend.mutation(api.machines.emitAgentStartFailed, {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      error
+    }).catch((emitErr) => {
+      console.log(`   ⚠️  Failed to emit startFailed event: ${emitErr.message}`);
+    });
+  }
+  emitStartFailedEvent(role, chatroomId, error) {
+    this.deps.backend.mutation(api.machines.emitAgentStartFailed, {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId,
+      role,
+      error
+    }).catch(() => {});
+  }
   getSlot(chatroomId, role) {
-    return this.slots.get(agentKey2(chatroomId, role));
+    return this.getSlotFromMirror(chatroomId, role);
   }
   listActive() {
     const result = [];
@@ -88468,13 +89386,19 @@ class AgentProcessManager {
     untrackChildPid(pid);
   }
   async killExistingBeforeSpawn(chatroomId, role) {
-    const key = agentKey2(chatroomId, role);
+    const key = agentKey3(chatroomId, role);
+    await this.killInMemorySlotIfAlive(key, chatroomId, role);
+    await this.killPersistedProcessIfAlive(chatroomId, role);
+  }
+  async killInMemorySlotIfAlive(key, chatroomId, role) {
     const slot = this.slots.get(key);
     if (slot?.pid && isProcessAlive(this.deps.processes.kill, slot.pid) && (slot.state === "running" || slot.state === "spawning")) {
-      const pid2 = slot.pid;
+      const pid = slot.pid;
       slot.state = "stopping";
-      await this.doStop(key, slot, pid2, { chatroomId, role, reason: "daemon.respawn" });
+      await this.doStop(key, slot, pid, { chatroomId, role, reason: "daemon.respawn" });
     }
+  }
+  async killPersistedProcessIfAlive(chatroomId, role) {
     let entries2 = [];
     try {
       entries2 = await this.deps.persistence.listAgentEntries(this.deps.machineId);
@@ -88487,11 +89411,10 @@ class AgentProcessManager {
     }
     const { pid, harness } = persisted.entry;
     if (!isProcessAlive(this.deps.processes.kill, pid)) {
-      try {
-        await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
-      } catch {}
+      await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role).catch(() => {});
       return;
     }
+    const key = agentKey3(chatroomId, role);
     const currentSlot = this.slots.get(key);
     if (currentSlot?.pid === pid && currentSlot.state !== "idle") {
       return;
@@ -88574,30 +89497,20 @@ class AgentProcessManager {
     }
   }
   async tryDaemonMemoryResume(opts) {
-    const capabilities = getHarnessCapabilities(opts.agentHarness);
-    if (!capabilities.supportsSessionResume) {
+    const validationResult = this.validateDaemonMemoryResumePreconditions(opts);
+    if (validationResult) {
       return null;
     }
     const stored = this.lastHarnessSessions.get(opts.key);
     if (!stored) {
       return null;
     }
-    if (stored.workingDir !== opts.workingDir) {
-      this.clearLastHarnessSession(opts.key);
-      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, "working directory changed", stored.harnessSessionId);
-      return null;
-    }
-    if (stored.harness !== opts.agentHarness || !stored.agentName) {
-      this.clearLastHarnessSession(opts.key);
-      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, stored.harness !== opts.agentHarness ? "harness changed" : "incomplete session in daemon memory", stored.harnessSessionId);
-      return null;
-    }
-    if (!opts.service.resumeFromDaemonMemory) {
-      await this.emitSessionResumeFailed(opts.chatroomId, opts.role, "daemon-memory session resume not yet supported", stored.harnessSessionId);
+    const resumeFromDaemonMemory = opts.service.resumeFromDaemonMemory;
+    if (!resumeFromDaemonMemory) {
       return null;
     }
     try {
-      const spawnResult = await opts.service.resumeFromDaemonMemory({
+      const spawnResult = await resumeFromDaemonMemory({
         workingDir: stored.workingDir,
         prompt: createSpawnPrompt(opts.initPrompt),
         systemPrompt: opts.systemPrompt,
@@ -88621,6 +89534,31 @@ class AgentProcessManager {
       return null;
     }
   }
+  validateDaemonMemoryResumePreconditions(opts) {
+    const capabilities = getHarnessCapabilities(opts.agentHarness);
+    if (!capabilities.supportsSessionResume) {
+      return null;
+    }
+    const stored = this.lastHarnessSessions.get(opts.key);
+    if (!stored) {
+      return null;
+    }
+    if (stored.workingDir !== opts.workingDir) {
+      this.clearLastHarnessSession(opts.key);
+      this.emitSessionResumeFailed(opts.chatroomId, opts.role, "working directory changed", stored.harnessSessionId);
+      return "working directory changed";
+    }
+    if (stored.harness !== opts.agentHarness || !stored.agentName) {
+      this.clearLastHarnessSession(opts.key);
+      this.emitSessionResumeFailed(opts.chatroomId, opts.role, stored.harness !== opts.agentHarness ? "harness changed" : "incomplete session in daemon memory", stored.harnessSessionId);
+      return "validation failed";
+    }
+    if (!opts.service.resumeFromDaemonMemory) {
+      this.emitSessionResumeFailed(opts.chatroomId, opts.role, "daemon-memory session resume not yet supported", stored.harnessSessionId);
+      return "not supported";
+    }
+    return null;
+  }
   async emitSessionResumed(chatroomId, role, harnessSessionId) {
     try {
       await this.deps.backend.mutation(api.machines.emitSessionResumed, {
@@ -88650,195 +89588,248 @@ class AgentProcessManager {
       console.log(`   ⚠️  Failed to emit sessionResumeFailed event: ${err.message}`);
     }
   }
-  async doEnsureRunning(key, slot, opts) {
-    slot.state = "spawning";
-    const wantResume = opts.wantResume;
-    console.log(`[AgentProcessManager] harness start: role=${opts.role} harness=${opts.agentHarness} wantResume=${wantResume} reason=${opts.reason}`);
+  resetSlotIdle(slot) {
+    slot.state = "idle";
+    slot.pendingOperation = undefined;
+  }
+  checkRateLimitGate(opts, slot) {
+    const spawnCheck = this.deps.spawning.shouldAllowSpawn(opts.chatroomId, opts.reason, {
+      bypassConcurrentLimit: opts.reason.startsWith("user.")
+    });
+    if (!spawnCheck.allowed) {
+      this.resetSlotIdle(slot);
+      return { success: false, error: "rate_limited" };
+    }
+    return null;
+  }
+  checkCrashLoopGate(opts, slot) {
+    if (opts.reason !== "platform.crash_recovery") {
+      return null;
+    }
+    const loopCheck = this.deps.crashLoop.record(opts.chatroomId, opts.role, this.deps.clock.now());
+    if (loopCheck.allowed) {
+      return null;
+    }
+    if (loopCheck.waitMs !== undefined && loopCheck.waitMs > 0) {
+      console.log(`   ⏳ Agent restart backoff: waiting ${loopCheck.waitMs}ms before retry`);
+      this.resetSlotIdle(slot);
+      return { success: false, error: "backoff" };
+    }
+    this.deps.backend.mutation(api.machines.emitRestartLimitReached, {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      restartCount: loopCheck.restartCount,
+      windowMs: loopCheck.windowMs
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to emit restartLimitReached event: ${err.message}`);
+    });
+    this.resetSlotIdle(slot);
+    return { success: false, error: "crash_loop" };
+  }
+  async validateWorkingDirGate(opts, slot) {
+    try {
+      const dirStat = await this.deps.fs.stat(opts.workingDir);
+      if (!dirStat.isDirectory()) {
+        this.resetSlotIdle(slot);
+        return {
+          success: false,
+          error: `Working directory is not a directory: ${opts.workingDir}`
+        };
+      }
+    } catch {
+      this.resetSlotIdle(slot);
+      return { success: false, error: `Working directory does not exist: ${opts.workingDir}` };
+    }
+    return null;
+  }
+  async fetchInitPromptResult(opts, slot) {
+    let initPromptResult;
     try {
-      const spawnCheck = this.deps.spawning.shouldAllowSpawn(opts.chatroomId, opts.reason, {
-        bypassConcurrentLimit: opts.reason.startsWith("user.")
+      initPromptResult = await this.deps.backend.query(api.messages.getInitPrompt, {
+        sessionId: this.deps.sessionId,
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        convexUrl: this.deps.convexUrl
       });
-      if (!spawnCheck.allowed) {
-        slot.state = "idle";
-        slot.pendingOperation = undefined;
-        return { success: false, error: "rate_limited" };
-      }
-      if (opts.reason === "platform.crash_recovery") {
-        const loopCheck = this.deps.crashLoop.record(opts.chatroomId, opts.role, this.deps.clock.now());
-        if (!loopCheck.allowed) {
-          if (loopCheck.waitMs !== undefined && loopCheck.waitMs > 0) {
-            console.log(`   ⏳ Agent restart backoff: waiting ${loopCheck.waitMs}ms before retry`);
-            slot.state = "idle";
-            slot.pendingOperation = undefined;
-            return { success: false, error: "backoff" };
-          }
-          this.deps.backend.mutation(api.machines.emitRestartLimitReached, {
-            sessionId: this.deps.sessionId,
+    } catch (e) {
+      this.resetSlotIdle(slot);
+      return {
+        ok: false,
+        result: { success: false, error: `Failed to fetch init prompt: ${e.message}` }
+      };
+    }
+    if (!initPromptResult?.prompt) {
+      this.resetSlotIdle(slot);
+      return {
+        ok: false,
+        result: { success: false, error: "Failed to fetch init prompt from backend" }
+      };
+    }
+    return {
+      ok: true,
+      initialMessage: initPromptResult.initialMessage,
+      rolePrompt: initPromptResult.rolePrompt
+    };
+  }
+  async spawnAgentForEnsureRunning(key, slot, opts, initPrompt, wantResume) {
+    const service3 = this.deps.agentServices.get(opts.agentHarness);
+    if (!service3) {
+      this.resetSlotIdle(slot);
+      return {
+        ok: false,
+        result: { success: false, error: `Unknown agent harness: ${opts.agentHarness}` }
+      };
+    }
+    let spawnResult;
+    const resumePath = decideResumePathOnRestart({
+      supportsSessionResume: getHarnessCapabilities(opts.agentHarness).supportsSessionResume,
+      wantResume,
+      hasStoredSnapshot: this.lastHarnessSessions.has(key)
+    });
+    if (resumePath === "daemon_memory") {
+      spawnResult = await this.tryDaemonMemoryResume({
+        key,
+        chatroomId: opts.chatroomId,
+        role: opts.role,
+        agentHarness: opts.agentHarness,
+        workingDir: opts.workingDir,
+        model: opts.model,
+        initPrompt: initPrompt.initialMessage,
+        systemPrompt: initPrompt.rolePrompt,
+        service: service3
+      }) ?? undefined;
+    }
+    if (!spawnResult) {
+      try {
+        spawnResult = await service3.spawn({
+          workingDir: opts.workingDir,
+          prompt: createSpawnPrompt(initPrompt.initialMessage),
+          systemPrompt: initPrompt.rolePrompt,
+          model: opts.model,
+          context: {
             machineId: this.deps.machineId,
             chatroomId: opts.chatroomId,
-            role: opts.role,
-            restartCount: loopCheck.restartCount,
-            windowMs: loopCheck.windowMs
-          }).catch((err) => {
-            console.log(`   ⚠️  Failed to emit restartLimitReached event: ${err.message}`);
-          });
-          slot.state = "idle";
-          slot.pendingOperation = undefined;
-          return { success: false, error: "crash_loop" };
-        }
-      }
-      try {
-        const dirStat = await this.deps.fs.stat(opts.workingDir);
-        if (!dirStat.isDirectory()) {
-          slot.state = "idle";
-          slot.pendingOperation = undefined;
-          return {
-            success: false,
-            error: `Working directory is not a directory: ${opts.workingDir}`
-          };
-        }
-      } catch {
-        slot.state = "idle";
-        slot.pendingOperation = undefined;
-        return { success: false, error: `Working directory does not exist: ${opts.workingDir}` };
-      }
-      let initPromptResult;
-      try {
-        initPromptResult = await this.deps.backend.query(api.messages.getInitPrompt, {
-          sessionId: this.deps.sessionId,
-          chatroomId: opts.chatroomId,
-          role: opts.role,
-          convexUrl: this.deps.convexUrl
+            role: opts.role
+          }
         });
       } catch (e) {
-        slot.state = "idle";
-        slot.pendingOperation = undefined;
-        return { success: false, error: `Failed to fetch init prompt: ${e.message}` };
-      }
-      if (!initPromptResult?.prompt) {
-        slot.state = "idle";
-        slot.pendingOperation = undefined;
-        return { success: false, error: "Failed to fetch init prompt from backend" };
-      }
-      const service3 = this.deps.agentServices.get(opts.agentHarness);
-      if (!service3) {
-        slot.state = "idle";
-        slot.pendingOperation = undefined;
-        return { success: false, error: `Unknown agent harness: ${opts.agentHarness}` };
+        this.resetSlotIdle(slot);
+        return {
+          ok: false,
+          result: { success: false, error: `Failed to spawn agent: ${e.message}` }
+        };
       }
-      let spawnResult;
-      const resumePath = decideResumePathOnRestart({
-        supportsSessionResume: getHarnessCapabilities(opts.agentHarness).supportsSessionResume,
-        wantResume,
-        hasStoredSnapshot: this.lastHarnessSessions.has(key)
+    }
+    return { ok: true, spawnResult };
+  }
+  assignRunningSlotState(key, slot, opts, spawnResult, wantResume, pid) {
+    slot.state = "running";
+    slot.pid = pid;
+    slot.harness = opts.agentHarness;
+    slot.harnessSessionId = spawnResult.harnessSessionId;
+    if (spawnResult.harnessSessionId) {
+      this.recordLastHarnessSession(key, {
+        harnessSessionId: spawnResult.harnessSessionId,
+        harness: opts.agentHarness,
+        agentName: spawnResult.harnessReconnect?.agentName ?? "",
+        workingDir: opts.workingDir,
+        model: opts.model ?? spawnResult.harnessReconnect?.model
       });
-      if (resumePath === "daemon_memory") {
-        spawnResult = await this.tryDaemonMemoryResume({
-          key,
-          chatroomId: opts.chatroomId,
-          role: opts.role,
-          agentHarness: opts.agentHarness,
-          workingDir: opts.workingDir,
-          model: opts.model,
-          initPrompt: initPromptResult.initialMessage,
-          systemPrompt: initPromptResult.rolePrompt,
-          service: service3
-        }) ?? undefined;
-      }
-      if (!spawnResult) {
-        try {
-          spawnResult = await service3.spawn({
-            workingDir: opts.workingDir,
-            prompt: createSpawnPrompt(initPromptResult.initialMessage),
-            systemPrompt: initPromptResult.rolePrompt,
-            model: opts.model,
-            context: {
-              machineId: this.deps.machineId,
-              chatroomId: opts.chatroomId,
-              role: opts.role
-            }
-          });
-        } catch (e) {
-          slot.state = "idle";
-          slot.pendingOperation = undefined;
-          return { success: false, error: `Failed to spawn agent: ${e.message}` };
-        }
-      }
-      const { pid } = spawnResult;
-      this.deps.spawning.recordSpawn(opts.chatroomId);
-      slot.state = "running";
-      slot.pid = pid;
-      slot.harness = opts.agentHarness;
-      slot.harnessSessionId = spawnResult.harnessSessionId;
-      if (spawnResult.harnessSessionId) {
-        this.recordLastHarnessSession(key, {
-          harnessSessionId: spawnResult.harnessSessionId,
-          harness: opts.agentHarness,
-          agentName: spawnResult.harnessReconnect?.agentName ?? "",
-          workingDir: opts.workingDir,
-          model: opts.model ?? spawnResult.harnessReconnect?.model
-        });
-      }
-      slot.model = opts.model;
-      slot.wantResume = wantResume;
-      slot.workingDir = opts.workingDir;
-      slot.startedAt = this.deps.clock.now();
-      slot.pendingOperation = undefined;
-      slot.recentLogLines = [];
-      this.deps.resumeStormTracker.reset(opts.chatroomId, opts.role);
-      if (spawnResult.onLogLine) {
-        spawnResult.onLogLine((line) => appendRecentLogLine(slot, line));
-      }
-      this.deps.backend.mutation(api.machines.updateSpawnedAgent, {
-        sessionId: this.deps.sessionId,
-        machineId: this.deps.machineId,
+    }
+    slot.model = opts.model;
+    slot.wantResume = wantResume;
+    slot.workingDir = opts.workingDir;
+    slot.startedAt = this.deps.clock.now();
+    slot.pendingOperation = undefined;
+    slot.recentLogLines = [];
+    this.deps.resumeStormTracker.reset(opts.chatroomId, opts.role);
+  }
+  emitSpawnedAgentUpdate(opts, spawnResult, pid) {
+    this.deps.backend.mutation(api.machines.updateSpawnedAgent, {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId: opts.chatroomId,
+      role: opts.role,
+      pid,
+      model: opts.model,
+      reason: opts.reason,
+      ...spawnResult.harnessSessionId ? { harnessSessionId: spawnResult.harnessSessionId } : {}
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to update PID in backend: ${err.message}`);
+    });
+  }
+  registerSpawnCallbacks(slot, opts, spawnResult, pid) {
+    if (spawnResult.onLogLine) {
+      spawnResult.onLogLine((line) => appendRecentLogLine(slot, line));
+    }
+    spawnResult.onExit(({ code: code2, signal }) => {
+      this.handleExit({
         chatroomId: opts.chatroomId,
         role: opts.role,
         pid,
-        model: opts.model,
-        reason: opts.reason,
-        ...spawnResult.harnessSessionId ? { harnessSessionId: spawnResult.harnessSessionId } : {}
-      }).catch((err) => {
-        console.log(`   ⚠️  Failed to update PID in backend: ${err.message}`);
+        code: code2,
+        signal
       });
-      try {
-        await this.deps.persistence.persistAgentPid(this.deps.machineId, opts.chatroomId, opts.role, pid, opts.agentHarness);
-      } catch {}
-      spawnResult.onExit(({ code: code2, signal }) => {
-        this.handleExit({
+    });
+    if (spawnResult.onAgentEnd) {
+      spawnResult.onAgentEnd(() => {
+        this.turnEndQueue.enqueue(() => this.runHandleAgentEnd({
           chatroomId: opts.chatroomId,
           role: opts.role,
           pid,
-          code: code2,
-          signal
-        });
+          harness: opts.agentHarness
+        }));
       });
-      if (spawnResult.onAgentEnd) {
-        spawnResult.onAgentEnd(() => {
-          this.turnEndQueue.enqueue(() => this.runHandleAgentEnd({
-            chatroomId: opts.chatroomId,
-            role: opts.role,
-            pid,
-            harness: opts.agentHarness
-          }));
-        });
+    }
+    let lastReportedTokenAt = 0;
+    spawnResult.onOutput(() => {
+      const now = this.deps.clock.now();
+      if (now - lastReportedTokenAt >= 30000) {
+        lastReportedTokenAt = now;
+        this.deps.backend.mutation(api.participants.updateTokenActivity, {
+          sessionId: this.deps.sessionId,
+          chatroomId: opts.chatroomId,
+          role: opts.role
+        }).catch(() => {});
       }
-      let lastReportedTokenAt = 0;
-      spawnResult.onOutput(() => {
-        const now = this.deps.clock.now();
-        if (now - lastReportedTokenAt >= 30000) {
-          lastReportedTokenAt = now;
-          this.deps.backend.mutation(api.participants.updateTokenActivity, {
-            sessionId: this.deps.sessionId,
-            chatroomId: opts.chatroomId,
-            role: opts.role
-          }).catch(() => {});
-        }
-      });
-      return { success: true, pid };
+    });
+  }
+  async finalizeRunningSlot(key, slot, opts, spawnResult, wantResume) {
+    const { pid } = spawnResult;
+    this.deps.spawning.recordSpawn(opts.chatroomId);
+    this.assignRunningSlotState(key, slot, opts, spawnResult, wantResume, pid);
+    this.emitSpawnedAgentUpdate(opts, spawnResult, pid);
+    try {
+      await this.deps.persistence.persistAgentPid(this.deps.machineId, opts.chatroomId, opts.role, pid, opts.agentHarness);
+    } catch {}
+    this.registerSpawnCallbacks(slot, opts, spawnResult, pid);
+  }
+  async doEnsureRunning(key, slot, opts) {
+    slot.state = "spawning";
+    const wantResume = opts.wantResume;
+    console.log(`[AgentProcessManager] harness start: role=${opts.role} harness=${opts.agentHarness} wantResume=${wantResume} reason=${opts.reason}`);
+    try {
+      const rateLimit = this.checkRateLimitGate(opts, slot);
+      if (rateLimit)
+        return rateLimit;
+      const crashLoop = this.checkCrashLoopGate(opts, slot);
+      if (crashLoop)
+        return crashLoop;
+      const workingDir = await this.validateWorkingDirGate(opts, slot);
+      if (workingDir)
+        return workingDir;
+      const initPrompt = await this.fetchInitPromptResult(opts, slot);
+      if (!initPrompt.ok)
+        return initPrompt.result;
+      const spawn5 = await this.spawnAgentForEnsureRunning(key, slot, opts, initPrompt, wantResume);
+      if (!spawn5.ok)
+        return spawn5.result;
+      await this.finalizeRunningSlot(key, slot, opts, spawn5.spawnResult, wantResume);
+      return { success: true, pid: spawn5.spawnResult.pid };
     } catch (e) {
-      slot.state = "idle";
-      slot.pendingOperation = undefined;
+      this.resetSlotIdle(slot);
       return { success: false, error: `Unexpected error: ${e.message}` };
     }
   }
@@ -88851,64 +89842,75 @@ class AgentProcessManager {
   readHarnessReconnectMetadata(service3, pid) {
     return service3.getHarnessReconnectContext?.(pid);
   }
-  async doStop(key, slot, pid, opts) {
-    try {
-      const harness = slot.harness;
-      const service3 = harness ? this.deps.agentServices.get(harness) : undefined;
-      const supportsResume = harness ? getHarnessCapabilities(harness).supportsSessionResume : false;
-      const preserveForResume = shouldPreserveHarnessTeardown(opts.reason, supportsResume, Boolean(slot.harnessSessionId));
-      if (harness && slot.harnessSessionId) {
-        if (preserveForResume) {
-          const harnessMeta = service3 ? this.readHarnessReconnectMetadata(service3, pid) : undefined;
-          this.recordLastHarnessSession(key, {
-            harnessSessionId: slot.harnessSessionId,
-            harness,
-            agentName: harnessMeta?.agentName ?? "",
-            workingDir: slot.workingDir ?? "",
-            model: slot.model ?? harnessMeta?.model
-          });
-        } else {
-          this.clearLastHarnessSession(key);
-        }
-      } else if (!preserveForResume) {
+  shouldPreserveHarnessOnStop(slot, opts) {
+    const harness = slot.harness;
+    const supportsResume = harness ? getHarnessCapabilities(harness).supportsSessionResume : false;
+    return shouldPreserveHarnessTeardown(opts.reason, supportsResume, Boolean(slot.harnessSessionId));
+  }
+  recordHarnessSessionOnStop(key, slot, pid, service3) {
+    const harness = slot.harness;
+    const harnessMeta = service3 ? this.readHarnessReconnectMetadata(service3, pid) : undefined;
+    this.recordLastHarnessSession(key, {
+      harnessSessionId: slot.harnessSessionId,
+      harness,
+      agentName: harnessMeta?.agentName ?? "",
+      workingDir: slot.workingDir ?? "",
+      model: slot.model ?? harnessMeta?.model
+    });
+  }
+  updateHarnessSessionOnStop(key, slot, pid, service3, preserveForResume) {
+    const harness = slot.harness;
+    if (harness && slot.harnessSessionId) {
+      if (preserveForResume) {
+        this.recordHarnessSessionOnStop(key, slot, pid, service3);
+      } else {
         this.clearLastHarnessSession(key);
       }
-      if (service3) {
-        await service3.stop(pid, { preserveForResume });
-        service3.untrack(pid);
-      } else {
-        try {
-          this.deps.processes.kill(-pid, "SIGTERM");
-        } catch {}
-        let dead = false;
-        for (let i2 = 0;i2 < 20; i2++) {
-          await this.deps.clock.delay(500);
-          if (!isProcessAlive(this.deps.processes.kill, pid)) {
-            dead = true;
-            break;
-          }
-        }
-        if (!dead) {
-          try {
-            this.deps.processes.kill(-pid, "SIGKILL");
-          } catch {}
-          for (let i2 = 0;i2 < 10; i2++) {
-            await this.deps.clock.delay(500);
-            if (!isProcessAlive(this.deps.processes.kill, pid)) {
-              dead = true;
-              break;
-            }
-          }
-        }
-        for (const svc of this.deps.agentServices.values()) {
-          svc.untrack(pid);
+      return;
+    }
+    if (!preserveForResume) {
+      this.clearLastHarnessSession(key);
+    }
+  }
+  preserveOrClearHarnessSessionOnStop(key, slot, pid, opts, service3) {
+    const preserveForResume = this.shouldPreserveHarnessOnStop(slot, opts);
+    this.updateHarnessSessionOnStop(key, slot, pid, service3, preserveForResume);
+    return preserveForResume;
+  }
+  async killProcessWithFallback(pid) {
+    try {
+      this.deps.processes.kill(-pid, "SIGTERM");
+    } catch {}
+    let dead = false;
+    for (let i2 = 0;i2 < 20; i2++) {
+      await this.deps.clock.delay(500);
+      if (!isProcessAlive(this.deps.processes.kill, pid)) {
+        dead = true;
+        break;
+      }
+    }
+    if (!dead) {
+      try {
+        this.deps.processes.kill(-pid, "SIGKILL");
+      } catch {}
+      for (let i2 = 0;i2 < 10; i2++) {
+        await this.deps.clock.delay(500);
+        if (!isProcessAlive(this.deps.processes.kill, pid)) {
+          break;
         }
       }
-    } catch {}
+    }
+    for (const svc of this.deps.agentServices.values()) {
+      svc.untrack(pid);
+    }
+  }
+  resetSlotAfterStop(slot) {
     slot.state = "idle";
     slot.pid = undefined;
     slot.startedAt = undefined;
     slot.pendingOperation = undefined;
+  }
+  recordStopExit(slot, pid, opts) {
     const exitArgs3 = {
       sessionId: this.deps.sessionId,
       machineId: this.deps.machineId,
@@ -88924,6 +89926,21 @@ class AgentProcessManager {
       console.log(`   ⚠️  Failed to record agent exit event: ${err.message}`);
       this.queueExitRetry({ role: opts.role, args: exitArgs3 });
     });
+  }
+  async doStop(key, slot, pid, opts) {
+    try {
+      const harness = slot.harness;
+      const service3 = harness ? this.deps.agentServices.get(harness) : undefined;
+      const preserveForResume = this.preserveOrClearHarnessSessionOnStop(key, slot, pid, opts, service3);
+      if (service3) {
+        await service3.stop(pid, { preserveForResume });
+        service3.untrack(pid);
+      } else {
+        await this.killProcessWithFallback(pid);
+      }
+    } catch {}
+    this.resetSlotAfterStop(slot);
+    this.recordStopExit(slot, pid, opts);
     try {
       await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
     } catch {}
@@ -88934,12 +89951,15 @@ var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4;
 var init_agent_process_manager = __esm(() => {
   init_generator();
   init_types();
+  init_esm();
   init_turn_completed_backend();
   init_api3();
   init_orphan_tracker();
   init_agent_lifecycle();
   init_classify_resume_storm_reason();
   init_handle_turn_completed();
+  init_agent_lifecycle_runtime();
+  init_agent_lifecycle_types();
 });
 
 // src/infrastructure/services/harness-spawning/rate-limiter.ts
@@ -89505,6 +90525,7 @@ var init_models_refresh = __esm(() => {
 var startObservedSyncSubscriptionEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const effectContext2 = yield* exports_Effect.context();
+  const runtime4 = yield* exports_Effect.runtime();
   console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Starting observed-sync subscription (reactive)`);
   const observedWorkingDirs = new Map;
   const chatroomRefreshState = new Map;
@@ -89560,7 +90581,7 @@ var startObservedSyncSubscriptionEffect = (wsClient2) => exports_Effect.gen(func
       console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync subscription stopped`);
     }
   };
-  function handleObservedChange(observed) {
+  function collectWorkingDirChanges(observed) {
     const newWorkingDirs = new Set;
     const refreshedWorkingDirs = new Set;
     for (const chatroom of observed) {
@@ -89578,55 +90599,77 @@ var startObservedSyncSubscriptionEffect = (wsClient2) => exports_Effect.gen(func
         newWorkingDirs.add(wd);
       }
     }
+    return { newWorkingDirs, refreshedWorkingDirs };
+  }
+  function pruneStaleChatroomRefreshState(observed) {
     for (const [chatroomId] of chatroomRefreshState) {
       const stillObserved = observed.some((c) => c.chatroomId === chatroomId);
       if (!stillObserved) {
         chatroomRefreshState.delete(chatroomId);
       }
     }
+  }
+  function removeUnobservedWorkingDirs(newWorkingDirs) {
     const currentWorkingDirs = new Set(observedWorkingDirs.keys());
-    let addedCount = 0;
     let removedCount = 0;
     for (const wd of currentWorkingDirs) {
-      if (!newWorkingDirs.has(wd)) {
-        const state = observedWorkingDirs.get(wd);
-        if (state) {
-          clearInterval(state.intervalHandle);
-          observedWorkingDirs.delete(wd);
-          const skips = skippedPushCount.get(wd) ?? 0;
-          if (skips > 0) {
-            console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd} (skipped ${skips} overlapping pushes)`);
-          } else {
-            console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd}`);
-          }
-          skippedPushCount.delete(wd);
-          pendingRefresh.delete(wd);
-          removedCount++;
-        }
+      if (newWorkingDirs.has(wd)) {
+        continue;
+      }
+      const state = observedWorkingDirs.get(wd);
+      if (!state) {
+        continue;
+      }
+      clearInterval(state.intervalHandle);
+      observedWorkingDirs.delete(wd);
+      const skips = skippedPushCount.get(wd) ?? 0;
+      if (skips > 0) {
+        console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd} (skipped ${skips} overlapping pushes)`);
+      } else {
+        console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd}`);
       }
+      skippedPushCount.delete(wd);
+      pendingRefresh.delete(wd);
+      removedCount++;
     }
+    return removedCount;
+  }
+  function addNewlyObservedWorkingDirs(newWorkingDirs) {
+    let addedCount = 0;
     for (const wd of newWorkingDirs) {
+      if (observedWorkingDirs.has(wd)) {
+        continue;
+      }
+      observedWorkingDirs.set(wd, {
+        intervalHandle: setInterval(() => {
+          schedulePushForWorkingDir(wd, "safety-poll");
+        }, OBSERVED_SAFETY_POLL_MS),
+        pushInFlight: false
+      });
+      console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Started observing ${wd}`);
+      schedulePushForWorkingDir(wd, "safety-poll");
+      addedCount++;
+    }
+    return addedCount;
+  }
+  function triggerRefreshedWorkingDirs(refreshedWorkingDirs) {
+    for (const wd of refreshedWorkingDirs) {
       if (!observedWorkingDirs.has(wd)) {
-        observedWorkingDirs.set(wd, {
-          intervalHandle: setInterval(() => {
-            schedulePushForWorkingDir(wd, "safety-poll");
-          }, OBSERVED_SAFETY_POLL_MS),
-          pushInFlight: false
-        });
-        console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Started observing ${wd}`);
-        schedulePushForWorkingDir(wd, "safety-poll");
-        addedCount++;
+        continue;
       }
+      console.log(`[${formatTimestamp()}] \uD83D\uDD04 Refresh triggered for ${wd}`);
+      schedulePushForWorkingDir(wd, "refresh");
     }
+  }
+  function handleObservedChange(observed) {
+    const { newWorkingDirs, refreshedWorkingDirs } = collectWorkingDirChanges(observed);
+    pruneStaleChatroomRefreshState(observed);
+    const removedCount = removeUnobservedWorkingDirs(newWorkingDirs);
+    const addedCount = addNewlyObservedWorkingDirs(newWorkingDirs);
     if (addedCount > 0 || removedCount > 0) {
       console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observing ${observedWorkingDirs.size} working dir(s)`);
     }
-    for (const wd of refreshedWorkingDirs) {
-      if (observedWorkingDirs.has(wd)) {
-        console.log(`[${formatTimestamp()}] \uD83D\uDD04 Refresh triggered for ${wd}`);
-        schedulePushForWorkingDir(wd, "refresh");
-      }
-    }
+    triggerRefreshedWorkingDirs(refreshedWorkingDirs);
   }
   function schedulePushForWorkingDir(workingDir, reason = "safety-poll") {
     if (stopped)
@@ -89644,9 +90687,13 @@ var startObservedSyncSubscriptionEffect = (wsClient2) => exports_Effect.gen(func
       return;
     }
     state.pushInFlight = true;
-    pushForWorkingDir(workingDir, reason).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️ Push failed for ${workingDir}: ${getErrorMessage(err)}`);
-    }).finally(() => {
+    pushForWorkingDir(workingDir, reason);
+  }
+  function pushForWorkingDir(workingDir, reason = "safety-poll") {
+    exports_Runtime.runFork(runtime4)(exports_Effect.all([
+      pushSingleWorkspaceGitSummaryForObservedEffect(workingDir, reason),
+      pushSingleWorkspaceCommandsEffect(workingDir)
+    ], { concurrency: "unbounded" }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[${formatTimestamp()}] ⚠️ Observed sync failed for ${workingDir}: ${getErrorMessage(err)}`))), exports_Effect.ensuring(exports_Effect.sync(() => {
       const s = observedWorkingDirs.get(workingDir);
       if (s) {
         s.pushInFlight = false;
@@ -89655,15 +90702,7 @@ var startObservedSyncSubscriptionEffect = (wsClient2) => exports_Effect.gen(func
           schedulePushForWorkingDir(workingDir, "refresh");
         }
       }
-    });
-  }
-  async function pushForWorkingDir(workingDir, reason = "safety-poll") {
-    await exports_Effect.runPromise(pushSingleWorkspaceGitSummaryForObservedEffect(workingDir, reason).pipe(exports_Effect.provide(effectContext2))).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️ Observed git summary push failed for ${workingDir}: ${getErrorMessage(err)}`);
-    });
-    await exports_Effect.runPromise(pushSingleWorkspaceCommandsEffect(workingDir).pipe(exports_Effect.provide(effectContext2))).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️ Command sync failed for ${workingDir}: ${getErrorMessage(err)}`);
-    });
+    }))));
   }
 });
 var init_observed_sync = __esm(() => {
@@ -89736,36 +90775,21 @@ var init_workspace_list_subscription = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/command-loop.ts
-function evictStaleDedupEntries(tracker) {
-  const evictBefore = Date.now() - AGENT_REQUEST_DEADLINE_MS;
-  for (const [id3, ts] of tracker.commandIds) {
-    if (ts < evictBefore)
-      tracker.commandIds.delete(id3);
-  }
-  for (const [id3, ts] of tracker.pingIds) {
-    if (ts < evictBefore)
-      tracker.pingIds.delete(id3);
-  }
-  for (const [id3, ts] of tracker.gitRefreshIds) {
-    if (ts < evictBefore)
-      tracker.gitRefreshIds.delete(id3);
-  }
-  for (const [id3, ts] of tracker.capabilitiesRefreshIds) {
+function evictStaleEntries(entries2, evictBefore) {
+  for (const [id3, ts] of entries2) {
     if (ts < evictBefore)
-      tracker.capabilitiesRefreshIds.delete(id3);
-  }
-  for (const [id3, ts] of tracker.localActionIds) {
-    if (ts < evictBefore)
-      tracker.localActionIds.delete(id3);
-  }
-  for (const [id3, ts] of tracker.commandRunIds) {
-    if (ts < evictBefore)
-      tracker.commandRunIds.delete(id3);
-  }
-  for (const [id3, ts] of tracker.commandStopIds) {
-    if (ts < evictBefore)
-      tracker.commandStopIds.delete(id3);
+      entries2.delete(id3);
   }
+}
+function evictStaleDedupEntries(tracker) {
+  const evictBefore = Date.now() - AGENT_REQUEST_DEADLINE_MS;
+  evictStaleEntries(tracker.commandIds, evictBefore);
+  evictStaleEntries(tracker.pingIds, evictBefore);
+  evictStaleEntries(tracker.gitRefreshIds, evictBefore);
+  evictStaleEntries(tracker.capabilitiesRefreshIds, evictBefore);
+  evictStaleEntries(tracker.localActionIds, evictBefore);
+  evictStaleEntries(tracker.commandRunIds, evictBefore);
+  evictStaleEntries(tracker.commandStopIds, evictBefore);
   processManager.evictStalePendingStops();
 }
 function handleRequestStartEffect(event, tracker) {
@@ -89936,6 +90960,7 @@ var init_command_loop = __esm(() => {
   startCommandLoopEffect = exports_Effect.gen(function* () {
     const session2 = yield* DaemonSessionService;
     const effectContext2 = yield* exports_Effect.context();
+    const runtime4 = yield* exports_Effect.runtime();
     const observedSyncEnabled = featureFlags.observedSyncEnabled ?? false;
     let heartbeatCount = 0;
     const heartbeatTimer = setInterval(() => {
@@ -89946,15 +90971,9 @@ var init_command_loop = __esm(() => {
         heartbeatCount++;
         console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
         if (!observedSyncEnabled) {
-          exports_Effect.runPromise(pushGitStateEffect.pipe(exports_Effect.provide(effectContext2))).catch((err) => {
-            console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed: ${getErrorMessage(err)}`);
-          });
-          exports_Effect.runPromise(pushCommandsEffect.pipe(exports_Effect.provide(effectContext2))).catch((err) => {
-            console.warn(`[${formatTimestamp()}] ⚠️  Command sync failed: ${getErrorMessage(err)}`);
-          });
-          exports_Effect.runPromise(syncCommitDetailsEffect().pipe(exports_Effect.provide(effectContext2))).catch((err) => {
-            console.warn(`[${formatTimestamp()}] ⚠️  Commit detail sync failed: ${getErrorMessage(err)}`);
-          });
+          exports_Runtime.runFork(runtime4)(exports_Effect.all([pushGitStateEffect, pushCommandsEffect, syncCommitDetailsEffect()], {
+            concurrency: "unbounded"
+          }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[${formatTimestamp()}] ⚠️  Heartbeat sync failed: ${getErrorMessage(err)}`)))));
         }
       }).catch((err) => {
         console.warn(`[${formatTimestamp()}] ⚠️  Daemon heartbeat failed: ${getErrorMessage(err)}`);
@@ -89976,9 +90995,9 @@ var init_command_loop = __esm(() => {
     if (observedSyncEnabled) {
       console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync enabled, skipping immediate push`);
     } else {
-      exports_Effect.runPromise(pushGitStateEffect.pipe(exports_Effect.provide(effectContext2))).catch(() => {});
-      exports_Effect.runPromise(pushCommandsEffect.pipe(exports_Effect.provide(effectContext2))).catch(() => {});
-      exports_Effect.runPromise(syncCommitDetailsEffect().pipe(exports_Effect.provide(effectContext2))).catch(() => {});
+      exports_Runtime.runFork(runtime4)(exports_Effect.all([pushGitStateEffect, pushCommandsEffect, syncCommitDetailsEffect()], {
+        concurrency: "unbounded"
+      }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[${formatTimestamp()}] ⚠️ Startup sync failed: ${getErrorMessage(err)}`)))));
     }
     const PROCESS_KILL_TIMEOUT_MS = 6000;
     const CLOSE_TIMEOUT_MS = 3000;
@@ -90011,43 +91030,46 @@ var init_command_loop = __esm(() => {
         return;
       isShuttingDown = true;
       console.log(`
-[${formatTimestamp()}] Shutting down... (press Ctrl+C again to force)`);
+[${formatTimestamp()}] Shutting down... (press Ctrl+B again to force)`);
+      const watchdog = setupShutdownWatchdog();
+      clearInterval(heartbeatTimer);
+      stopSubscriptions();
+      await runDaemonShutdownEffect();
+      await closeAllSessionsAndHarnesses();
+      clearTimeout(watchdog);
+      releaseLock();
+      process.exit(0);
+    };
+    const setupShutdownWatchdog = () => {
       const watchdog = setTimeout(() => {
         console.error(`[${formatTimestamp()}] Shutdown timed out — forcing exit.`);
         forceExit(1);
       }, SHUTDOWN_WATCHDOG_MS);
       watchdog.unref?.();
-      clearInterval(heartbeatTimer);
-      if (gitSubscriptionHandle)
-        gitSubscriptionHandle.stop();
-      if (fileContentSubscriptionHandle)
-        fileContentSubscriptionHandle.stop();
-      if (fileTreeSubscriptionHandle)
-        fileTreeSubscriptionHandle.stop();
-      if (workspaceListSubscriptionHandle)
-        workspaceListSubscriptionHandle.stop();
-      if (observedSyncSubscriptionHandle)
-        observedSyncSubscriptionHandle.stop();
-      if (logObserverSubscriptionHandle)
-        logObserverSubscriptionHandle.stop();
-      if (pendingPromptSubscriptionHandle)
-        pendingPromptSubscriptionHandle.stop();
-      if (pendingHarnessSessionSubscriptionHandle)
-        pendingHarnessSessionSubscriptionHandle.stop();
-      if (commandSubscriptionHandle)
-        commandSubscriptionHandle.stop();
-      if (lifecycleManager)
-        lifecycleManager.stopMonitoring();
+      return watchdog;
+    };
+    const stopSubscriptions = () => {
+      gitSubscriptionHandle?.stop();
+      fileContentSubscriptionHandle?.stop();
+      fileTreeSubscriptionHandle?.stop();
+      workspaceListSubscriptionHandle?.stop();
+      observedSyncSubscriptionHandle?.stop();
+      logObserverSubscriptionHandle?.stop();
+      pendingPromptSubscriptionHandle?.stop();
+      pendingHarnessSessionSubscriptionHandle?.stop();
+      commandSubscriptionHandle?.stop();
+      lifecycleManager?.stopMonitoring();
+    };
+    const runDaemonShutdownEffect = async () => {
       await withTimeout3(exports_Effect.runPromise(onDaemonShutdownEffect.pipe(exports_Effect.provide(effectContext2))), PROCESS_KILL_TIMEOUT_MS);
+    };
+    const closeAllSessionsAndHarnesses = async () => {
       for (const handle of activeSessions.values()) {
         await withTimeout3(handle.close(), CLOSE_TIMEOUT_MS);
       }
       for (const harness of harnesses.values()) {
         await withTimeout3(harness.close(), CLOSE_TIMEOUT_MS);
       }
-      clearTimeout(watchdog);
-      releaseLock();
-      process.exit(0);
     };
     const handleSignal = (signal) => {
       signalCount += 1;
@@ -91316,4 +92338,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=C790B7A198F818CB64756E2164756E21
+//# debugId=D908929E6EC55FCC64756E2164756E21