@humwick/server 0.130.1 → 0.130.3

package/src/automations/reconcile.ts

@@ -1,29 +1,20 @@
-import { createCommand } from "../commands-db";
-import { getAgent, getTaskAsync, listAgents, listOrchestrators, sendMessage, updateTaskStatusAsync } from "../db";
+import { updateRunAsync } from "./write-async";
+import { sendMessageAsync } from "../db/message-send";
+import { createCommandAsync } from "../commands-write";
+
+import { getAgent, getTaskAsync, listAgents, listOrchestrators, updateTaskStatusAsync } from "../db";
 import { renderTemplate } from "../prompt-resolver";
 import { CLOSED_TASK_STATUS } from "./constants";
 import { settleAutomationPrechecks } from "./precheck";
-import {
-  ensureAutomationTables,
-  getAutomation,
-  getAutomationRun,
-  rowToAutomationRun,
-  updateRun,
-  db,
-} from "./storage";
+import { listReconcilableRunsAsync } from "./read-async";
+import { ensureAutomationTables, getAutomation, getAutomationRun } from "./storage";
 import type { AutomationReconcileResult } from "./types";
 import type { AgentCard, AutomationRun, AutomationRunStatus, AutomationRuntimeBudget, Command, Message, Task } from "../types";
 
 export async function reconcileAutomationRuns(now = Date.now()): Promise<AutomationReconcileResult[]> {
   ensureAutomationTables();
   const results: AutomationReconcileResult[] = await settleAutomationPrechecks(now);
-  const rows = db().query(`
-    SELECT * FROM automation_runs
-    WHERE status IN ('scheduled', 'dispatching', 'waiting_agent', 'running') AND task_id IS NOT NULL
-    ORDER BY created_at ASC
-  `).all() as any[];
-  for (const row of rows) {
-    const run = rowToAutomationRun(row);
+  for (const run of await listReconcilableRunsAsync()) {
     const task = run.taskId ? await getTaskAsync(run.taskId) : null;
     if (!task) continue;
 
@@ -31,12 +22,12 @@ export async function reconcileAutomationRuns(now = Date.now()): Promise<Automat
     const hasRuntimeMetaChange = hasMetaChanges(run.meta, runtimeMeta);
     const nextOpenStatus: AutomationRunStatus = task.status === "open" ? "waiting_agent" : "running";
     if ((task.claimedBy && task.claimedBy !== run.targetAgentId) || run.status !== nextOpenStatus || hasRuntimeMetaChange) {
-      updateRun(run.id, {
+      (await updateRunAsync(run.id, {
         status: nextOpenStatus,
         targetAgentId: task.claimedBy ?? run.targetAgentId,
         spawnedAgentId: run.spawnedAgentId ?? task.claimedBy,
         meta: hasRuntimeMetaChange ? { ...run.meta, ...runtimeMeta } : undefined,
-      }, now);
+      }, now));
     }
 
     if (!CLOSED_TASK_STATUS.has(task.status)) {
@@ -52,22 +43,22 @@ export async function reconcileAutomationRuns(now = Date.now()): Promise<Automat
         results.push(timedOut);
         continue;
       }
-      const warning = maybeWarnRuntimeBudget(updated, task, now);
+      const warning = (await maybeWarnRuntimeBudget(updated, task, now));
       results.push({ run: getAutomationRun(run.id) ?? updated, task, message: warning });
       continue;
     }
 
     const status: AutomationRunStatus = task.status === "done" ? "succeeded" : task.status === "canceled" ? "canceled" : "failed";
-    updateRun(run.id, {
+    (await updateRunAsync(run.id, {
       status,
       finishedAt: now,
       result: { taskStatus: task.status, result: task.result ?? null },
       targetAgentId: task.claimedBy ?? run.targetAgentId,
       spawnedAgentId: run.spawnedAgentId ?? task.claimedBy,
       meta: hasMetaChanges(run.meta, runtimeMeta) ? { ...run.meta, ...runtimeMeta } : undefined,
-    }, now);
+    }, now));
     const updated = getAutomationRun(run.id)!;
-    const command = maybeShutdownOnDemandAgent(updated, task, now);
+    const command = (await maybeShutdownOnDemandAgent(updated, task, now));
     results.push({ run: getAutomationRun(run.id)!, task, command });
   }
   return results;
@@ -140,7 +131,7 @@ function runtimeWarningAt(run: AutomationRun, budget: AutomationRuntimeBudget):
   return run.startedAt + budget.warnAtMs;
 }
 
