@humwick/server 0.130.1 → 0.130.3

package/src/services/task-lifecycle.ts

@@ -1,3 +1,5 @@
+import { markTaskAgentReapedAsync } from "../db/task-entity-async";
+import { markWorkspaceCarryPendingAsync } from "../db/runtime-tail-async";
 // #831 — Task lifecycle automation ON LAND. The land event already knows the branch, commit,
 // backlink, and (worker-reported) gate ledger; this service turns that authoritative land into
 // the Task drive the coordinator otherwise hand-does (~40% of its tool calls): advance the
@@ -24,13 +26,7 @@
 import { errMessage } from "@humwick/sdk";
 import { boundTaskIdsForWorkspace } from "./workspace-task-binding";
 import { resolveLandedTaskIds, type LandedTaskAttributionInput } from "./landed-task-attribution";
-import {
-  activeWorkspaceCarryPendingHeadsForTask,
-  getAgent,
-  getTaskDetail,
-  markTaskAgentReaped,
-  markWorkspaceCarryPending,
-} from "../db";
+import { activeWorkspaceCarryPendingHeadsForTask, getAgent, getTaskDetail } from "../db";
 import { setTaskEntityStage, setTaskEntityStatus } from "./task-entity";
 import { carryPendingBlocker, carryPendingDiscardedHead, isCarryPendingBlocker, openCarryPendingBlocker } from "./carry-pending";
 import { postTaskMilestoneComment, taskCloseBridgeAsync, type TaskCloseBridgeEntry } from "./task-issue-weave";
