@humwick/server 0.130.2 → 0.130.4

package/src/lifecycle-manager.ts

@@ -1,12 +1,15 @@
+import { framed } from "./hub-metrics";
+import { upsertManagedAgentStateAsync, updateManagedAgentStateAsync } from "./db/lifecycle-tail-async";
+import { createActivityEventAsync } from "./db/activity-async";
+import { createCommandAsync, prepareCommandWriteAsync, submitPreparedCommandAsync } from "./commands-write";
 import { timePostBindPhase } from "./post-bind-startup";
 import { requestAgentExitCleanup } from "./agent-exit-cleanup";
 import { hostSpawnsDrained } from "./db/spawn-host-cap";
-import { createCommand } from "./commands-db";
-import { createCommandAsync, prepareCommandWriteAsync } from "./commands-write";
+
 import { errMessage, fireAndForget, guardedInterval } from "@humwick/sdk";
 import { agentProviderState } from "./provider-state";
-import { createActivityEvent, getAgent, getDb, getOrchestrator, listOrchestrators, listWorkspaces, pendingOwnRelayRunIds } from "./db";
-import { getManagedAgentState, listSpawnPolicies, updateManagedAgentState, upsertManagedAgentState } from "./config-store"; import { managedSpawnReservationCurrent, restoreDrainedSpawnReservation } from "./managed-spawn-reservation";
+import { getAgent, getDb, getOrchestrator, listOrchestrators, listWorkspaces, pendingOwnRelayRunIds } from "./db";
+import { getManagedAgentState, listSpawnPolicies } from "./config-store"; import { managedSpawnReservationCurrent, restoreDrainedSpawnReservation } from "./managed-spawn-reservation";
 import { emitRelayEvent } from "./events";
 import { alwaysReloadTags, reconcileLifecycleContextPressure, requestAgentCompact } from "./lifecycle-context-pressure";
 import { escalateManagedSpawnFailure, escalateOfflineOrchestrator } from "./managed-policy-escalation";