-function maybeWarnRuntimeBudget(run: AutomationRun, task: Task, now: number): Message | undefined {
+async function maybeWarnRuntimeBudget(run: AutomationRun, task: Task, now: number): Promise<Message | undefined> {
   if (run.meta.runtimeBudgetWarnedAt) return undefined;
   const budget = runtimeBudgetForRun(run);
   if (!budget) return undefined;
@@ -150,7 +141,7 @@ function maybeWarnRuntimeBudget(run: AutomationRun, task: Task, now: number): Me
   const target = runtimeBudgetMessageTarget(run, task);
   if (!target) return undefined;
   const remainingMinutes = Math.max(1, Math.ceil((deadline - now) / 60_000));
-  const message = sendMessage({
+  const message = (await sendMessageAsync({
     from: "system",
     to: target,
     kind: "control",
@@ -173,15 +164,15 @@ function maybeWarnRuntimeBudget(run: AutomationRun, task: Task, now: number): Me
       automationRunId: run.id,
       runtimeBudgetWarning: true,
     },
-  });
-  updateRun(run.id, {
+  }));
+  (await updateRunAsync(run.id, {
     meta: {
       ...run.meta,
       runtimeBudgetWarnedAt: now,
       runtimeBudgetWarningMessageId: message.id,
       runtimeBudgetDeadlineAt: deadline,
     },
-  }, now);
+  }, now));
   return message;
 }
 
@@ -205,7 +196,7 @@ async function maybeFailNeverReadyOfflineTarget(run: AutomationRun, task: Task,
     },
   }, { privileged: true });
   const updatedTask = taskResult.task ?? (await getTaskAsync(task.id)) ?? task;
-  updateRun(run.id, {
+  (await updateRunAsync(run.id, {
     status: "failed",
     finishedAt: now,
     error: reason,
@@ -225,7 +216,7 @@ async function maybeFailNeverReadyOfflineTarget(run: AutomationRun, task: Task,
       runtimeTargetOfflineAt: now,
       runtimeTargetNeverReady: true,
     },
-  }, now);
+  }, now));
   return { run: getAutomationRun(run.id)!, task: (await getTaskAsync(task.id)) ?? updatedTask };
 }
 
@@ -251,8 +242,8 @@ async function maybeTimeoutRuntimeBudget(run: AutomationRun, task: Task, now: nu
     },
   }, { privileged: true });
   const updatedTask = taskResult.task ?? (await getTaskAsync(task.id)) ?? task;
-  const command = requestOnDemandAgentShutdown(run, updatedTask, now, "runtime-budget-timeout");
-  updateRun(run.id, {
+  const command = (await requestOnDemandAgentShutdown(run, updatedTask, now, "runtime-budget-timeout"));
+  (await updateRunAsync(run.id, {
     status: "timed_out",
     finishedAt: now,
     error: "Automation runtime budget elapsed",
@@ -273,7 +264,7 @@ async function maybeTimeoutRuntimeBudget(run: AutomationRun, task: Task, now: nu
       runtimeBudgetDeadlineAt: deadline,
       ...(command ? { shutdownCommandId: command.id } : {}),
     },
-  }, now);
+  }, now));
   return { run: getAutomationRun(run.id)!, task: (await getTaskAsync(task.id)) ?? updatedTask, command };
 }
 
@@ -285,19 +276,19 @@ function runtimeBudgetMessageTarget(run: AutomationRun, task: Task): string | un
   return undefined;
 }
 