@@ -142,13 +138,13 @@ export interface CarryPendingMarkResult {
 //     records a second blocker rather than being swallowed as idempotent. SCOPED (preserves other
 //     blockers); never reopens a terminal Task.
 // FAILS CLOSED: a swallowed marking failure would silently drop the guard, so failures flip `ok`.
-export function markWorkspaceTasksCarryPending(workspace: LifecycleWorkspace, discardedHead: string, log: LogFn = (m) => console.warn(m)): CarryPendingMarkResult {
+export async function markWorkspaceTasksCarryPending(workspace: LifecycleWorkspace, discardedHead: string, log: LogFn = (m) => console.warn(m)): Promise<CarryPendingMarkResult> {
   const head = discardedHead.trim();
   if (!head) return { ok: true, marked: [], failed: [] };
   // 1) DURABLE WORKSPACE MARKER FIRST — its successful persistence is half the fail-closed signal.
   let markerRecorded = false;
   try {
-    markerRecorded = markWorkspaceCarryPending(workspace.id, head);
+    markerRecorded = (await markWorkspaceCarryPendingAsync(workspace.id, head));
   } catch (error) {
     log(`#1456 carry-pending workspace marker write failed for ${workspace.id}: ${errMessage(error)}`);
   }
@@ -163,7 +159,7 @@ export function markWorkspaceTasksCarryPending(workspace: LifecycleWorkspace, di
     // Already have a blocker for THIS exact head? nothing to add (idempotent per head).
     if (existing.some((b) => isCarryPendingBlocker(b) && carryPendingDiscardedHead(b) === head)) { marked.push(taskId); continue; }
     try {
-      setTaskEntityStatus(taskId, {
+      await setTaskEntityStatus(taskId, {
         status: "blocked",
         blockedBy: [...existing, carryPendingBlocker(head)],
         note: `#1456 carry-pending: delivered head ${head} was reverted (moved base); it must be confirmed carried before landing`,
@@ -227,7 +223,7 @@ function landKeyFor(input: LandedTaskLifecycleInput): string {
   return `land:${base}:${input.workspace.id}:${input.workspace.branch ?? "unknown"}`.slice(0, 240);
 }
 
-export function emitWorkspaceTaskSemanticNotifications(input: {
+export async function emitWorkspaceTaskSemanticNotifications(input: {
   workspace: LifecycleWorkspace;
   transition: TaskSemanticTransition;
   actor?: string;
@@ -235,13 +231,13 @@ export function emitWorkspaceTaskSemanticNotifications(input: {
   idempotencyKey?: string;
   outcome?: Record<string, unknown>;
   sha?: string;
-}): number[] {
+}): Promise<number[]> {
   const emitted: number[] = [];
   const coordinator = resolveCoordinatorAgentId(input.workspace.ownerAgentId ?? undefined);
   for (const taskId of boundTaskIdsForWorkspace(input.workspace)) {
     const task = getTaskDetail(taskId);
     if (!task) continue;
-    emitTaskSemanticNotification({
+    await emitTaskSemanticNotification({
       task,
       transition: input.transition,
       actor: input.actor,
@@ -273,7 +269,7 @@ interface ReapResult {
 // exist (already gone → nothing to reap) and be `transient` (one-shot); a `persistent` worker
 // keeps running (land-and-continue). Idempotent: any bound Task already stamped `reapedAt` short-
 // circuits, so a re-land never re-reaps. Reuses the reaper's canonical shutdown path.
-function maybeReapOwnerWorker(workspace: LifecycleWorkspace, outcomes: TaskLandOutcome[]): ReapResult {
+async function maybeReapOwnerWorker(workspace: LifecycleWorkspace, outcomes: TaskLandOutcome[]): Promise<ReapResult> {
   const driven = outcomes.filter((outcome) => !outcome.error);
   if (driven.length === 0) return { reaped: false, reason: "no-task-driven" };
   const agentId = workspace.ownerAgentId?.trim();
@@ -295,7 +291,7 @@ function maybeReapOwnerWorker(workspace: LifecycleWorkspace, outcomes: TaskLandO
   const blocker = automaticDisposalBlocker(agent, Date.now(), { requireIdle: false });
   if (blocker === "pending-own-run") return { reaped: false, agentId, reason: "pending-own-relay-run" };
   if (blocker) return { reaped: false, agentId, reason: blocker };
-  requestTransientAgentShutdown(agent, {
+  (await requestTransientAgentShutdown(agent, {
     reason: "deliverable-landed",
     requestedBy: "task-lifecycle",
     workspaceId: workspace.id,
@@ -303,13 +299,13 @@ function maybeReapOwnerWorker(workspace: LifecycleWorkspace, outcomes: TaskLandO
     activityTitle: "One-shot worker reaped on land",
     activityBody: `All ${driven.length} bound deliverable(s) landed green; disposing one-shot worker ${agentId} to free its slot + quota`,
     landReason: "deliverable-landed",
-  });
+  }));
   return { reaped: true, agentId };
 }
 
 // Stamp the reap marker on every bound Task + annotate the outcomes (the reap is decided ONCE at
 // owner level, then applied across the owner's tasks).
-function finalizeReap(outcomes: TaskLandOutcome[], reap: ReapResult, log: LogFn): void {
+async function finalizeReap(outcomes: TaskLandOutcome[], reap: ReapResult, log: LogFn): Promise<void> {
   for (const outcome of outcomes) {
     if (outcome.error) continue;
     outcome.reaped = reap.reaped;
@@ -317,10 +313,10 @@ function finalizeReap(outcomes: TaskLandOutcome[], reap: ReapResult, log: LogFn)
     if (reap.reason) outcome.reapSkipReason = reap.reason;
     if (reap.reaped && reap.agentId) {
       try {
-        markTaskAgentReaped(outcome.taskId, { agentId: reap.agentId, reason: "deliverable-landed" });
+        (await markTaskAgentReapedAsync(outcome.taskId, { agentId: reap.agentId, reason: "deliverable-landed" }));
         const task = getTaskDetail(outcome.taskId);
         if (task && task.status !== "done" && isAgentExitDoneWhen(task.doneWhen)) {
-          setTaskEntityStatus(outcome.taskId, {
+          await setTaskEntityStatus(outcome.taskId, {
             status: validationCompletionStatus(task.validationItems),
             note: "doneWhen=agent-exit satisfied by worker reap after land",
             actor: "task-lifecycle",
@@ -375,7 +371,7 @@ async function driveTaskOnLand(
     if (wsHeads.length > 0) {
       carryHead = wsHeads[0];
       try {
-        setTaskEntityStatus(taskId, {
+        await setTaskEntityStatus(taskId, {
           status: "blocked",
           blockedBy: [...(before.blockedBy ?? []), ...wsHeads.map(carryPendingBlocker)],
           note: `#1456 carry-pending (inherited from workspace ${input.workspace.id}): delivered head(s) ${wsHeads.join(", ")} were reverted; confirm the carry before landing`,
@@ -405,7 +401,7 @@ async function driveTaskOnLand(
   // 1 + 2 (deliverable-position axis) — advance the stage to `landed-on-main` and ATTACH the
   // landed commit (idempotent append). The execution `status` axis is handled separately below.
   const commit = input.mergedSha ? { sha: input.mergedSha, ...(input.subject ? { subject: input.subject } : {}) } : undefined;
-  let detail = setTaskEntityStage(taskId, {
+  let detail = await setTaskEntityStage(taskId, {
     deliverableStage: "landed-on-main",
     ...(input.workspace.branch ? { branch: input.workspace.branch } : {}),
     ...(commit ? { commit } : {}),
@@ -480,14 +476,14 @@ async function driveTaskOnLand(
 // the owner-level reap decision so `reaped` is accurate. A deliverable-LEVEL event ("task
 // deliverable landed", not "commit X merged") through the existing bus; #835 enriches the
 // audience/subscription layer on top of this same event.
-function emitDeliverableLandedEvent(input: LandedTaskLifecycleInput, outcome: TaskLandOutcome): void {
+async function emitDeliverableLandedEvent(input: LandedTaskLifecycleInput, outcome: TaskLandOutcome): Promise<void> {
   const landKey = landKeyFor(input);
   if (outcome.deliveredTipSuperseded) {
-    emitDeliverableSupersededEvent(input, outcome, landKey);
+    await emitDeliverableSupersededEvent(input, outcome, landKey);
     return;
   }
   if (outcome.error) {
-    emitDeliverableErrorReceipt(input, outcome, landKey);
+    await emitDeliverableErrorReceipt(input, outcome, landKey);
     return;
   }
   emitRelayEvent({
@@ -513,7 +509,7 @@ function emitDeliverableLandedEvent(input: LandedTaskLifecycleInput, outcome: Ta
   const task = getTaskDetail(outcome.taskId);
   if (!task) return;
   const coordinator = resolveCoordinatorAgentId(input.workspace.ownerAgentId ?? undefined);
-  emitTaskSemanticNotification({
+  await emitTaskSemanticNotification({
     task,
     transition: "landed-on-main",
     actor: "task-lifecycle",
@@ -530,7 +526,7 @@ function emitDeliverableLandedEvent(input: LandedTaskLifecycleInput, outcome: Ta
 // be proven to have reached `main` after a moved-base revert. Routed durably (ttl null) to the
 // coordinator AND the branch owner so it is confirmed/re-landed — the Task was held at `blocked`
 // (non-terminal, recoverable), NOT landed-on-main, so the tracker never reports a phantom landing.
-function emitDeliverableSupersededEvent(input: LandedTaskLifecycleInput, outcome: TaskLandOutcome, landKey: string): void {
+async function emitDeliverableSupersededEvent(input: LandedTaskLifecycleInput, outcome: TaskLandOutcome, landKey: string): Promise<void> {
   emitRelayEvent({
     type: "task.deliverable_landed",
     source: "server",
@@ -558,7 +554,7 @@ function emitDeliverableSupersededEvent(input: LandedTaskLifecycleInput, outcome
   const createdBy = task?.createdBy?.trim();
   const recipients = [...new Set([coordinator, taskOwnerTarget(task), owner].filter((r): r is string => Boolean(r)))];
   if (recipients.length === 0) return;
-  routeNotification({
+  await routeNotification({
     type: "task.land_conflict",
     scope: {
       taskId: String(outcome.taskId),
@@ -594,13 +590,13 @@ function emitDeliverableSupersededEvent(input: LandedTaskLifecycleInput, outcome
   });
 }
 
-function emitDeliverableErrorReceipt(input: LandedTaskLifecycleInput, outcome: TaskLandOutcome, landKey: string): void {
+async function emitDeliverableErrorReceipt(input: LandedTaskLifecycleInput, outcome: TaskLandOutcome, landKey: string): Promise<void> {
   const coordinator = resolveCoordinatorAgentId(input.workspace.ownerAgentId ?? undefined);
   const task = getTaskDetail(outcome.taskId);
   const ownerTarget = task?.owner ? taskOwnerTarget(task) : undefined;
   const recipients = [coordinator, ownerTarget].filter((id): id is string => Boolean(id)).map((agentId) => ({ agentId, matchedRule: "task-stakeholder" }));
   if (!recipients.length) return;
-  routeNotification({
+  await routeNotification({
     type: "task.landed",
     scope: {
       taskId: String(outcome.taskId),
@@ -662,7 +658,7 @@ export async function handleLandedTaskLifecycle(
   // Reap (step 5) is decided ONCE at owner level, only when ALL bound tasks are satisfied — then
   // applied/annotated across the outcomes. The deliverable event is emitted after, with the
   // accurate `reaped`.
-  finalizeReap(outcomes, maybeReapOwnerWorker(input.workspace, outcomes), log);
-  for (const outcome of outcomes) emitDeliverableLandedEvent(input, outcome);
+  await finalizeReap(outcomes, (await maybeReapOwnerWorker(input.workspace, outcomes)), log);
+  for (const outcome of outcomes) await emitDeliverableLandedEvent(input, outcome);
   return { handled: true, tasks: outcomes };
 }

package/src/services/task-repo-cwd.ts

@@ -0,0 +1,37 @@
+import { stringValue, type AgentCard } from "@humwick/sdk";
+import { getAgent, getTaskDetailAsync, getTeam, listProjects, rootsForProject, workspaceRepoRootForCwd, ValidationError } from "../db";
+import { isPathWithinBase } from "../utils";
+
+// #3769 — workflows and role spawns resolve the same Task checkout, including callers in worktrees.
+export async function taskLinkedRepoCwd(taskId: number, callerCwd?: string, caller?: AgentCard): Promise<string> {
+  const task = await getTaskDetailAsync(taskId);
+  if (!task) throw new ValidationError(`task ${taskId} not found or not a deliverable task`);
+  // #2844 — a Task created with `repo:` but no linked issue still names its project repo.
+  const repos = [...new Set([...task.issues.map((issue) => issue.repo), task.repo].filter((repo): repo is string => Boolean(repo)))];
+  if (repos.length === 0) {
+    throw new ValidationError(`task ${taskId} has no linked issue repo; pass cwd/orchestratorId explicitly`);
+  }
+  const candidates = listProjects()
+    .filter((project) => project.issueRepo && repos.includes(project.issueRepo))
+    .flatMap((project) => rootsForProject(project.id).map((root) => ({ project, root })));
+  if (candidates.length === 0) {
+    // #1627 — only registered roots can resolve a repo to a host checkout.
+    throw new ValidationError(`task ${taskId} links repo ${repos.join(", ")} but no Relay project root is registered for it, so relay cannot resolve a checkout path for it; pass cwd + orchestratorId explicitly, or register the checkout with relay_project_add_root`);
+  }
+  const team = caller?.teamId ? getTeam(caller.teamId) : null;
+  const rootTeam = team?.parentTeamId ? getTeam(team.parentTeamId) : team;
+  const coordinator = rootTeam?.coordinatorId ? getAgent(rootTeam.coordinatorId) : null;
+  const sources = [callerCwd, caller?.branchWorkspaceProjectRoot, stringValue(coordinator?.meta?.cwd)];
+  for (const source of sources) {
+    if (!source) continue;
+    const sourceCwd = workspaceRepoRootForCwd(source) ?? source;
+    const matching = candidates.filter(candidate => isPathWithinBase(sourceCwd, candidate.root.rootPath))
+      .sort((a, b) => b.root.rootPath.length - a.root.rootPath.length)[0];
+    if (matching) return matching.root.rootPath;
+  }
+  const projectId = team?.projectId ?? rootTeam?.projectId ?? task.projectId;
+  const preferred = projectId ? candidates.filter(candidate => candidate.project.id === projectId) : [];
+  const paths = [...new Set((preferred.length ? preferred : candidates).map(candidate => candidate.root.rootPath))];
+  if (paths.length === 1) return paths[0]!;
+  throw new ValidationError(`task ${taskId} links repo ${repos.join(", ")} with multiple registered roots; pass cwd explicitly`);
+}

package/src/services/task-review-hold.ts

@@ -17,19 +17,7 @@
 import { getCommandAsync } from "../commands-write";
 import { settleWorkspaceMergeCommand } from "../workspace-command-settle";
 import { errMessage, isRecord } from "@humwick/sdk";
-import {
-  ReviewHoldConflictError,
-  clearTaskReviewHoldAsync,
-  getTaskDetail,
-  getWorkspace,
-  latestClearedReviewPromotion,
-  taskPendingReviewDelivery,
-  setTaskReviewHoldAsync,
-  unsettledTaskMergeCommandIdsAsync,
-  type ClearTaskReviewHoldResult,
-  type ClearTaskReviewHoldBodyInput,
-  type SetTaskReviewHoldResult,
-} from "../db";
+import { ReviewHoldConflictError, clearTaskReviewHoldAsync, getTaskDetail, getWorkspace, latestClearedReviewPromotion, taskPendingReviewDelivery, setTaskReviewHoldAsync, unsettledTaskMergeCommandIdsAsync, type ClearTaskReviewHoldResult, type ClearTaskReviewHoldBodyInput, type SetTaskReviewHoldResult, ValidationError } from "../db";
 import { emitNewMessages, emitTaskChanged } from "../sse";
 import { routeNotification } from "../notification-router";
 import { COORDINATOR_AUTHORITY_HINT, callerHasTaskCoordinatorAuthority } from "../coordinator-authority";
@@ -42,7 +30,6 @@ import { landStoppedFact } from "../workspace-land-stopped";
 import { headLand } from "../workspace-recorded-land";
 import { reviewedHeadMatches } from "../db/task-review-hold";
 import { ServiceAuthError } from "./errors";
-import { ValidationError } from "../db";
 import type { AuthContext } from "./auth-context";
 import type { TaskDetail } from "../types";
 import { taskOwnerTarget } from "../task-owner";
@@ -79,10 +66,10 @@ export function canControlTaskReviewHold(ctx: AuthContext, task: Pick<TaskDetail
   return callerHasTaskCoordinatorAuthority(ctx.callerAgentId, task);
 }
 
-function notifyReviewHoldCleared(task: TaskDetail, promoted: { eventId: number; workspaceId: string; sourceHeadSha: string } | undefined): void {
+async function notifyReviewHoldCleared(task: TaskDetail, promoted: { eventId: number; workspaceId: string; sourceHeadSha: string } | undefined): Promise<void> {
   if (!promoted) return;
   const recipients = [...new Set([task.ownerAgentId, taskOwnerTarget(task)].filter((item): item is string => Boolean(item && item.trim())))];
-  const delivered = routeNotification({
+  const delivered = await routeNotification({
     type: "task.review-hold.cleared",
     scope: {
       taskId: String(task.id),
@@ -233,7 +220,7 @@ export async function setTaskReviewHoldControl(input: SetTaskReviewHoldControlIn
   if (detail) emitTaskChanged(detail, input.held ? "task.review-hold.set" : "task.review-hold.cleared");
   let landingHandoff: number | undefined;
   if (promoted) {
-    if (detail) notifyReviewHoldCleared(detail, promoted);
+    if (detail) await notifyReviewHoldCleared(detail, promoted);
     // Re-drive the ready/schedule effect for the promoted delivery (the held park deferred it;
     // the promotion supplies the authorization the sweep needs).
     landingHandoff = await reDrivePromotedLanding(task.id, promoted, actor, input.landingOperationId);

package/src/services/task-semantic-events.ts

@@ -1,6 +1,8 @@
+import { framed } from "../hub-metrics";
+import { addSubscriptionAsync } from "../db/lifecycle-tail-async";
 import { guardedTimeout, LEGACY_HUMAN_AGENT_ID } from "@humwick/sdk";
 import { getAgent } from "../db";
-import { addSubscription } from "../db/notification-subscriptions";
+
 import { getTaskOwnerFacet } from "../db/task-owner";
 import { isGoneAgentRecipient, resolveTaskOwnerAgentId, seatAgentIdOf, taskCoordinatorTarget, taskOwnerTarget, withoutSeatDuplicates } from "../task-owner";
 import { emitRelayEvent } from "../events";
@@ -99,7 +101,7 @@ interface StatusPulseBatch {
 
 const statusPulseBatches = new Map<string, StatusPulseBatch>();
 
-export function autoSubscribeTaskCoordinator(agentId: string | undefined, taskId: number): boolean {
+export async function autoSubscribeTaskCoordinator(agentId: string | undefined, taskId: number): Promise<boolean> {
   const cleaned = agentId?.trim();
   if (!cleaned || !getAgent(cleaned)) return false;
   // #2862 — the owner (role seat or human) is addressed by every notice; a per-agent subscription
@@ -107,17 +109,17 @@ export function autoSubscribeTaskCoordinator(agentId: string | undefined, taskId
   const facet = getTaskOwnerFacet(taskId);
   if (facet?.owner && resolveTaskOwnerAgentId(facet) === cleaned) return true;
   for (const transition of TASK_NOTIFICATION_TRANSITIONS) {
-    addSubscription({
+    (await addSubscriptionAsync({
       agentId: cleaned,
       type: TASK_NOTIFICATION_TYPE[transition],
       mode: "opt_in",
       scopeMatch: { taskId: String(taskId) },
-    });
+    }));
   }
   return true;
 }
 
-export function emitTaskSemanticNotification(input: TaskSemanticNotificationInput): void {
+export async function emitTaskSemanticNotification(input: TaskSemanticNotificationInput): Promise<void> {
   const type = TASK_NOTIFICATION_TYPE[input.transition as KnownTaskSemanticTransition] ?? UNKNOWN_TASK_NOTIFICATION_TYPE;
   const scope = taskNotificationScope(input);
   const semanticEvent = `task.${input.transition}`;
@@ -166,7 +168,7 @@ export function emitTaskSemanticNotification(input: TaskSemanticNotificationInpu
       .map((recipient) => ({ ...recipient, agentId: seatAgentIdOf(recipient.agentId) }));
     for (const recipient of dedupeRecipients(seated)) {
       if (recipient.agentId === input.actor) continue;
-      enqueueStatusPulse(recipient.agentId, {
+      await enqueueStatusPulse(recipient.agentId, {
         taskId: input.task.id,
         title: input.task.title,
         transition: input.transition,
@@ -181,7 +183,7 @@ export function emitTaskSemanticNotification(input: TaskSemanticNotificationInpu
     return;
   }
 
-  routeNotification({
+  await routeNotification({
     type,
     scope,
     recipients,
@@ -239,18 +241,18 @@ function pulseSupersededByLifecycle(agentId: string, item: StatusPulseDigestItem
     || (item.sha !== undefined && hasRecentLifecycleSignal(agentId, taskSignalKey(item.taskId, item.transition, item.sha)));
 }
 
-function enqueueStatusPulse(agentId: string, item: StatusPulseDigestItem): void {
+async function enqueueStatusPulse(agentId: string, item: StatusPulseDigestItem): Promise<void> {
   if (pulseSupersededByLifecycle(agentId, item)) return; // #1032b/#1038
   const batch = statusPulseBatches.get(agentId) ?? { items: [] };
   batch.items.push(item);
   if (!batch.timer) {
     // #3643 — the flush writes a message; a BUSY thrown from a bare timer exited the hub.
-    batch.timer = guardedTimeout(`[task-status-pulse] flush for ${agentId}`, TASK_STATUS_PULSE_BATCH_MS, () => flushTaskStatusPulses(agentId));
+    batch.timer = guardedTimeout(`[task-status-pulse] flush for ${agentId}`, TASK_STATUS_PULSE_BATCH_MS, framed("timer task-status-pulse", () => flushTaskStatusPulses(agentId)));
   }
   statusPulseBatches.set(agentId, batch);
 }
 
-export function flushTaskStatusPulses(agentId?: string): void {
+export async function flushTaskStatusPulses(agentId?: string): Promise<void> {
   const targets = agentId ? [agentId] : [...statusPulseBatches.keys()];
   for (const target of targets) {
     const batch = statusPulseBatches.get(target);
@@ -263,7 +265,7 @@ export function flushTaskStatusPulses(agentId?: string): void {
     const fresh = batch.items.filter((item) => !pulseSupersededByLifecycle(target, item));
     if (fresh.length === 0) continue;
     const items = compactStatusPulseItems(fresh);
-    notifySystemMessage(target, {
+    await notifySystemMessage(target, {
       subject: `Task status pulse (${items.length})`,
       body: taskStatusPulseBody(items),
       payload: {

package/src/services/task-state-reconcile.ts

@@ -4,8 +4,9 @@
 // live in src/db/task-state-reconcile.ts; every change is applied by its conditional writer, which
 // re-checks the rule in the transaction, then audited here with one `task.reconciled` relay event.
 import { errMessage } from "@humwick/sdk";
-import { isSqliteBusyError, withFastFailConnection, writerLockAvailable } from "../db/connection";
-import { getIssueRef, updateIssueRef } from "../db/issue-refs";
+import { getGateway } from "../db/gateway";
+import { getIssueRef } from "../db/issue-refs";
+import { updateIssueRefAsync } from "../db/issue-refs-async";
 import { applyTaskStateReconcileAsync, listTaskStateReconcileCandidatesAsync } from "../db/task-state-reconcile-async";
 import { TASK_RECONCILE_ACTOR, type TaskReconcileRule, type TaskStateReconcileApplied } from "../db/task-state-reconcile";
 import { emitRelayEvent } from "../events";
@@ -24,7 +25,6 @@ const ISSUE_REFRESHES_PER_RUN = 20;
 const ISSUE_REFRESH_BACKOFF_MS = 60 * 60_000;
 const CANDIDATE_LIMIT = 100;
 /** A write step waits this long for another writer's lock before the run steps aside (the shared connection waits ~1 s). */
-const STEP_BUSY_TIMEOUT_MS = 40;
 
 export interface TaskStateReconcileOptions {
   now?: number;
@@ -55,7 +55,7 @@ const refreshFailedAt = new Map<string, number>();
 
 /** Post-commit effects of one applied change: the SSE/semantic pulse, plan refs and the audit event. */
 async function publishApplied(applied: TaskStateReconcileApplied): Promise<void> {
-  emitStatusChangeEffects(applied.before, applied.detail, TASK_RECONCILE_ACTOR, undefined);
+  await emitStatusChangeEffects(applied.before, applied.detail, TASK_RECONCILE_ACTOR, undefined);
   if (applied.detail.status === "done") await advanceTerminalPlanRefsAsync({ taskId: applied.detail.id, actor: TASK_RECONCILE_ACTOR });
   emitRelayEvent({
     type: "task.reconciled",
@@ -84,7 +84,7 @@ function stepRunner(opts: TaskStateReconcileOptions, result: TaskStateReconcileR
       }
     },
     contended() {
-      if (writerLockAvailable(STEP_BUSY_TIMEOUT_MS)) return false;
+      if (!getGateway().stats.writer.busy && getGateway().stats.writer.queued === 0) return false;
       result.moreWork = true;
       return true;
     },
@@ -104,19 +104,10 @@ async function refreshIssueRefs(refIds: string[], opts: TaskStateReconcileOption
     try {
       const live = await (opts.adapterResolver ?? resolveIssueTrackerAdapter)(ref).getStatus(ref);
       const status = live.status === "open" || live.status === "closed" ? live.status : ref.status;
-      // The tracker read can take long: re-check the lock right before the write, and bound the write itself.
+      // The tracker read can take long: re-check the lock right before the write. The write itself waits on
+      // the writer thread, never on the loop (#1870 S7).
       if (steps.contended()) break;
-      const written = await steps.timed(() => {
-        try {
-          withFastFailConnection(STEP_BUSY_TIMEOUT_MS, () => updateIssueRef(ref.id, { status, title: live.title, closeReason: live.closeReason, statusSyncedAt: Date.now() }));
-          return true;
-        } catch (error) {
-          if (!isSqliteBusyError(error)) throw error;
-          result.moreWork = true;
-          return false;
-        }
-      });
-      if (!written) break;
+      await updateIssueRefAsync(ref.id, { status, title: live.title, closeReason: live.closeReason, statusSyncedAt: Date.now() });
       closedAny ||= status === "closed";
     } catch (error) {
       refreshFailedAt.set(id, now);

package/src/services/task-validation.ts

@@ -21,12 +21,12 @@ export async function setTaskValidationControl(taskId: number, input: SetTaskVal
   const actor = ctx.callerAgentId ?? ctx.actor.id;
   const result = await getGateway().write("taskEntity.setValidation", { id: taskId, input, actor }, { critical: true, idempotencyKey }) as unknown as { task: TaskDetail; eventId: number; item: TaskValidationItem };
   emitTaskChanged(result.task, "task.validation");
-  if (before.status !== result.task.status) emitStatusChangeEffects(before, result.task, actor, String(result.eventId));
+  if (before.status !== result.task.status) await emitStatusChangeEffects(before, result.task, actor, String(result.eventId));
   if (result.item.status === "failed") {
     const coordinator = (result.task.owner ? taskOwnerTarget(result.task) : undefined)
       ?? (result.task.teamId ? resolveTeamCoordinatorAgentId(result.task.teamId) : undefined)
       ?? resolveCoordinatorAgentId(result.task.ownerAgentId) ?? result.task.createdBy;
-    emitTaskSemanticNotification({ task: result.task, transition: "gate-failed", actor, occurrenceKey: String(result.eventId), recipients: coordinator ? [coordinator] : [], outcome: { gate: "validation", detail: `${result.item.criterion}: ${result.item.note ?? "failed"}`, validationItem: result.item } });
+    await emitTaskSemanticNotification({ task: result.task, transition: "gate-failed", actor, occurrenceKey: String(result.eventId), recipients: coordinator ? [coordinator] : [], outcome: { gate: "validation", detail: `${result.item.criterion}: ${result.item.note ?? "failed"}`, validationItem: result.item } });
   }
   if (before.status !== "done" && result.task.status === "done") await advanceTerminalPlanRefsAsync({ taskId, actor });
   return result.task;

package/src/services/team-templates.ts

@@ -1,6 +1,7 @@
 import { isRecord, SPAWN_PROVIDERS, VALID_WORKSPACE_MODES, APPROVAL_MODES, VALID_AGENT_LIFECYCLES } from "@humwick/sdk";
 import { getTeam, ValidationError } from "../db";
-import { deleteConfig, getConfig, listConfig, setConfig } from "../config-store";
+import { getConfig, listConfig } from "../config-store";
+import { deleteConfigAsync, setConfigAsync } from "../config-store-write";
 import { TEAM_TEMPLATE_NAMESPACE } from "../team-template-config";
 import { cleanString, optionalEnum } from "../validation";
 import type { AuthContext } from "./auth-context";
@@ -21,7 +22,7 @@ interface TeamTemplateInstantiateInput {
 
 interface TeamTemplateInstantiateResult {
   template: TeamTemplate;
-  team: ReturnType<typeof setCallerTeamBrief>["team"];
+  team: Awaited<ReturnType<typeof setCallerTeamBrief>>["team"];
   spawned: SpawnAgentResult[];
 }
 
@@ -47,11 +48,11 @@ function withTimestamps(template: TeamTemplate, existing?: TeamTemplate): TeamTe
   };
 }
 
-export function saveTeamTemplate(input: Record<string, unknown>, updatedBy?: string): TeamTemplate {
+export async function saveTeamTemplateAsync(input: Record<string, unknown>, updatedBy?: string): Promise<TeamTemplate> {
   if (input.teamId !== undefined && input.composition !== undefined) {
     throw new ValidationError("teamId capture and manual composition are mutually exclusive");
   }
-  if (input.teamId !== undefined) return captureTeamTemplateFromTeam(cleanString(input.teamId, "teamId", { required: true, max: 120 })!, input, updatedBy);
+  if (input.teamId !== undefined) return captureTeamTemplateFromTeamAsync(cleanString(input.teamId, "teamId", { required: true, max: 120 })!, input, updatedBy);
   const slug = templateSlug(input);
   const existing = getConfig<TeamTemplate>(TEAM_TEMPLATE_NAMESPACE, slug)?.value;
   const template = withTimestamps({
@@ -64,7 +65,7 @@ export function saveTeamTemplate(input: Record<string, unknown>, updatedBy?: str
     ...(cleanString(input.definitionOfDone, "definitionOfDone", { max: 4000 }) ? { definitionOfDone: cleanString(input.definitionOfDone, "definitionOfDone", { max: 4000 }) } : {}),
     ...(input.planSkeleton !== undefined ? { planSkeleton: input.planSkeleton as TeamTemplate["planSkeleton"] } : {}),
   }, existing);
-  return setConfig(TEAM_TEMPLATE_NAMESPACE, template.slug, template, updatedBy).value as TeamTemplate;
+  return (await setConfigAsync(TEAM_TEMPLATE_NAMESPACE, template.slug, template, updatedBy)).value as TeamTemplate;
 }
 
 export function listTeamTemplates(): TeamTemplate[] {
@@ -75,8 +76,8 @@ export function getTeamTemplate(slug: string): TeamTemplate | null {
   return getConfig<TeamTemplate>(TEAM_TEMPLATE_NAMESPACE, slug)?.value ?? null;
 }
 
-export function deleteTeamTemplate(slug: string, updatedBy?: string): boolean {
-  return deleteConfig(TEAM_TEMPLATE_NAMESPACE, slug, updatedBy);
+export async function deleteTeamTemplateAsync(slug: string, updatedBy?: string): Promise<boolean> {
+  return (await deleteConfigAsync(TEAM_TEMPLATE_NAMESPACE, slug, updatedBy));
 }
 
 function parseFrozenComposition(raw: string): Array<Record<string, unknown>> {
@@ -107,7 +108,7 @@ function compositionFromFrozenSnapshot(raw: string): TeamTemplateCompositionEntr
   return composition;
 }
 
-export function captureTeamTemplateFromTeam(teamId: string, input: Record<string, unknown> = {}, updatedBy?: string): TeamTemplate {
+export async function captureTeamTemplateFromTeamAsync(teamId: string, input: Record<string, unknown> = {}, updatedBy?: string): Promise<TeamTemplate> {
   const team = getTeam(teamId);
   if (!team) throw new ValidationError(`team ${teamId} not found`);
   if (!team.composition) throw new ValidationError("team has no frozen composition snapshot; dissolve it before capture");
@@ -123,7 +124,7 @@ export function captureTeamTemplateFromTeam(teamId: string, input: Record<string
     ...(team.brief ? { brief: team.brief } : {}),
     ...(team.definitionOfDone ? { definitionOfDone: team.definitionOfDone } : {}),
   }, existing);
-  return setConfig(TEAM_TEMPLATE_NAMESPACE, template.slug, template, updatedBy).value as TeamTemplate;
+  return (await setConfigAsync(TEAM_TEMPLATE_NAMESPACE, template.slug, template, updatedBy)).value as TeamTemplate;
 }
 
 function cleanWait(value: unknown): number {
@@ -157,11 +158,11 @@ export async function instantiateTeamTemplate(input: TeamTemplateInstantiateInpu
   const slug = cleanString(input.slug, "slug", { required: true, max: 120 })!;
   const template = getTeamTemplate(slug);
   if (!template) throw new ValidationError(`team template ${slug} not found`);
-  const teamPayload = setCallerTeamBrief(ctx, {
+  const teamPayload = (await setCallerTeamBrief(ctx, {
     title: template.title,
     brief: template.brief,
     definitionOfDone: template.definitionOfDone,
-  });
+  }));
   const spawned: SpawnAgentResult[] = [];
   for (const entry of template.composition) {
     for (let i = 0; i < entry.count; i++) {