@humwick/server 0.130.2 → 0.130.4

package/src/workspace-config.ts

@@ -3,5 +3,5 @@ import type { WorkspaceConfig } from "@humwick/sdk";
 // Single source for the isolated-worktree symlink default (config-store + settings registry).
 // Only the untracked rig config is linked; AGENTS.md is tracked (#3516), so a worktree gets it from git.
 export const WORKSPACE_CONFIG_DEFAULTS: WorkspaceConfig = {
-  symlinkPaths: [".claude-rig"],
+  symlinkPaths: [],
 };

package/src/workspace-conflict-resolver.ts

@@ -81,7 +81,8 @@ async function withdrawArmedLand(ws: WorkspaceRecord, reason: string): Promise<"
 export async function handBackLandConflict(ws: WorkspaceRecord, now: number, why: string): Promise<ConflictHandback> {
   const meta = ws.metadata as Record<string, unknown>;
   if (conflictHandedBackForArm(meta)) return "skipped";
-  const instructions = handbackInstructions(ws, why);
+  const cause = typeof meta.mergeError === "string" ? meta.mergeError : undefined;
+  const instructions = handbackInstructions(ws, cause && !why.includes(cause) ? `${why}: ${cause}` : why);
   const withdrawn = await withdrawArmedLand(ws, instructions);
   // The steward's shutdown fences the row out of every other lane until it settles: the sweep
   // retries this pending hand-back (workspace-steward-watchdog.ts), never the steward path.
@@ -106,7 +107,7 @@ export async function handBackLandConflict(ws: WorkspaceRecord, now: number, why
     // One notice per recipient: it also wakes the owner, so no separate `landed-failure` (whose per-arm key
     // the land-conflict Task notice already holds). A notify failure falls through to the operator alarm.
     try {
-      routeNotification({
+      await routeNotification({
         type: "workspace.stranded_escalation", forceDelivery: true, ttlMs: null,
         scope: { workspaceId: ws.id, repoRoot: ws.repoRoot, author: ws.ownerAgentId, parent: coordinator ?? undefined },
         recipients,
@@ -130,14 +131,14 @@ export async function handBackLandConflict(ws: WorkspaceRecord, now: number, why
     }
   }
 
-  raiseOperatorAlarm({
+  (await raiseOperatorAlarm({
     clientId: `steward-handoff-unescalatable-${ws.id}:${strandKey}`,
     source: "workspace-steward-handoff-watchdog",
     subject: "Land conflict has no one to hand it back to",
     detail: `${branchLabel} in ${ws.repoRoot} has an unresolved land conflict and no owner, coordinator, or fallback to hand it back to (${why}). Configure AGENT_RELAY_WORKSPACE_STEWARD_FALLBACK or land/reclaim the worktree manually.`,
     view: "orchestrators",
     metadata: { maintenanceJobId: "workspace-steward-handoff-watchdog", workspaceId: ws.id, repoRoot: ws.repoRoot, branch: ws.branch, reason: why },
-  });
+  }));
   await transitionWorkspaceLandStateAsync(ws.id, "merge-error", { stewardHandoffEscalatedAt: now, stewardUnavailable: true, conflictHandbackPending: undefined, ...stewardEnded });
   if (withdrawn === "none") await finishWorkspaceStewardHandoff(ws);
   await createActivityEventAsync({
@@ -167,14 +168,15 @@ export async function superviseLandConflict(ws: WorkspaceRecord, reason: string,
 
 const inFlight = new Set<Promise<unknown>>();
 
-/** Fire-and-forget form for settle paths that must not await the wake (#1790). */
-export function superviseLandConflictLater(workspaceId: string, reason: string, opts: { tip?: string } = {}): void {
+/** Track the wake so deferred settle queues can drain its committed effects (#1790/#1870). */
+export function superviseLandConflictLater(workspaceId: string, reason: string, opts: { tip?: string } = {}): Promise<void> {
   const ws = getWorkspace(workspaceId);
-  if (!ws) return;
+  if (!ws) return Promise.resolve();
   const run = superviseLandConflict(ws, reason, opts)
     .catch((error) => console.warn(`[workspace-conflict-resolver] supervising ${workspaceId} failed; the hand-off watchdog retries: ${errMessage(error)}`))
     .finally(() => inFlight.delete(run));
   inFlight.add(run);
+  return run.then(() => {});
 }
 
 export async function settleConflictSupervisionForTests(): Promise<void> {

package/src/workspace-dead-owner-recovery.ts

@@ -1,19 +1,20 @@
+import { createCommandAsync } from "./commands-write";
 // Host-bound rescue for an unpushed dead-owner workspace. Kept separate from
 // the orphan sweep so command construction remains reusable without inflating
 // the disk⇄DB reconciler.
 import type { WorkspaceRecord } from "./types";
-import { createCommand } from "./commands-db";
+
 import { emitCommandEvent } from "./command-events";
 
-export function dispatchDeadOwnerRescue(orch: { agentId: string }, workspace: WorkspaceRecord): string {
-  const command = createCommand({
+export async function dispatchDeadOwnerRescue(orch: { agentId: string }, workspace: WorkspaceRecord): Promise<string> {
+  const command = (await createCommandAsync({
     type: "workspace.reconcile", source: "system", target: orch.agentId, correlationId: workspace.id,
     params: {
       action: "reconcile", workspaceId: workspace.id, repoRoot: workspace.repoRoot,
       worktreePath: workspace.worktreePath, branch: workspace.branch, baseRef: workspace.baseRef,
       baseSha: workspace.baseSha, autoReclaim: "dead-owner", requestedBy: "workspace-dead-owner-reaper", requestedAt: Date.now(),
     },
-  });
+  }));
   emitCommandEvent(command, `command.${command.status}`);
   return command.id;
 }

package/src/workspace-escalation.ts

@@ -1,5 +1,6 @@
+import { claimWorkspaceHumanEscalationAlertAsync } from "./db/runtime-tail-async";
 import { stewardFallbackTarget } from "./config";
-import { claimWorkspaceHumanEscalationAlert } from "./db";
+
 import { routeNotification } from "./notification-router";
 import { raiseOperatorAlarm } from "./operator-alarm";
 import { resolveStewardIdentity } from "./steward-identity";
@@ -18,7 +19,7 @@ export interface WorkspaceCustodyEscalationInput {
   idempotencyKey?: string;
 }
 
-export function routeWorkspaceCustodyEscalation(input: WorkspaceCustodyEscalationInput): string[] {
+export async function routeWorkspaceCustodyEscalation(input: WorkspaceCustodyEscalationInput): Promise<string[]> {
   const { ownerAgentId, coordinatorAgentId } = resolveStewardIdentity(input.workspace);
   const fallback = stewardFallbackTarget();
   const recipients = [...new Set([ownerAgentId, coordinatorAgentId, fallback].filter((value): value is string => Boolean(value)))];
@@ -31,7 +32,7 @@ export function routeWorkspaceCustodyEscalation(input: WorkspaceCustodyEscalatio
     // the caller's idempotencyKey (which already bakes in the condition
     // fingerprint) so an unchanged condition never re-sends, while a real change
     // (new key) still alerts.
-    if (input.idempotencyKey && !claimWorkspaceHumanEscalationAlert(input.idempotencyKey)) {
+    if (input.idempotencyKey && !(await claimWorkspaceHumanEscalationAlertAsync(input.idempotencyKey))) {
       const channelId = workspaceHumanEscalationChannelId();
       return channelId ? [channelId] : [];
     }
@@ -41,18 +42,18 @@ export function routeWorkspaceCustodyEscalation(input: WorkspaceCustodyEscalatio
       ownerAgentId,
       fallbackTarget: fallback || undefined,
     };
-    const human = notifyWorkspaceHumanEscalation({
+    const human = (await notifyWorkspaceHumanEscalation({
       subject: input.subject,
       body: input.body,
       payload,
       source: "workspace-custody",
-    });
+    }));
     if (human.accepted && human.channelId) return [human.channelId];
     console.warn(`[workspace-escalation] zero agent recipients and no human channel for workspace ${input.workspace.id}: ${human.reason ?? "unknown reason"}`);
     return [];
   }
 
-  routeNotification({
+  await routeNotification({
     type: input.type ?? "workspace.stranded_escalation",
     scope: {
       workspaceId: input.workspace.id,
@@ -84,13 +85,13 @@ export function routeWorkspaceCustodyEscalation(input: WorkspaceCustodyEscalatio
 // undefined) and most `review_requested` auto-abandons have no agent to page by default,
 // so without this the notice is swallowed and the strand loops in the dark. Returns the
 // (possibly empty) recipient list so the caller can still decide whether to stamp state.
-export function routeWorkspaceCustodyEscalationOrAlarm(
+export async function routeWorkspaceCustodyEscalationOrAlarm(
   input: WorkspaceCustodyEscalationInput & { source: string },
-): string[] {
+): Promise<string[]> {
   const { source, ...escalation } = input;
-  const targets = routeWorkspaceCustodyEscalation(escalation);
+  const targets = await routeWorkspaceCustodyEscalation(escalation);
   if (!targets.length) {
-    raiseOperatorAlarm({
+    (await raiseOperatorAlarm({
       clientId: `${escalation.idempotencyKey ?? `${escalation.workspace.id}:${escalation.subject}`}:no-recipients`,
       source,
       subject: escalation.subject,
@@ -101,7 +102,7 @@ export function routeWorkspaceCustodyEscalationOrAlarm(
         branch: escalation.workspace.branch,
         status: escalation.workspace.status,
       },
-    });
+    }));
   }
   return targets;
 }

package/src/workspace-human-escalation.ts

@@ -43,7 +43,7 @@ export function warnIfNoHumanReachableEscalationTarget(log: (message: string) =>
   return true;
 }
 
-export function notifyWorkspaceHumanEscalation(input: WorkspaceHumanEscalationInput): WorkspaceHumanEscalationResult {
+export async function notifyWorkspaceHumanEscalation(input: WorkspaceHumanEscalationInput): Promise<WorkspaceHumanEscalationResult> {
   const channelId = workspaceHumanEscalationChannelId();
   if (!channelId) return { accepted: false, reason: "no human escalation channel configured" };
   if (!getChannel(channelId)) return { accepted: false, reason: `human escalation channel ${channelId} is not registered` };
@@ -59,9 +59,9 @@ export function notifyWorkspaceHumanEscalation(input: WorkspaceHumanEscalationIn
 
   try {
     if (channelId === DEFAULT_NTFY_CHANNEL_ID) {
-      relayNotifyNtfy(event, input.idempotencyKey);
+      (await relayNotifyNtfy(event, input.idempotencyKey));
     } else {
-      relayEgressToChannel({ channelId, event }, undefined, input.idempotencyKey);
+      (await relayEgressToChannel({ channelId, event }, undefined, input.idempotencyKey));
     }
     return { accepted: true, channelId };
   } catch (error) {

package/src/workspace-land-gate-watchdog.ts

@@ -41,21 +41,21 @@ export async function runLandGateFailureWatchdog(opts: { now?: number; delayMs?:
     const coordinator = resolveCoordinatorAgentId(owner);
     const target = coordinator ?? stewardFallbackTarget() ?? owner;
     if (!target) {
-      raiseOperatorAlarm({
+      (await raiseOperatorAlarm({
         clientId: `land-gate-failed-unescalatable:${fresh.id}:${failure.notifiedAt}`,
         source: "workspace-land-gate-watchdog",
         subject: "Land gate failure has no escalation recipient",
         detail: `${fresh.branch ?? fresh.id} remains blocked by required gate ${failure.gateName ?? "(unknown)"} with no author, coordinator, or configured fallback.`,
         view: "orchestrators",
         metadata: { workspaceId: fresh.id, repoRoot: fresh.repoRoot, branch: fresh.branch, gateName: failure.gateName },
-      });
+      }));
       await patchWorkspaceMetadataAsync(fresh.id, { landGateFailureEscalatedAt: now });
       escalated.push(fresh.id);
       continue;
     }
     const targetAgent = getAgent(target);
     const enabled = notificationEnabledFor("workspace.land_gate_failed", { agentId: target, teamId: targetAgent?.teamId });
-    routeNotification({
+    await routeNotification({
       type: "workspace.land_gate_failed",
       scope: { author: owner, parent: coordinator ?? undefined, repoRoot: fresh.repoRoot, workspaceId: fresh.id },
       recipients: [target],

package/src/workspace-land-refusal.ts

@@ -0,0 +1,20 @@
+import type { WorkspaceRecord } from "@humwick/sdk";
+import { updateWorkspaceStatusAsync } from "./db";
+import { notifyBranchLandFailed } from "./branch-landed";
+import { deferLandSettleSideEffect } from "./land-settle-dispatch";
+import { landStoppedFact, recordLandStopped } from "./workspace-land-stopped";
+
+export class LandConfigurationError extends Error {}
+
+/** A new delivery arms a new hand-off; base movement cannot repair a refused configuration (#3824). */
+export function workspaceLandRefused(workspace: WorkspaceRecord): boolean {
+  const stop = landStoppedFact(workspace.metadata);
+  return stop?.reason === "refused" && stop.handoff === workspace.metadata.landRequestAttemptAt;
+}
+
+export async function refuseWorkspaceLand(workspace: WorkspaceRecord, reason: string, commandId?: string): Promise<void> {
+  if (workspaceLandRefused(workspace)) return;
+  const current = await updateWorkspaceStatusAsync(workspace.id, "review_requested", { mergeError: reason });
+  await recordLandStopped(workspace.id, "refused", reason, { final: true });
+  deferLandSettleSideEffect("land-refused", () => notifyBranchLandFailed({ workspace: current ?? workspace, commandId, reason }));
+}

package/src/workspace-land-stopped.ts

@@ -5,6 +5,7 @@ import { getWorkspace, patchWorkspaceMetadataAsync } from "./db";
 import type { WorkspaceRecord } from "./types";
 
 export type LandStopReason =
+  | "refused"
   | "no-progress"
   | "nothing-to-land"
   | "retry-exhausted"

package/src/workspace-merge.ts

@@ -1,3 +1,5 @@
+import { acquireMergeLeaseAsync, releaseMergeLeaseAsync } from "./db/runtime-tail-async";
+import { LandConfigurationError, refuseWorkspaceLand } from "./workspace-land-refusal";
 import { capturedDeliveryGateRefusal } from "./services/captured-delivery-gate";
 import { ValidationError } from "./db/connection";
 import { WORKSPACE_MERGE_HOLD_MESSAGE } from "./db/workspace-merge-hold";
@@ -6,19 +8,7 @@ import { resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import { errMessage, isRecord, stringValue, type LandingContainmentMode } from "@humwick/sdk";
 import { cancelPendingLegacyLandingsAsync, createLegacyLandingAsync } from "./commands-landing-async";
-import {
-  acquireMergeLease,
-  exitCertificateMatchesInstance,
-  getActiveMergePause,
-  getAgent,
-  listAgents,
-  listOrchestrators,
-  patchWorkspaceMetadataAsync,
-  releaseMergeLease,
-  REVIEW_HOLD_REJECT_MESSAGE,
-  updateWorkspaceStatusAsync,
-  workspaceLandBarrier,
-} from "./db";
+import { exitCertificateMatchesInstance, getActiveMergePause, getAgent, listAgents, listOrchestrators, patchWorkspaceMetadataAsync, REVIEW_HOLD_REJECT_MESSAGE, updateWorkspaceStatusAsync, workspaceLandBarrier } from "./db";
 import { ensureLegacyOpenLandingOwnershipAsync } from "./db/landing-ingress-async";
 import { OFFLINE_PRUNE_MS } from "./config";
 import { getLandingConfig } from "./config-store";
@@ -44,8 +34,6 @@ import type { LandingLaneIdentity } from "./landing-lane-key";
 import { archiveLandAttempt, CLEAR_LAST_ATTEMPT_VERDICT, CLEAR_MERGE_RETRY, heavyGateQueuePriorityForRetry } from "./workspace-merge-progress";
 import { coalesceWorkspaceMerge } from "./workspace-merge-dispatch";
 
-// Re-export so consumers can import the tuple from the strategy home without a
-// second import hop.
 export { AUTO_MERGE_POLICIES } from "./types";
 
 // One home for the land-strategy contract, shared by BOTH land surfaces — the HTTP
@@ -393,12 +381,7 @@ async function dispatchWorkspaceMerge(workspace: WorkspaceRecord, opts: RequestW
   // unauthorized one is refused outright instead of being silently ignored.
   const gate = resolveWorkspaceLandGate(workspace, { level: opts.gateLevel, reason: opts.gateReason, auth: opts.gateAuth });
   if (!gate.ok) return { ok: false, status: gate.status, error: gate.error };
-  // #638 — an active merge-pause is the operator's tourniquet for a merge loop on this
-  // repo. The auto-merge job already honors it (workspace-auto-merge.ts), but gate the
-  // shared dispatcher too as defense-in-depth: never let an auto-merge-originated request
-  // acquire the lease + storm while paused, regardless of which caller dispatched it. A
-  // manual/steward land (any other `requestedBy`) is the intended RECOVERY path during a
-  // pause, so it's allowed through.
+  // #638 — auto-merge honors the repo pause here too; manual/steward lands remain a recovery path.
   if (!plainGit && opts.requestedBy === "auto-merge" && getActiveMergePause(workspace.repoRoot, workspace.baseRef ?? "main")) {
     return { ok: false, status: 409, error: `auto-merge paused for ${workspace.repoRoot}` };
   }
@@ -420,9 +403,10 @@ async function dispatchWorkspaceMerge(workspace: WorkspaceRecord, opts: RequestW
   let gatePlacement: Awaited<ReturnType<typeof selectLandGateHost>>;
   try {
     gatePlacement = await selectLandGateHost(workspace, onlineOwner, laneIdentity.remoteIdentity,
-      effectiveStrategy !== "pr" && effectiveStrategy !== "auto" && gate.gate.level !== "none" ? laneIdentity.gateRequirements : undefined);
+      effectiveStrategy !== "pr" && effectiveStrategy !== "auto" && gate.gate.level !== "none" ? laneIdentity.gateRequirements : undefined, laneIdentity.gateDepsStrategy);
   } catch (error) {
-    return { ok: false, status: 409, error: errMessage(error) };
+    if (error instanceof LandConfigurationError) await refuseWorkspaceLand(workspace, error.message);
+    return { ok: false, status: error instanceof LandConfigurationError ? 422 : 409, error: errMessage(error) };
   }
   const gateHost = gatePlacement.orchestrator;
   const mergeLeaseKey = laneIdentity.remoteIdentity.startsWith("remote:") ? laneIdentity.remoteIdentity : `remote:${laneIdentity.remoteIdentity}`;
@@ -438,7 +422,7 @@ async function dispatchWorkspaceMerge(workspace: WorkspaceRecord, opts: RequestW
   let leaseAcquired = false;
   let commandCreated = false;
   if (!plainGit || gatePlacement.delegated) {
-    const lease = acquireMergeLease(mergeLeaseKey, workspace.id, opts.requestedBy);
+    const lease = (await acquireMergeLeaseAsync(mergeLeaseKey, workspace.id, opts.requestedBy));
     if (!lease.ok) {
       if (containmentMode === "cgroup-v2-close-v1") {
         await cleanupLegacyLandingReservationOnHost(gateHost, executionTreeHandle!).catch(() => false);
@@ -493,7 +477,7 @@ async function dispatchWorkspaceMerge(workspace: WorkspaceRecord, opts: RequestW
       lastWorkspaceActionAt: armAt,
     });
     if (!updated) {
-      if (leaseAcquired) releaseMergeLease({ repoRoot: mergeLeaseKey, workspaceId: workspace.id });
+      if (leaseAcquired) (await releaseMergeLeaseAsync({ repoRoot: mergeLeaseKey, workspaceId: workspace.id }));
       if (containmentMode === "cgroup-v2-close-v1") {
         await cleanupLegacyLandingReservationOnHost(gateHost, executionTreeHandle!).catch(() => false);
       }
@@ -604,7 +588,7 @@ async function dispatchWorkspaceMerge(workspace: WorkspaceRecord, opts: RequestW
   } catch (e) {
     // Acquired the lease but failed before dispatch — release it or the repo
     // stays blocked until the TTL expires.
-    if (!commandCreated && leaseAcquired) releaseMergeLease({ repoRoot: mergeLeaseKey, workspaceId: workspace.id });
+    if (!commandCreated && leaseAcquired) (await releaseMergeLeaseAsync({ repoRoot: mergeLeaseKey, workspaceId: workspace.id }));
     if (!commandCreated && containmentMode === "cgroup-v2-close-v1") {
       await cleanupLegacyLandingReservationOnHost(gateHost, executionTreeHandle!).catch(() => false);
     }

package/src/workspace-nothing-to-land-notice.ts

@@ -6,14 +6,14 @@ import { withWorkspaceTaskOwnerRoles } from "./task-owner-notices";
 import { resolveLandedTaskIds } from "./services/landed-task-attribution";
 import type { WorkspaceRecord } from "./types";
 
-export function notifyNothingToLand(workspace: WorkspaceRecord, sha: string, commandId: string, sourceHeadSha?: string): void {
+export async function notifyNothingToLand(workspace: WorkspaceRecord, sha: string, commandId: string, sourceHeadSha?: string): Promise<void> {
   const author = workspace.ownerAgentId;
   const coordinator = resolveCoordinatorAgentId(author);
   const taskOwners = resolveLandedTaskIds({ workspace, sourceHeadSha }).map(id => resolveTaskOwnerAgentId(getTaskDetail(id)));
   const recipients = withWorkspaceTaskOwnerRoles([author, coordinator, ...taskOwners], workspace);
   if (!recipients.length) return;
   const base = workspace.baseRef ?? "base";
-  routeNotification({
+  await routeNotification({
     type: "branch.landed",
     scope: { author, parent: coordinator ?? undefined, repoRoot: workspace.repoRoot, workspaceId: workspace.id },
     recipients, forceDelivery: true, ttlMs: null,

package/src/workspace-orphans.ts

@@ -1,3 +1,6 @@
+import { pruneWorkspaceOrphanAlertsAsync, pruneStaleWorkspaceHumanEscalationAlertsAsync, claimWorkspaceOrphanAlertAsync } from "./db/runtime-tail-async";
+import { dispatchOrphanCleanup } from "./workspace-cleanup-stale";
+import { emitCommandEvent } from "./command-events";
 // Orphaned-worktree reconciliation (#244). An isolated worktree on disk with no
 // live DB row is "orphaned" — left behind when a session ended without a clean
 // teardown (crash, killed runner, a reaped row). Symmetrically, a live row whose
@@ -20,8 +23,8 @@
 
 import { resolve } from "node:path";
 import type { WorkspaceMergePreview, WorkspaceOrphan, WorkspaceProbe, WorkspaceProbeWorktree, WorkspaceRecord, WorkspaceStatus } from "./types";
-import { claimWorkspaceOrphanAlert, createActivityEventAsync, getWorkspace, listOrchestrators, listWorkspaces, pruneStaleWorkspaceHumanEscalationAlerts, pruneWorkspaceOrphanAlerts, updateWorkspaceStatusAsync } from "./db";
-import { createCommand } from "./commands-db";
+import { createActivityEventAsync, getWorkspace, listOrchestrators, listWorkspaces, updateWorkspaceStatusAsync } from "./db";
+
 import { isPathWithinBase } from "./utils";
 import { IN_FLIGHT_WORKSPACE_STATUSES, TERMINAL_WORKSPACE_STATUSES, worktreeReapable, type WorktreeReapState } from "./workspace-phase";
 import { isOwnerAlive, isOwnerProcessConfirmedGone, liveAgentCwds, worktreeInUseByLiveAgent } from "./workspace-merge";
@@ -33,7 +36,6 @@ import { READY_TO_LAND_ESCALATION_STATUSES, routeWorkspaceCustodyEscalationOrAla
 import { workspaceLandBlocked } from "./land-block";
 import { dispatchDeadOwnerRescue } from "./workspace-dead-owner-recovery";
 import { runWithConcurrency, sortLeastRecentlyProbed } from "./maintenance/workspaces";
-import { emitCommandEvent } from "./command-events";
 import {
   WORKSPACE_ORPHAN_REAPER_DEAD_OWNER_PROBE_BATCH_SIZE,
   WORKSPACE_ORPHAN_REAPER_MISSING_PROBE_BATCH_SIZE,
@@ -421,27 +423,6 @@ export async function collectWorkspaceOrphans(
   return { orphans, missingWorktrees, deadOwnerWorkspaces, ...(moreOrphanEnrichmentWork ? { moreOrphanEnrichmentWork } : {}) };
 }
 
-function dispatchCleanup(orch: OnlineOrchestrator, orphan: WorkspaceOrphan): string {
-  const command = createCommand({
-    type: "workspace.cleanup",
-    source: "system",
-    target: orch.agentId,
-    params: {
-      action: "cleanup",
-      worktreePath: orphan.worktreePath,
-      repoRoot: orphan.repoRoot,
-      branch: orphan.branch,
-      baseRef: orphan.baseRef,
-      baseSha: orphan.baseSha,
-      deleteBranch: true,
-      reclaim: true,
-      requestedBy: "workspace-orphan-reaper",
-      requestedAt: Date.now(),
-    },
-  });
-  emitCommandEvent(command, `command.${command.status}`);
-  return command.id;
-}
 
 /**
  * Scheduled reaper (maintenance job). Auto-removes orphaned worktrees that are
@@ -520,7 +501,7 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
       if (!reapEnabled) continue; // detect-only mode
       if (nonTerminalRowsByPath.has(resolve(orphan.worktreePath))) continue; // still claimed — never reap (#278)
       if (worktreeInUseByLiveAgent(orphan.worktreePath, liveCwds)) continue; // a live agent runs in it — never reap its cwd
-      const commandId = dispatchCleanup(orch, orphan);
+      const commandId = (await dispatchOrphanCleanup(orch.agentId, orphan));
       reaped.push(orphan.worktreePath);
       await createActivityEventAsync({
         clientId: `workspace-orphan-reaped-${orphan.worktreePath}-${now}`,
@@ -541,7 +522,7 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
     const alertKey = `disk:${resolve(orphan.worktreePath)}`;
     liveAlertKeys.add(alertKey);
     const fingerprint = orphanAlertFingerprint({ headSha: orphan.headSha, ahead: orphan.ahead, unmergedAhead: orphan.unmergedAhead, dirty: orphan.dirty, safeToReap: orphan.safeToReap });
-    if (!claimWorkspaceOrphanAlert(alertKey, fingerprint, now)) continue;
+    if (!(await claimWorkspaceOrphanAlertAsync(alertKey, fingerprint, now))) continue;
     flagged.push(orphan.worktreePath);
     const detail = orphan.safeToReap === undefined
       ? "host could not be probed for land-state"
@@ -549,7 +530,7 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
         ? "uncommitted changes in the worktree"
         : `${orphan.unmergedAhead ?? orphan.ahead ?? "?"} un-landed commit(s)`;
     if (orphanHasWorkEvidence(orphan)) {
-      routeWorkspaceCustodyEscalationOrAlarm({
+      await routeWorkspaceCustodyEscalationOrAlarm({
         source: "workspace-orphan-reaper",
         workspace: { id: `orphan:${orphan.worktreePath}`, repoRoot: orphan.repoRoot, branch: orphan.branch, status: "review_requested", ownerAgentId: undefined },
         subject: "Stranded worktree needs attention",
@@ -586,9 +567,9 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
     const inFlight = IN_FLIGHT_WORKSPACE_STATUSES.has(workspace.status);
     if (ownerAlive || inFlight) {
       liveAlertKeys.add(key);
-      if (!claimWorkspaceOrphanAlert(key, orphanAlertFingerprint({ status: workspace.status, ownerAlive, inFlight }), now)) continue;
+      if (!(await claimWorkspaceOrphanAlertAsync(key, orphanAlertFingerprint({ status: workspace.status, ownerAlive, inFlight }), now))) continue;
       if (workspaceNeedsCustodyEscalation(workspace, false)) {
-        routeWorkspaceCustodyEscalationOrAlarm({
+        await routeWorkspaceCustodyEscalationOrAlarm({
           source: "workspace-orphan-reaper",
           workspace,
           subject: "Workspace row has no worktree on disk",
@@ -658,7 +639,7 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
       if (!updated) continue;
       autoAbandoned.push(workspace.id);
       if (workspaceNeedsCustodyEscalation(workspace, previewHasWorkEvidence(probe.kind === "preview" ? probe.preview : null))) {
-        routeWorkspaceCustodyEscalationOrAlarm({
+        await routeWorkspaceCustodyEscalationOrAlarm({
           source: "workspace-orphan-reaper",
           workspace,
           type: "workspace.auto_abandoned",
@@ -690,7 +671,7 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
 
     liveAlertKeys.add(key);
     const missingFingerprint = orphanAlertFingerprint({ status: workspace.status, probe: probe.kind, recoverableTip: probe.kind === "preview" ? probe.preview.recoverableTip : undefined, headSha: probe.kind === "preview" ? probe.preview.headSha : undefined, ahead: probe.kind === "preview" ? probe.preview.ahead : undefined, unmergedAhead: probe.kind === "preview" ? probe.preview.unmergedAhead : undefined });
-    if (!claimWorkspaceOrphanAlert(key, missingFingerprint, now)) continue;
+    if (!(await claimWorkspaceOrphanAlertAsync(key, missingFingerprint, now))) continue;
     flaggedMissingWorktrees.push(workspace.id);
     const hasWorkEvidence = probe.kind === "preview" && previewHasWorkEvidence(probe.preview);
     const detail = probe.kind === "preview"
@@ -701,7 +682,7 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
         ? `host could not confirm whether branch ${workspace.branch} has landed`
         : "host could not confirm whether recoverable branch work remains";
     if (workspaceNeedsCustodyEscalation(workspace, hasWorkEvidence)) {
-      routeWorkspaceCustodyEscalationOrAlarm({
+      await routeWorkspaceCustodyEscalationOrAlarm({
         source: "workspace-orphan-reaper",
         workspace,
         subject: "Missing-worktree workspace needs attention",
@@ -846,10 +827,10 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
     liveDeadOwnerKeys.add(flagKey);
     liveAlertKeys.add(flagKey);
     const deadOwnerFingerprint = orphanAlertFingerprint({ status: workspace.status, headSha: preview?.headSha, ahead: preview?.ahead, unmergedAhead: preview?.unmergedAhead, dirtyCount: preview?.dirtyCount, probeAvailable: Boolean(preview) });
-    if (!claimWorkspaceOrphanAlert(flagKey, deadOwnerFingerprint, now)) continue;
+    if (!(await claimWorkspaceOrphanAlertAsync(flagKey, deadOwnerFingerprint, now))) continue;
     deadOwnerFlagged.push(workspace.id);
     const rescueCommandId = preview?.originCaptureChecked === true && preview.originCaptured === false && orch
-      ? dispatchDeadOwnerRescue(orch, workspace)
+      ? (await dispatchDeadOwnerRescue(orch, workspace))
       : undefined;
     const detail = safeToReap === undefined
       ? "host could not be probed for land-state"
@@ -858,7 +839,7 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
         : `${preview?.unmergedAhead ?? preview?.ahead ?? "?"} un-landed commit(s)`;
     const hasWorkEvidence = previewHasWorkEvidence(preview);
     if (workspaceNeedsCustodyEscalation(workspace, hasWorkEvidence)) {
-      routeWorkspaceCustodyEscalationOrAlarm({
+      await routeWorkspaceCustodyEscalationOrAlarm({
         source: "workspace-orphan-reaper",
         workspace,
         subject: "Dead-owner worktree needs attention",
@@ -896,8 +877,8 @@ export async function reapOrphanedWorktrees(context: { signal?: AbortSignal } =
   // still waiting it out and re-fire orphan alerts already claimed for this condition.
   if (!signal?.aborted) {
     for (const key of deadOwnerTracker.keys()) if (!liveDeadOwnerKeys.has(key)) deadOwnerTracker.delete(key);
-    pruneWorkspaceOrphanAlerts(liveAlertKeys);
-    pruneStaleWorkspaceHumanEscalationAlerts(now, HUMAN_ESCALATION_ALERT_MAX_AGE_MS);
+    (await pruneWorkspaceOrphanAlertsAsync(liveAlertKeys));
+    (await pruneStaleWorkspaceHumanEscalationAlertsAsync(now, HUMAN_ESCALATION_ALERT_MAX_AGE_MS));
   }
 
   // #2408 — true whenever ANY of the three per-tick probe budgets left candidates un-probed this run.

package/src/workspace-pr-completion.ts

@@ -1,6 +1,8 @@
+import { createActivityEventAsync } from "./db/activity-async";
+import { createCommandAsync } from "./commands-write";
 import { isRecord } from "@humwick/sdk";
-import { createCommand, getCommand } from "./commands-db";
-import { createActivityEvent, patchWorkspaceMetadataAsync, workspaceLandBarrier } from "./db";
+import { getCommand } from "./commands-db";
+import { patchWorkspaceMetadataAsync, workspaceLandBarrier } from "./db";
 import { handleReviewerPipelineScan, isAwaitingReviewerApproval } from "./reviewer-pipeline";
 import { isOwnerAlive, requestWorkspaceMerge } from "./workspace-merge";
 import type { Command, WorkspaceAutoMergePolicy, WorkspaceMergePreview, WorkspaceRecord } from "./types";
@@ -39,7 +41,7 @@ export async function reconcileLandedPr(workspace: WorkspaceRecord, preview: Wor
     },
   });
   if (recycle.ok) {
-    createActivityEvent({
+    (await createActivityEventAsync({
       clientId: `workspace-pr-recycle-${workspace.id}-${Date.now()}`,
       kind: "state",
       title: "Workspace recycling after PR land",
@@ -48,7 +50,7 @@ export async function reconcileLandedPr(workspace: WorkspaceRecord, preview: Wor
       icon: "ti-git-merge",
       view: "orchestrators",
       metadata: { source: "server", maintenanceJobId: "workspace-conflict-scan", workspaceId: workspace.id, commandId: recycle.command.id, landedVia: "pr" },
-    });
+    }));
     return { kind: "recycle", command: recycle.command };
   }
   // 409 = lease held by an in-flight merge — retry next sweep, don't finalize (re-strands a
@@ -199,7 +201,7 @@ async function dispatchRelayPrMergeCommand(workspace: WorkspaceRecord, preview:
   const now = Date.now();
   const prNumber = preview.prNumber ?? (typeof workspace.metadata.prNumber === "number" ? workspace.metadata.prNumber : undefined);
   const prUrl = preview.prUrl ?? text(workspace.metadata.prUrl);
-  const command = createCommand({
+  const command = (await createCommandAsync({
     type: "workspace.pr-merge",
     source: "system",
     target: orchestratorAgentId,
@@ -209,7 +211,7 @@ async function dispatchRelayPrMergeCommand(workspace: WorkspaceRecord, preview:
       branch: workspace.branch, baseRef: workspace.baseRef, prNumber, prUrl, policy,
       requestedBy: "relay-pr-completion", requestedAt: now,
     },
-  });
+  }));
   await patchWorkspaceMetadataAsync(workspace.id, {
     relayMerged: true, relayMergeCommandId: command.id, relayMergeDispatchedAt: now, relayMergePolicy: policy,
     relayMergeError: undefined, relayMergeFailedAt: undefined,
@@ -221,7 +223,7 @@ async function dispatchRelayPrRefreshCommand(workspace: WorkspaceRecord, preview
   const now = Date.now();
   const prNumber = preview.prNumber ?? (typeof workspace.metadata.prNumber === "number" ? workspace.metadata.prNumber : undefined);
   const prUrl = preview.prUrl ?? text(workspace.metadata.prUrl);
-  const command = createCommand({
+  const command = (await createCommandAsync({
     type: "workspace.pr-refresh",
     source: "system",
     target: orchestratorAgentId,
@@ -231,7 +233,7 @@ async function dispatchRelayPrRefreshCommand(workspace: WorkspaceRecord, preview
       branch: workspace.branch, baseRef: workspace.baseRef, prNumber, prUrl, policy, refreshKey, attempts,
       requestedBy: "relay-pr-completion", requestedAt: now,
     },
-  });
+  }));
   await patchWorkspaceMetadataAsync(workspace.id, {
     prRefreshCommandId: command.id, prRefreshDispatchedAt: now, prRefreshPolicy: policy, prRefreshPrNumber: prNumber,
     prRefreshKey: refreshKey, prRefreshAttempts: attempts, prRefreshError: undefined, prRefreshFailedAt: undefined,

package/src/workspace-rekey.ts

@@ -55,7 +55,7 @@ export function fenceWorkspaceRekeyCommand(commandId: string): Promise<{ fenced:
 export async function drainStewardRekeyNotices(): Promise<void> {
   for (const row of pendingStewardRekeyNotices()) {
     try {
-      const routed = notifyTaskCoordinatorOfRekey(row);
+      const routed = await notifyTaskCoordinatorOfRekey(row);
       if (routed) await getGateway().write("workspaceRekey.noticeSent", { eventId: row.id });
     } catch (error) {
       console.warn(`[steward-rekey] notice for task event ${row.id} failed; retrying later: ${error}`);
@@ -63,7 +63,7 @@ export async function drainStewardRekeyNotices(): Promise<void> {
   }
 }
 
-function notifyTaskCoordinatorOfRekey(row: StewardRekeyNoticeRow): boolean {
+async function notifyTaskCoordinatorOfRekey(row: StewardRekeyNoticeRow): Promise<boolean> {
   const task = getTaskDetail(row.task_id);
   if (!task) return false;
   const m = parseJson<Record<string, unknown>>(row.metadata, {});
@@ -82,7 +82,7 @@ function notifyTaskCoordinatorOfRekey(row: StewardRekeyNoticeRow): boolean {
     ...(rewritten.length ? [`${rewritten.length} commit(s) changed patch identity`] : []),
     ...(merges.length ? [`${merges.length} merge commit(s) were re-resolved and cannot be verified by patch-id`] : []),
   ];
-  const delivered = routeNotification({
+  const delivered = await routeNotification({
     type: "task.steward_rekey",
     scope: {
       taskId: String(task.id), transition: "steward-rekey", workspaceId,

package/src/workspace-steward-failure.ts

@@ -30,13 +30,13 @@ export async function recordStewardWakeFailure(workspace: WorkspaceRecord, error
   const body = `Workspace \`${ws.id}\` (\`${ws.branch ?? ws.id}\` → \`${ws.baseRef ?? "base"}\`): ${error}. Relay will retry after ${Math.ceil(STEWARD_HANDOFF_WATCHDOG_MS / 60_000)} minutes. ${stewardRecoveryAdvice(ws.baseRef ?? "main", capExhausted)}`;
   const payload = { kind: "workspace.steward-spawn-failed", workspaceId: ws.id, branch: ws.branch, reason: error };
   if (recipients.length) {
-    routeNotification({
+    await routeNotification({
       type: "workspace.stranded_escalation", forceDelivery: true, ttlMs: null,
       scope: { workspaceId: ws.id, repoRoot: ws.repoRoot, author: ownerAgentId, parent: coordinatorAgentId ?? undefined },
       recipients, message: { subject, body, payload, idempotencyKey: `steward-spawn-failed:${ws.id}:${failureId}` },
     });
   } else {
-    raiseOperatorAlarm({ clientId: `steward-spawn-failed:${ws.id}:${failureId}`, source: "workspace-steward-failure", subject, detail: body, dedupeEvent: true, metadata: payload });
+    (await raiseOperatorAlarm({ clientId: `steward-spawn-failed:${ws.id}:${failureId}`, source: "workspace-steward-failure", subject, detail: body, dedupeEvent: true, metadata: payload }));
   }
   await patchWorkspaceMetadataAsync(ws.id, { stewardWakeFailureNotifiedAt: now });
 }

package/src/workspace-steward-wake.ts

@@ -92,7 +92,7 @@ export async function wakeRepoSteward(ws: WorkspaceRecord, reason: string, opts:
         stewardHandoffEscalatedAt: undefined, stewardRewakeCount: undefined,
       } : {}),
     });
-    routeNotification({
+    await routeNotification({
       type: "workspace.steward_task",
       scope: { workspaceId: ws.id, repoRoot: ws.repoRoot, author: ownerAgentId, parent: coordinatorAgentId ?? undefined },
       recipients: [`policy:${policyName}`],
@@ -139,7 +139,7 @@ export async function wakeRepoSteward(ws: WorkspaceRecord, reason: string, opts:
       }, attempt < STEWARD_WAKE_STAMP_ATTEMPTS ? current : undefined);
       if (!stamped) continue;
       if (current.landState === "merge-error") await transitionWorkspaceLandStateAsync(ws.id, "steward-requested");
-      notifyStewardHandoff({ workspace: ws, stewardId: policyName, coordinatorAgentId, reason });
+      await notifyStewardHandoff({ workspace: ws, stewardId: policyName, coordinatorAgentId, reason });
       return { ok: true, policy: policyName };
     }
   } catch (e) {

package/public/assets/agent-liveness-CaNwK0Zf.js

@@ -1,2 +0,0 @@
-import{T as e}from"./display-BrKWFGJz.js";function t(t,n){return!!n&&n.status!==`offline`&&!e(t,n)}export{t};
-//# sourceMappingURL=agent-liveness-CaNwK0Zf.js.map