-function maybeShutdownOnDemandAgent(run: AutomationRun, task: Task, now: number): Command | undefined {
+async function maybeShutdownOnDemandAgent(run: AutomationRun, task: Task, now: number): Promise<Command | undefined> {
   if (run.shutdownRequestedAt) return undefined;
   const automation = getAutomation(run.automationId);
   if (!automation || automation.targetPolicy.mode !== "on_demand_agent" || automation.targetPolicy.keepAlive) return undefined;
-  const command = requestOnDemandAgentShutdown(run, task, now, "task-complete");
-  if (command) updateRun(run.id, { shutdownRequestedAt: now, meta: { ...run.meta, shutdownCommandId: command.id } }, now);
+  const command = (await requestOnDemandAgentShutdown(run, task, now, "task-complete"));
+  if (command) (await updateRunAsync(run.id, { shutdownRequestedAt: now, meta: { ...run.meta, shutdownCommandId: command.id } }, now));
   return command;
 }
 
-function requestOnDemandAgentShutdown(run: AutomationRun, task: Task, now: number, reason: string): Command | undefined {
+async function requestOnDemandAgentShutdown(run: AutomationRun, task: Task, now: number, reason: string): Promise<Command | undefined> {
   const agentId = task.claimedBy ?? run.targetAgentId ?? run.spawnedAgentId;
   if (!agentId) return undefined;
-  return createCommand({
+  return (await createCommandAsync({
     type: "agent.shutdown",
     source: "automation",
     target: agentId,
@@ -310,5 +301,5 @@ function requestOnDemandAgentShutdown(run: AutomationRun, task: Task, now: numbe
       automationRunId: run.id,
       reason,
     },
-  });
+  }));
 }

package/src/automations/storage.ts

@@ -70,8 +70,8 @@ export function listAutomations(): Automation[] {
     .map(rowToAutomation);
 }
 
-export function listAutomationRuns(filter: { automationId?: string; status?: string; limit?: number } = {}): AutomationRun[] {
-  ensureAutomationTables();
+/** Listing SQL, exported so the query-plan gate pins the production statement (#3799). */
+export function buildListAutomationRunsQuery(filter: { automationId?: string; status?: string; limit?: number } = {}): { sql: string; params: (string | number)[] } {
   const clauses: string[] = [];
   const params: (string | number)[] = [];
   if (filter.automationId) {
@@ -84,8 +84,13 @@ export function listAutomationRuns(filter: { automationId?: string; status?: str
   }
   const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
   params.push(filter.limit ?? 100);
-  return (db().query(`SELECT * FROM automation_runs ${where} ORDER BY created_at DESC LIMIT ?`).all(...params) as any[])
-    .map(rowToAutomationRun);
+  return { sql: `SELECT * FROM automation_runs ${where} ORDER BY created_at DESC LIMIT ?`, params };
+}
+
+export function listAutomationRuns(filter: { automationId?: string; status?: string; limit?: number } = {}): AutomationRun[] {
+  ensureAutomationTables();
+  const { sql, params } = buildListAutomationRunsQuery(filter);
+  return (db().query(sql).all(...params) as any[]).map(rowToAutomationRun);
 }
 
 export function getAutomationRun(id: string): AutomationRun | null {
@@ -176,25 +181,43 @@ export function cancelActiveRuns(automationId: string, now: number, reason: stri
     .run(now, reason, now, automationId, ...OPEN_RUN_STATUSES);
 }
 
+/** Enabled automations whose next fire time has passed; indexed on (enabled, next_run_at). */
+export const DUE_AUTOMATIONS_SQL = "SELECT * FROM automations WHERE enabled = 1 AND next_run_at IS NOT NULL AND next_run_at <= ? ORDER BY next_run_at ASC LIMIT 25";
+export function listDueAutomations(now: number): Automation[] {
+  return (db().query(DUE_AUTOMATIONS_SQL).all(now) as any[]).map(rowToAutomation);
+}
+
 export function rescheduleAutomation(automation: Automation, nextRunAt: number | undefined, now: number): void {
   db().query("UPDATE automations SET next_run_at = ?, updated_at = ? WHERE id = ?").run(nextRunAt ?? null, now, automation.id);
 }
 
 /** #3175 — runs whose precheck command has been dispatched but not yet settled. */
-export function listPendingPrecheckRuns(): AutomationRun[] {
-  return (db().query(`
+export const PENDING_PRECHECK_RUNS_SQL = `
     SELECT * FROM automation_runs
     WHERE status = 'running' AND task_id IS NULL AND json_extract(meta, '$.precheck.status') = 'running'
     ORDER BY created_at ASC LIMIT 100
-  `).all() as any[]).map(rowToAutomationRun);
+  `;
+export function listPendingPrecheckRuns(): AutomationRun[] {
+  return (db().query(PENDING_PRECHECK_RUNS_SQL).all() as any[]).map(rowToAutomationRun);
+}
+
+/** Open runs bound to a task: the reconcile pass walks these against the task's live state. */
+export const RECONCILABLE_RUNS_SQL = `
+    SELECT * FROM automation_runs
+    WHERE status IN ('scheduled', 'dispatching', 'waiting_agent', 'running') AND task_id IS NOT NULL
+    ORDER BY created_at ASC
+  `;
+export function listReconcilableRuns(): AutomationRun[] {
+  return (db().query(RECONCILABLE_RUNS_SQL).all() as any[]).map(rowToAutomationRun);
 }
 
 /** Queued runs ready to dispatch. A run whose precheck already reported hits was accepted while the
  * automation was runnable (Run now works on disabled automations), so it continues regardless. */
-export function listDispatchableQueuedRuns(): AutomationRun[] {
-  return (db().query(`
+export const DISPATCHABLE_QUEUED_RUNS_SQL = `
     SELECT r.* FROM automation_runs r JOIN automations a ON a.id = r.automation_id
     WHERE r.status = 'scheduled' AND (a.enabled = 1 OR json_extract(r.meta, '$.precheck.status') = 'hits')
     ORDER BY r.scheduled_for ASC LIMIT 25
-  `).all() as any[]).map(rowToAutomationRun);
+  `;
+export function listDispatchableQueuedRuns(): AutomationRun[] {
+  return (db().query(DISPATCHABLE_QUEUED_RUNS_SQL).all() as any[]).map(rowToAutomationRun);
 }

package/src/automations/write-async.ts

@@ -0,0 +1,33 @@
+import { randomUUID } from "node:crypto";
+import { getGateway } from "../db/gateway";
+import type { insertAutomation, updateAutomationNormalized } from "./persistence";
+import type { Automation, AutomationRun } from "../types";
+import type { insertRun, enqueueAutomationRun, updateRun, cancelActiveRuns, rescheduleAutomation } from "./storage";
+
+export function insertAutomationAsync(normalized: Parameters<typeof insertAutomation>[0], now: number): Promise<Automation> {
+  return getGateway().write("automations.create", { normalized, now }, { idempotencyKey: randomUUID() }) as unknown as Promise<Automation>;
+}
+export function updateAutomationNormalizedAsync(id: string, normalized: Parameters<typeof updateAutomationNormalized>[1], expected: Automation, now: number): Promise<Automation> {
+  return getGateway().write("automations.update", { id, normalized, expected, now }, { idempotencyKey: randomUUID() }) as unknown as Promise<Automation>;
+}
+export function deleteAutomationAsync(id: string): Promise<boolean> {
+  return getGateway().write("automations.delete", { id }) as unknown as Promise<boolean>;
+}
+export function admitAutomationRunAsync(input: { automationId: string; now: number; manual?: boolean; queuedRunId?: string }): Promise<{ automation: Automation; run: AutomationRun } | null> {
+  return getGateway().write("automations.admitRun", input, { idempotencyKey: randomUUID() }) as unknown as Promise<{ automation: Automation; run: AutomationRun } | null>;
+}
+export function insertRunAsync(...args: Parameters<typeof insertRun>): Promise<ReturnType<typeof insertRun>> {
+  return getGateway().write("automations.insertRun", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof insertRun>>;
+}
+export function enqueueAutomationRunAsync(...args: Parameters<typeof enqueueAutomationRun>): Promise<ReturnType<typeof enqueueAutomationRun>> {
+  return getGateway().write("automations.enqueueRun", args, { idempotencyKey: randomUUID() }) as unknown as Promise<ReturnType<typeof enqueueAutomationRun>>;
+}
+export function updateRunAsync(...args: Parameters<typeof updateRun>): Promise<void> {
+  return getGateway().write("automations.updateRun", args, { idempotencyKey: randomUUID() }) as unknown as Promise<void>;
+}
+export function cancelActiveRunsAsync(...args: Parameters<typeof cancelActiveRuns>): Promise<void> {
+  return getGateway().write("automations.cancelRuns", args, { idempotencyKey: randomUUID() }) as unknown as Promise<void>;
+}
+export function rescheduleAutomationAsync(...args: Parameters<typeof rescheduleAutomation>): Promise<void> {
+  return getGateway().write("automations.reschedule", args, { idempotencyKey: randomUUID() }) as unknown as Promise<void>;
+}

package/src/branch-land-notice.ts

@@ -0,0 +1,93 @@
+import { isHumanAgentId } from "@humwick/sdk";
+import type { BranchLandedInput, resolveLandedTask } from "./branch-landed";
+import { getAgent, getTaskDetail } from "./db";
+import { renderTemplate } from "./prompt-resolver";
+import { routeNotification, INFORMATIONAL_TTL_MS } from "./notification-router";
+import { stampLifecycleSignal, taskSignalKey } from "./lifecycle-signal-registry";
+import { resolveCoordinatorAgentId } from "./steward-identity";
+import { resolveTaskOwnerAgentId } from "./task-owner";
+import { audienceWithTaskOwnerRole } from "./task-owner-notices";
+import { notifyLandUnconfirmed, verifyPublishedLand } from "./services/landed-ancestry";
+
+export async function announceVerifiedLand(input: BranchLandedInput, landedTask: ReturnType<typeof resolveLandedTask>, idempotencyKey?: string): Promise<void> {
+  const { workspace } = input;
+  const base = workspace.baseRef ?? "main";
+  const verification = input.mergedSha && input.landVerifiedSha === input.mergedSha
+    ? "confirmed" : await verifyPublishedLand(workspace.repoRoot, input.mergedSha, workspace.baseRef);
+  if (verification !== "confirmed") {
+    await notifyLandUnconfirmed({ workspace, sha: input.mergedSha, targetRef: base.startsWith("origin/") ? base : `origin/${base}`, kind: verification });
+    return;
+  }
+  const landedBranch = workspace.branch;
+  const shortSha = input.mergedSha?.slice(0, 12);
+  const landedTaskPayload = landedTask ? { taskId: landedTask.taskId, taskLabel: landedTask.taskLabel } : {};
+  const author = workspace.ownerAgentId;
+  const shaLabel = shortSha ? ` as \`${shortSha}\`` : "";
+  const subjectLabel = input.subject ? ` — "${input.subject}"` : "";
+  const payload = {
+    verified: true,
+    kind: "branch.landed",
+    workspaceId: workspace.id,
+    repoRoot: workspace.repoRoot,
+    branch: landedBranch,
+    base,
+    sha: input.mergedSha,
+    author,
+    newBranch: input.newBranch,
+    pushed: input.pushed,
+    ...landedTaskPayload,
+  };
+
+  // The branch author cares most — push regardless of online (store-ahead delivers it on
+  // next poll if they've moved on, #234). A live owner continues in its worktree.
+  if (author) {
+    const branchLabel = landedBranch ? `\`${landedBranch}\`` : "Your branch";
+    const continueLabel = input.newBranch
+      ? ` You're now on \`${input.newBranch}\` — keep working there.`
+      : " Worktree reclaimed.";
+    // Durable (ttl null): the author's own branch landing must reach them even after they go
+    // offline (store-ahead #234) — not a bystander notice that goes stale.
+    const notices = await routeNotification({
+      type: "branch.landed",
+      scope: { author, repoRoot: workspace.repoRoot, workspaceId: workspace.id },
+      recipients: [author],
+      ttlMs: null,
+      message: {
+        subject: "Your branch landed",
+        body: renderTemplate("notify.land.success", {
+          branch: branchLabel,
+          base,
+          sha: `${shaLabel}${subjectLabel}`,
+          publishLabel: "",
+          continueLabel,
+        }) + " verified: true.",
+        payload: { ...payload, notification: "landed-success" },
+        idempotencyKey,
+        replyExpected: false,
+      },
+    });
+    if (landedTask && input.mergedSha) {
+      for (const notice of notices) stampLifecycleSignal(notice.to, taskSignalKey(landedTask.taskId, "landed-on-main", input.mergedSha));
+    }
+  }
+
+  // Coordinator copy (#2837), informational. No explicit recipients: the router records the rule decision (#446).
+  const mainScope = { author, repoRoot: workspace.repoRoot, workspaceId: workspace.id, teamId: landedTask?.teamId ?? (author ? getAgent(author)?.teamId : undefined), coordinatorAgentIds: [...new Set([resolveCoordinatorAgentId(author), landedTask && resolveTaskOwnerAgentId(getTaskDetail(landedTask.taskId))].filter((id): id is string => !!id && !isHumanAgentId(id)))] };
+  const branchLabel = landedBranch ? `\`${landedBranch}\`` : "A branch";
+  const authorLabel = author ? ` by \`${author}\`` : "";
+  const notices = await routeNotification({
+    type: "branch.landed",
+    scope: mainScope, ...audienceWithTaskOwnerRole("branch.landed", mainScope, landedTask?.taskId), // #2862
+    ttlMs: INFORMATIONAL_TTL_MS,
+    message: {
+      subject: `Merged to ${base}`,
+      body: `🔀 ${branchLabel}${authorLabel} merged to \`${base}\`${shaLabel}${subjectLabel}. verified: true.`,
+      payload: { ...payload, notification: "landed-success" },
+      idempotencyKey,
+      replyExpected: false,
+    },
+  });
+  if (landedTask && input.mergedSha) {
+    for (const notice of notices) stampLifecycleSignal(notice.to, taskSignalKey(landedTask.taskId, "landed-on-main", input.mergedSha));
+  }
+}