@@ -82,7 +85,7 @@ export class LifecycleManager {
 
   start(): void {
     if (this.timer) return;
-    const tick = () => timePostBindPhase("lifecycle.tick", () => this.tick());
+    const tick = framed("timer lifecycle", () => timePostBindPhase("lifecycle.tick", () => this.tick()));
     void fireAndForget("[lifecycle] tick", tick);
     this.timer = guardedInterval("[lifecycle] tick", this.tickMs, tick);
   }
@@ -102,13 +105,13 @@ export class LifecycleManager {
     // #2171 — validation instructions must come from the policy's launch host. The tick primes
     // remote land-gate files once per host so synchronous spawn composition reads current cache.
     await primeLandGatesForPolicies(policies);
-    const contextHandled = this.reconcileContextPressure(policies);
+    const contextHandled = (await this.reconcileContextPressure(policies));
     for (const policy of policies) {
       await this.reconcilePolicy(policy, contextHandled);
     }
   }
 
-  onMessageForPolicy(policyName: string): PolicySpawnOutcome | Promise<PolicySpawnOutcome> {
+  async onMessageForPolicy(policyName: string): Promise<PolicySpawnOutcome> {
     const policy = this.loadPolicies().find((item) => item.name === policyName);
     if (!policy) return { woke: false, reason: `no spawn policy '${policyName}'` };
     if (policy.mode !== "on-demand") return { woke: false, reason: `spawn policy '${policyName}' is not on-demand` };
@@ -139,8 +142,7 @@ export class LifecycleManager {
     // FAILURE, not a success. Propagate it so callers don't stamp a false hand-off.
     // Explicit wake (watchdog / auto-merge / cooldown re-wake): exempt from the respawn-rate backstop
     // — its own STEWARD_HANDOFF_REWAKE_MAX + wake cooldown already bound it (#1745).
-    const command = this.spawnAgent(policy, "message-trigger", { enforceStewardRate: false });
-    if (command instanceof Promise) return this.policyWakeOutcome(policyName, command, state);
+    const command = (await this.spawnAgent(policy, "message-trigger", { enforceStewardRate: false }));
     if (!command) return { woke: false, reason: `steward spawn failed for '${policyName}' (${this.policyWakeFailureReason(policyName, state)})` };
     return { woke: true, via: "spawned", command };
   }
@@ -186,13 +188,13 @@ export class LifecycleManager {
   // drifted registration copies (epic #342). Only the orchestrator-report projection
   // below still enters managed-running from the lifecycle manager.
 
-  onOrchestratorManagedAgentsReported(orchestratorId: string, agents: ManagedAgent[], exitedAgents: ManagedSessionExitDiagnostics[] = []): void {
+  async onOrchestratorManagedAgentsReported(orchestratorId: string, agents: ManagedAgent[], exitedAgents: ManagedSessionExitDiagnostics[] = []): Promise<void> {
     for (const agent of agents) {
       if (!agent.policyName || !agent.spawnRequestId) continue;
       const state = getManagedAgentState(agent.policyName);
       if (!state || state.spawnRequestId !== agent.spawnRequestId) continue;
       // Same came-up-running core the registration transports use — one home, no drift.
-      markManagedAgentRunning(
+      (await markManagedAgentRunning(
         {
           policyName: agent.policyName,
           spawnRequestId: agent.spawnRequestId,
@@ -202,7 +204,7 @@ export class LifecycleManager {
         },
         authContextFromSystem(),
         { now: this.now },
-      );
+      ));
 
       // Liveness reconciliation: the orchestrator just reported this process as
       // running. If the relay record says offline, the two truths disagree
@@ -211,12 +213,12 @@ export class LifecycleManager {
       if (reportedAgentId) {
         const relayAgent = getAgent(reportedAgentId);
         if (relayAgent && relayAgent.status === "offline") {
-          this.emitLivenessMismatch(
+          (await this.emitLivenessMismatch(
             reportedAgentId,
             agent.policyName,
             agent.spawnRequestId,
             "orchestrator reports the process running but relay marked it offline",
-          );
+          ));
         }
       }
     }
@@ -238,23 +240,23 @@ export class LifecycleManager {
           (state.tmuxSession && agent.tmuxSession === state.tmuxSession) ||
           (agent.policyName === policy.name && (!state.spawnRequestId || agent.spawnRequestId === state.spawnRequestId))
         ));
-        this.markPolicyFailure(policy, state, exited?.lastError ?? "orchestrator session disappeared", { exited });
+        (await this.markPolicyFailure(policy, state, exited?.lastError ?? "orchestrator session disappeared", { exited }));
       } else if (state.status === "stopping" && !reported) {
-        const next = updateManagedAgentState(policy.name, {
+        const next = (await updateManagedAgentStateAsync(policy.name, {
           status: "stopped",
           agentId: undefined,
           tmuxSession: undefined,
           lastStopAt: this.now(),
-        });
-        if (next) this.emitState(next);
+        }));
+        if (next) (await this.emitState(next));
       }
     }
   }
 
-  onAgentDisappeared(agentId: string): void {
+  async onAgentDisappeared(agentId: string): Promise<void> {
     // Reconcile the agent's worktrees before policy handling — this runs for
     // every agent (managed or not), so it must not depend on a policy match.
-    this.reconcileWorkspacesForAgent(agentId);
+    (await this.reconcileWorkspacesForAgent(agentId));
     const policy = this.loadPolicies().find((item) => getManagedAgentState(item.name)?.agentId === agentId);
     if (!policy) {
       const agent = getAgent(agentId);
@@ -264,23 +266,23 @@ export class LifecycleManager {
     const state = getManagedAgentState(policy.name);
     if (!state) return;
     if (state.status === "stopping") {
-      const next = updateManagedAgentState(policy.name, {
+      const next = (await updateManagedAgentStateAsync(policy.name, {
         status: "stopped",
         agentId: undefined,
         tmuxSession: undefined,
         lastStopAt: this.now(),
-      });
-      if (next) this.emitState(next);
+      }));
+      if (next) (await this.emitState(next));
       return;
     }
-    this.markPolicyFailure(policy, state, "agent disappeared");
+    (await this.markPolicyFailure(policy, state, "agent disappeared"));
     if (isStewardPolicy(policy)) void retryStewardLandsAfterSlotFreed().catch(error => console.warn(`[steward] slot recovery failed: ${errMessage(error)}`));
   }
 
-  onConfigChanged(namespace: string, key: string): void {
+  async onConfigChanged(namespace: string, key: string): Promise<void> {
     if (namespace !== "spawn-policy") return;
     const policy = this.loadPolicies().find((item) => item.name === key);
-    if (policy) void fireAndForget(`[lifecycle] reconcile ${policy.name}`, () => this.reconcilePolicy(policy, this.reconcileContextPressure([policy])));
+    if (policy) await fireAndForget(`[lifecycle] reconcile ${policy.name}`, async () => (await this.reconcilePolicy(policy, (await this.reconcileContextPressure([policy])))));
   }
 
   onRelayUpdated(_newVersion: string): void {
@@ -289,9 +291,16 @@ export class LifecycleManager {
     }
   }
 
-  spawnAgent(policy: SpawnPolicy, reason = "reconcile", opts: { enforceStewardRate?: boolean } = {}): Command | null | Promise<Command | null> {
+  spawnAgent(policy: SpawnPolicy, reason = "reconcile", opts: { enforceStewardRate?: boolean } = {}): Promise<Command | null> {
     const pending = this.pendingSpawnPreparations.get(policy.name);
     if (pending) return pending;
+    const preparation = this.prepareSpawn(policy, reason, opts);
+    this.pendingSpawnPreparations.set(policy.name, preparation);
+    void preparation.finally(() => { if (this.pendingSpawnPreparations.get(policy.name) === preparation) this.pendingSpawnPreparations.delete(policy.name); }).catch(() => {});
+    return preparation;
+  }
+
+  private async prepareSpawn(policy: SpawnPolicy, reason: string, opts: { enforceStewardRate?: boolean }): Promise<Command | null> {
     // #1745 — universal steward chokepoint: every spawn path (message-trigger, reconcile respawn,
     // backoff-expired, always-on) funnels through here, so the kill-switch + per-repo cap gate lives
     // here as the last line of defence. A denied steward spawn returns null WITHOUT churning managed
@@ -310,7 +319,7 @@ export class LifecycleManager {
       }
     }
     // #2656 — a disabled provider parks the policy (visible reason, no backoff); a later tick resumes it.
-    const providerOff = managedPolicyProviderDisabledMessage(policy); if (providerOff) { const parked = parkManagedPolicyForDisabledProvider(policy, providerOff); if (parked) this.emitState(parked, `spawn skipped: ${providerOff}`); return null; }
+    const providerOff = managedPolicyProviderDisabledMessage(policy); if (providerOff) { const parked = (await parkManagedPolicyForDisabledProvider(policy, providerOff)); if (parked) (await this.emitState(parked, `spawn skipped: ${providerOff}`)); return null; }
     const orch = getOrchestrator(policy.orchestratorId);
     if (!orch || orch.status !== "online") {
       const state = getManagedAgentState(policy.name) ?? {
@@ -322,45 +331,42 @@ export class LifecycleManager {
         consecutiveFailures: 0,
         updatedAt: this.now(),
       };
-      this.markBackoff(policy, state, "orchestrator offline");
+      (await this.markBackoff(policy, state, "orchestrator offline"));
       const next = getManagedAgentState(policy.name);
-      if (next) escalateOfflineOrchestrator(policy, next, orch);
+      if (next) void fireAndForget(`[lifecycle] escalate ${policy.name}`, () => escalateOfflineOrchestrator(policy, next, orch));
       return null;
     }
     if (hostSpawnsDrained(orch.agentId)) return null;
     const spawnRequestId = generateSpawnRequestId(); const policySnapshot = JSON.stringify(policy);
     // Reserve `starting` before an async parameter build. A second queued wake can then observe
     // the reservation instead of minting a second request id while provisioning resolves.
-    const priorState = getManagedAgentState(policy.name); const reserved = upsertManagedAgentState({ policyName: policy.name, status: "starting", orchestratorId: policy.orchestratorId, provider: policy.provider, spawnRequestId, lastSpawnAt: this.now(), restartCount: priorState?.restartCount ?? 0, consecutiveFailures: priorState?.consecutiveFailures ?? 0 });
-    this.emitState(reserved, `spawn: ${reason}`);
-    const releaseReservation = (error: unknown): void => { const current = getManagedAgentState(policy.name); if (current?.spawnRequestId === spawnRequestId) { if (current.status === "starting") this.markPolicyFailure(policy, current, errMessage(error)); } };
+    const priorState = getManagedAgentState(policy.name); const reserved = (await upsertManagedAgentStateAsync({ policyName: policy.name, status: "starting", orchestratorId: policy.orchestratorId, provider: policy.provider, spawnRequestId, lastSpawnAt: this.now(), restartCount: priorState?.restartCount ?? 0, consecutiveFailures: priorState?.consecutiveFailures ?? 0 }));
+    (await this.emitState(reserved, `spawn: ${reason}`));
+    const releaseReservation = async (error: unknown): Promise<void> => { const current = getManagedAgentState(policy.name); if (current?.spawnRequestId === spawnRequestId) { if (current.status === "starting") (await this.markPolicyFailure(policy, current, errMessage(error))); } };
     let params: Record<string, unknown> | Promise<Record<string, unknown>>;
     try { params = this.buildManagedSpawnParams(policy, spawnRequestId, { createdBy: "lifecycle-manager", authority: SYSTEM_LAUNCH, requestedAt: this.now() }); }
-    catch (error) { releaseReservation(error); return null; }
+    catch (error) { (await releaseReservation(error)); return null; }
     const finish = async (spawnParams: Record<string, unknown>): Promise<Command | null> => {
     const prepared = await prepareCommandWriteAsync({ type: "agent.spawn", source: "system", target: orch.agentId,
       correlationId: spawnRequestId, params: { ...spawnParams, reason } }, { hostCap: { exempt: "managed-policy" } });
     // Re-check after all async launch preparation, including vault reads (#3574).
     if (!managedSpawnReservationCurrent(policy, policySnapshot, spawnRequestId)) return null;
-    if (hostSpawnsDrained(orch.agentId)) { restoreDrainedSpawnReservation(policy, spawnRequestId, priorState); return null; }
-    const command = createCommand(prepared.input, prepared.options, prepared.id);
+    if (hostSpawnsDrained(orch.agentId)) { (await restoreDrainedSpawnReservation(policy, spawnRequestId, priorState)); return null; }
+    const command = (await submitPreparedCommandAsync(prepared));
     emitCommandEvent(command, "command.requested");
     // #1745 — record the actual spawn so the respawn-rate backstop can bound a repeatedly-dying
     // steward (registers, then exits on quota — never a spawn failure, so backoff never engages).
     if (isStewardPolicy(policy)) noteStewardSpawn(policy.name, this.now());
     return command;
     };
-    const preparation = Promise.resolve(params).then(finish).catch((error) => { releaseReservation(error); return null; });
-    this.pendingSpawnPreparations.set(policy.name, preparation);
-    void preparation.finally(() => { if (this.pendingSpawnPreparations.get(policy.name) === preparation) this.pendingSpawnPreparations.delete(policy.name); }).catch(() => { /* preparation never rejects: it catches above */ });
-    return preparation;
+    return Promise.resolve(params).then(finish).catch(async (error) => { await releaseReservation(error); return null; });
   }
 
-  stopAgent(policy: SpawnPolicy, graceful = true, reason = "reconcile-stop"): Command | null {
+  async stopAgent(policy: SpawnPolicy, graceful = true, reason = "reconcile-stop"): Promise<Command | null> {
     const orch = getOrchestrator(policy.orchestratorId);
     if (!orch) return null;
     const state = getManagedAgentState(policy.name);
-    const next = upsertManagedAgentState({
+    const next = (await upsertManagedAgentStateAsync({
       policyName: policy.name,
       status: "stopping",
       agentId: state?.agentId,
@@ -372,9 +378,9 @@ export class LifecycleManager {
       lastStopAt: this.now(),
       restartCount: state?.restartCount ?? 0,
       consecutiveFailures: state?.consecutiveFailures ?? 0,
-    });
-    this.emitState(next, `stop: ${reason}`);
-    const command = createCommand({
+    }));
+    (await this.emitState(next, `stop: ${reason}`));
+    const command = (await createCommandAsync({
       type: "agent.shutdown",
       source: "system",
       target: orch.agentId,
@@ -392,7 +398,7 @@ export class LifecycleManager {
         requestedBy: "lifecycle-manager",
         requestedAt: this.now(),
       },
-    });
+    }));
     emitCommandEvent(command, "command.requested");
     return command;
   }
@@ -404,7 +410,7 @@ export class LifecycleManager {
     const restartRequestId = generateSpawnRequestId();
     const restartSpawn = buildManagedSpawnParamsAsync(policy, restartRequestId, { createdBy: "lifecycle-manager", authority: SYSTEM_LAUNCH, requestedAt: this.now(), ...(state?.agentId ? { identityAgentId: state.agentId } : {}) }); const finish = async (spawnParams: Record<string, unknown>): Promise<Command | null> => {
     if (hostSpawnsDrained(orch.agentId)) return null;
-    const restarted = upsertManagedAgentState({
+    const restarted = (await upsertManagedAgentStateAsync({
       policyName: policy.name,
       status: "stopping",
       agentId: state?.agentId,
@@ -416,8 +422,8 @@ export class LifecycleManager {
       lastStopAt: this.now(),
       restartCount: (state?.restartCount ?? 0) + 1,
       consecutiveFailures: state?.consecutiveFailures ?? 0,
-    });
-    this.emitState(restarted, `restart: ${reason}`);
+    }));
+    (await this.emitState(restarted, `restart: ${reason}`));
     const command = await createCommandAsync({ type: "agent.restart",
       source: "system",
       target: orch.agentId,
@@ -451,7 +457,7 @@ export class LifecycleManager {
     if (!state) {
       if (enabled && policy.mode === "always-on") await this.spawnAgent(policy, "always-on");
       else if (enabled && hasQueuedPolicyWork(policy.name)) await this.spawnAgent(policy, "message-trigger");
-      else this.ensureStoppedState(policy);
+      else (await this.ensureStoppedState(policy));
       return;
     }
 
@@ -460,7 +466,7 @@ export class LifecycleManager {
         // #1021 A3 — a never-registered spawn has no exit diagnostics, so isFastFailStorm
         // can never trip and it would back off/retry forever in silence. Flag it so the
         // escalation fires once it has failed repeatedly.
-        this.markPolicyFailure(policy, state, "spawn timed out before registration", { registerTimeout: true });
+        (await this.markPolicyFailure(policy, state, "spawn timed out before registration", { registerTimeout: true }));
       }
       return;
     }
@@ -481,13 +487,13 @@ export class LifecycleManager {
         const unconfirmedDead = agent?.meta?.lifecycleAction === "kill-failed" || managedRunningAgentAlive(agent);
         if (!unconfirmedDead) {
           this.stopRetries.delete(policy.name);
-          const next = updateManagedAgentState(policy.name, {
+          const next = (await updateManagedAgentStateAsync(policy.name, {
             status: "stopped",
             agentId: undefined,
             tmuxSession: undefined,
             lastStopAt: this.now(),
-          });
-          if (next) this.emitState(next);
+          }));
+          if (next) (await this.emitState(next));
         } else if (isStewardPolicy(policy) && agent && (agent.status === "busy" || pendingOwnRelayRunIds(agent, this.now()).length > 0 || this.holdsActiveWorkspaceClaim(agent.id))) {
           // #1761 — DEFER the forceful escalation while the steward is genuinely WORKING. Within the
           // STOP_TIMEOUT window a `stopping` policy still reads managedProcessActive, so
@@ -511,7 +517,7 @@ export class LifecycleManager {
           const retries = (this.stopRetries.get(policy.name) ?? 0) + 1;
           if (retries <= MAX_STEWARD_STOP_RETRIES) {
             this.stopRetries.set(policy.name, retries);
-            this.stopAgent(policy, false, `stop-retry-${retries} (unconfirmed dead after ${Math.round(STOP_TIMEOUT_MS / 1000)}s)`);
+            (await this.stopAgent(policy, false, `stop-retry-${retries} (unconfirmed dead after ${Math.round(STOP_TIMEOUT_MS / 1000)}s)`));
           } else {
             // Budget exhausted — release the policy from `stopping` to `stopped` and let go of the
             // handle. This is now SAFE (unlike pre-#1745, when clearing the handle let a duplicate
@@ -521,13 +527,13 @@ export class LifecycleManager {
             // deliberately no-ops on `stopping`, so transition directly here.
             console.warn(`[lifecycle] steward '${policy.name}' stop did not confirm dead after ${MAX_STEWARD_STOP_RETRIES} forceful attempts; releasing the handle (agent cap + orphan reaper now own the zombie)`);
             this.stopRetries.delete(policy.name);
-            const next = updateManagedAgentState(policy.name, {
+            const next = (await updateManagedAgentStateAsync(policy.name, {
               status: "stopped",
               agentId: undefined,
               tmuxSession: undefined,
               lastStopAt: this.now(),
-            });
-            if (next) this.emitState(next, "stop-retry exhausted: releasing handle");
+            }));
+            if (next) (await this.emitState(next, "stop-retry exhausted: releasing handle"));
           }
         }
       }
@@ -540,28 +546,28 @@ export class LifecycleManager {
       // stopping wedge (if any) gets its full MAX_STEWARD_STOP_RETRIES (#1761).
       this.stopRetries.delete(policy.name);
       if (!enabled) {
-        this.stopAgent(policy, true, "policy-disabled");
+        (await this.stopAgent(policy, true, "policy-disabled"));
         return;
       }
       if (!managedRunningAgentAlive(agent)) {
-        this.markPolicyFailure(policy, state, agentTerminalFailureMessage(agent) ?? "agent offline");
+        (await this.markPolicyFailure(policy, state, agentTerminalFailureMessage(agent) ?? "agent offline"));
         return;
       }
-      this.resetBackoffAfterHealthyRun(policy, state);
+      (await this.resetBackoffAfterHealthyRun(policy, state));
       if (policy.mode === "on-demand" && this.isIdle(policy, state)) {
-        this.stopAgent(policy, true, "idle-timeout");
+        (await this.stopAgent(policy, true, "idle-timeout"));
         return;
       }
       if (contextHandled.has(agent.id)) return;
       if (this.shouldCompact(agent)) {
-        requestAgentCompact({
+        (await requestAgentCompact({
           agent,
           reason: "context-threshold",
           policyName: policy.name,
           alwaysReload: alwaysReloadTags(agent.tags),
           now: this.now,
           hasActiveCommand: (target, type) => this.hasActiveCommand(target, type),
-        });
+        }));
         return;
       }
       if (policy.scheduledDailyRestart && this.dailyRestartDue(policy, state) && this.isIdle(policy, state, 3600)) {
@@ -589,60 +595,60 @@ export class LifecycleManager {
     }
   }
 
-  private reconcileContextPressure(policies: SpawnPolicy[]): Set<string> {
-    return reconcileLifecycleContextPressure({
+  private async reconcileContextPressure(policies: SpawnPolicy[]): Promise<Set<string>> {
+    return (await reconcileLifecycleContextPressure({
       policies,
       now: this.now,
       hasActiveCommand: (target, type) => this.hasActiveCommand(target, type),
-    });
+    }));
   }
 
-  private ensureStoppedState(policy: SpawnPolicy): void {
-    const state = upsertManagedAgentState({
+  private async ensureStoppedState(policy: SpawnPolicy): Promise<void> {
+    const state = (await upsertManagedAgentStateAsync({
       policyName: policy.name,
       status: "stopped",
       orchestratorId: policy.orchestratorId,
       provider: policy.provider,
-    });
-    this.emitState(state);
+    }));
+    (await this.emitState(state));
   }
 
-  private markPolicyFailure(
+  private async markPolicyFailure(
     policy: SpawnPolicy,
     state: ManagedAgentState,
     error: string,
     opts: { exited?: ManagedSessionExitDiagnostics; registerTimeout?: boolean } = {},
-  ): void {
+  ): Promise<void> {
     if (state.status === "stopping") return;
     // Read the terminal reason from the adapter-surfaced typed provider state rather
     // than re-parsing raw provider log text (#745 / #725 §4.4 leak #13).
     const agentId = state.agentId || opts.exited?.agentId;
     const modelUnavailable = agentId ? agentTerminalFailureMessage(getAgent(agentId)) : null;
     if (modelUnavailable) {
-      this.markFailed(policy, state, modelUnavailable);
+      (await this.markFailed(policy, state, modelUnavailable));
       return;
     }
     const failures = state.consecutiveFailures + 1;
     if (isFastFailStorm(failures, opts.exited)) {
-      this.markFailed(policy, state, error);
+      (await this.markFailed(policy, state, error));
       return;
     }
-    this.markBackoff(policy, state, error, failures);
+    (await this.markBackoff(policy, state, error, failures));
     // #1021 A3 — a register-never spawn never reaches markFailed (no exit diagnostics), so
     // without this its escalation would never fire. Escalate once it has failed repeatedly.
     if (isStewardPolicy(policy) && failures === MAX_FAST_FAILURES) {
       const next = getManagedAgentState(policy.name);
-      if (next) escalateManagedSpawnFailure(policy, next, { phase: "spawn-backoff", error });
+      if (next) void fireAndForget(`[lifecycle] escalate ${policy.name}`, () => escalateManagedSpawnFailure(policy, next, { phase: "spawn-backoff", error }));
     } else if (!isStewardPolicy(policy) && opts.registerTimeout && failures >= MAX_FAST_FAILURES) {
       const next = getManagedAgentState(policy.name);
-      if (next) escalateManagedSpawnFailure(policy, next, { phase: "register-timeout", error });
+      if (next) void fireAndForget(`[lifecycle] escalate ${policy.name}`, () => escalateManagedSpawnFailure(policy, next, { phase: "register-timeout", error }));
     }
   }
 
-  private markBackoff(policy: SpawnPolicy, state: ManagedAgentState, error: string, failures = state.consecutiveFailures + 1): void {
+  private async markBackoff(policy: SpawnPolicy, state: ManagedAgentState, error: string, failures = state.consecutiveFailures + 1): Promise<void> {
     if (state.status === "stopping") return;
     const delay = this.backoffDelay(policy, state);
-    const next = upsertManagedAgentState({
+    const next = (await upsertManagedAgentStateAsync({
       policyName: policy.name,
       status: "backoff",
       agentId: undefined,
@@ -655,13 +661,13 @@ export class LifecycleManager {
       consecutiveFailures: failures,
       backoffUntil: this.now() + delay * 1000,
       lastError: error,
-    });
-    this.emitState(next);
+    }));
+    (await this.emitState(next));
   }
 
-  private markFailed(policy: SpawnPolicy, state: ManagedAgentState, error: string): void {
+  private async markFailed(policy: SpawnPolicy, state: ManagedAgentState, error: string): Promise<void> {
     const failures = state.consecutiveFailures + 1;
-    const next = upsertManagedAgentState({
+    const next = (await upsertManagedAgentStateAsync({
       policyName: policy.name,
       status: "failed",
       agentId: undefined,
@@ -674,10 +680,10 @@ export class LifecycleManager {
       consecutiveFailures: failures,
       backoffUntil: isStewardPolicy(policy) ? this.now() + this.backoffDelay(policy, state) * 1000 : undefined,
       lastError: error,
-    });
-    this.emitState(next);
+    }));
+    (await this.emitState(next));
     // #1021 A3 — failed policies require an explicit wake/operator action. Surface the failure.
-    escalateManagedSpawnFailure(policy, next, { phase: "failed", error });
+    void fireAndForget(`[lifecycle] escalate ${policy.name}`, () => escalateManagedSpawnFailure(policy, next, { phase: "failed", error }));
   }
 
   private backoffDelay(policy: SpawnPolicy, state: ManagedAgentState | null): number {
@@ -687,16 +693,16 @@ export class LifecycleManager {
     return schedule[index]!;
   }
 
-  private resetBackoffAfterHealthyRun(policy: SpawnPolicy, state: ManagedAgentState): void {
+  private async resetBackoffAfterHealthyRun(policy: SpawnPolicy, state: ManagedAgentState): Promise<void> {
     if (state.consecutiveFailures === 0) return;
     const healthySince = state.healthySince ?? state.lastSpawnAt;
     if (!healthySince || this.now() - healthySince < policy.backoff.resetAfterSeconds * 1000) return;
-    const next = updateManagedAgentState(policy.name, {
+    const next = (await updateManagedAgentStateAsync(policy.name, {
       consecutiveFailures: 0,
       backoffUntil: undefined,
       lastError: undefined,
-    });
-    if (next) this.emitState(next);
+    }));
+    if (next) (await this.emitState(next));
   }
 
   private dailyRestartDue(_policy: SpawnPolicy, state: ManagedAgentState): boolean {
@@ -760,10 +766,10 @@ export class LifecycleManager {
   // emitManagedState (src/services/managed-running.ts) so the registration service
   // and this lifecycle reconciler emit identically (epic #342). We track the prior
   // status per policy here only to compute the from→to for the transition row.
-  private emitState(state: ManagedAgentState, reason?: string): void {
+  private async emitState(state: ManagedAgentState, reason?: string): Promise<void> {
     const previous = this.lastStatusByPolicy.get(state.policyName);
     this.lastStatusByPolicy.set(state.policyName, state.status);
-    emitManagedState(state, previous, reason, this.now);
+    (await emitManagedState(state, previous, reason, this.now));
     if (state.status === "stopped" && state.lastStopAt && this.loadPolicies().some(policy => policy.name === state.policyName && isStewardPolicy(policy))) {
       void retryStewardLandsAfterSlotFreed().catch(error => console.warn(`[steward] slot recovery failed: ${errMessage(error)}`));
     }
@@ -774,7 +780,7 @@ export class LifecycleManager {
   // event (banner) and a persisted activity event (timeline). Observability only —
   // it does not mutate agent status, since a live process may still have a dead
   // relay connection.
-  private emitLivenessMismatch(agentId: string, policyName: string | undefined, spawnRequestId: string | undefined, detail: string): void {
+  private async emitLivenessMismatch(agentId: string, policyName: string | undefined, spawnRequestId: string | undefined, detail: string): Promise<void> {
     emitRelayEvent({
       type: "liveness.mismatch",
       source: "lifecycle-manager",
@@ -783,7 +789,7 @@ export class LifecycleManager {
     });
     // #1912 §4 retained: orchestrator-report reconciliation is a synchronous projection loop;
     // changing only its audit to a detached promise would make dashboard event order ambiguous.
-    createActivityEvent({
+    (await createActivityEventAsync({
       clientId: `liveness-mismatch-${agentId}-${this.now()}-${++this.transitionSeq}`,
       kind: "state",
       title: `Liveness mismatch: ${agentId}`,
@@ -792,11 +798,11 @@ export class LifecycleManager {
       view: "managed-agents",
       agentId,
       metadata: { source: "lifecycle-manager", policyName, spawnRequestId, mismatch: true, detail },
-    });
+    }));
   }
 
-  private reconcileWorkspacesForAgent(agentId: string): void {
-    requestAgentExitCleanup(agentId);
+  private async reconcileWorkspacesForAgent(agentId: string): Promise<void> {
+    (await requestAgentExitCleanup(agentId));
   }
 
 }