@humwick/server 0.130.1 → 0.130.3

package/src/ci/incidents.ts

@@ -169,7 +169,7 @@ export function ingestCiObservation(observation: CiObservation, now: number = Da
 
 /** Gateway-routed form for async-capable polling jobs. The complete observation transition is one
  * writer operation, so no gateway await exposes a stale watch state to a later incident decision. */
-export async function ingestCiObservationAsync(observation: CiObservation): Promise<CiIncidentIngestResult> {
+export async function ingestCiObservationAsync(observation: CiObservation, now?: number): Promise<CiIncidentIngestResult> {
   const transition = transitionInput(observation);
-  return formatTransitionResult(await ingestCiObservationTransitionAsync(transition.input), transition.watchKey, transition.fingerprint);
+  return formatTransitionResult(await ingestCiObservationTransitionAsync(transition.input, now), transition.watchKey, transition.fingerprint);
 }

package/src/ci/monitor.ts

@@ -12,8 +12,8 @@ import { isPathWithinBase } from "../utils";
 import { computeCiWatchKey, isFailingJob } from "./incidents.ts";
 import { ghApi, type GitHubApi } from "../issue-tracker/github.ts";
 import { resolveCoordinatorAgentId } from "../steward-identity.ts";
-import { notifyCiRootMissing, notifyCiRootMissingAsync, type CiRootMissing } from "./root-missing.ts";
-import { notifyCiTransition, notifyCiTransitionAsync, type CiTransitionNotifyResult } from "./transition-notify.ts";
+import { notifyCiRootMissing, type CiRootMissing } from "./root-missing.ts";
+import { notifyCiTransition, type CiTransitionNotifyResult } from "./transition-notify.ts";
 import { workflowNotTriggered } from "./not-triggered.ts";
 import type { CiJobRef, CiObservation, CiObservationStatus, CiRunRef } from "./provider.ts";
 
@@ -343,7 +343,7 @@ export interface CiMonitorDeps {
   rootsForProject: (projectId: string) => ProjectRoot[];
   loadConfig: (root: ProjectRoot) => CiMonitorConfig | null | Promise<CiMonitorConfig | null>;
   api: GitHubApi;
-  notify: typeof notifyCiTransition;
+  notify: (...args: Parameters<typeof notifyCiTransition>) => CiTransitionNotifyResult | Promise<CiTransitionNotifyResult>;
   resolveCoordinator: (rootPath: string) => string | undefined;
   /** Commits workflows wait on: each watch of their root reports its verdict on them too. */
   shaWaits: () => Promise<CiShaWait[]>;
@@ -419,7 +419,6 @@ export async function runCiMonitor(input: Partial<CiMonitorDeps> = {}): Promise<
     readinessMs: 0, historyMs: 0, historyApiCalls: 0,
     transitions: { went_red: 0, back_green: 0, never_matched: 0, config_mismatch: 0, none: 0 },
   };
-  const useAsync = deps.notify === notifyCiTransition && !deps.now;
   // A repository counts as missing only if no root of it has the config, so a duplicate root cannot flap the notice.
   const missingRoots = new Map<string, CiRootMissing>();
   const presentRepositories = new Set<string>();
@@ -464,9 +463,7 @@ export async function runCiMonitor(input: Partial<CiMonitorDeps> = {}): Promise<
           const observation = await observeGitHubCiMonitorWatch(repository, watch, deps.api, runsPayload);
           if (deps.signal?.aborted) break;
           const notificationDeps = { resolveCoordinator: () => deps.resolveCoordinator(root.rootPath), ...(deps.now ? { now: deps.now() } : {}) };
-          const transition = useAsync
-            ? await notifyCiTransitionAsync(observation, notificationDeps)
-            : deps.notify(observation, notificationDeps);
+          const transition = await deps.notify(observation, notificationDeps);
           result.transitions[transition.transition] += 1;
           // The branch-tip row keys the watch; the same key carries its verdict on each waited commit.
           const watchKey = computeCiWatchKey(observation);
@@ -495,7 +492,7 @@ export async function runCiMonitor(input: Partial<CiMonitorDeps> = {}): Promise<
     if (presentRepositories.has(key) || deps.signal?.aborted) continue;
     const notifyDeps = { resolveCoordinator: () => deps.resolveCoordinator(missing.rootPath), ...(deps.now ? { now: deps.now() } : {}) };
     try {
-      if (useAsync ? await notifyCiRootMissingAsync(missing, notifyDeps) : notifyCiRootMissing(missing, notifyDeps)) result.missingRoots += 1;
+      if (await notifyCiRootMissing(missing, notifyDeps)) result.missingRoots += 1;
     } catch (error) {
       result.errors += 1;
       console.warn(`ci monitor ${missing.repository} root-missing notice skipped: ${errMessage(error)}`);

package/src/ci/notifications.ts

@@ -120,13 +120,13 @@ export interface RouteCiIncidentNotificationResult {
  * through routeNotification so its TTL, idempotency, routing explanation, and
  * Activity audit behavior stay identical to every other Relay notification.
  */
-export function routeCiIncidentNotification(input: RouteCiIncidentNotificationInput): RouteCiIncidentNotificationResult {
+export async function routeCiIncidentNotification(input: RouteCiIncidentNotificationInput): Promise<RouteCiIncidentNotificationResult> {
   const { payload } = input;
   const subject = input.subject ?? defaultSubject(input.type, payload.repository, payload.branch);
   const body = input.body ?? defaultBody(input);
   const recipients = input.recipients ?? [payload.coordinatorAgentId];
   const idempotencyKey = input.idempotencyKey ?? defaultIdempotencyKey(input);
-  const messages = routeNotification({
+  const messages = await routeNotification({
     type: input.type,
     scope: {
       repoRoot: payload.repoRoot ?? payload.repository,
@@ -148,14 +148,14 @@ export function routeCiIncidentNotification(input: RouteCiIncidentNotificationIn
   });
 
   if (!input.alertHuman) return { messages };
-  const humanFallback = notifyWorkspaceHumanEscalation({
+  const humanFallback = (await notifyWorkspaceHumanEscalation({
     subject,
     body,
     payload: { kind: input.type, ...payload },
     priority: humanAlertPriority(input.type),
     tags: ["agent-relay", "ci", humanAlertTag(input.type)],
     source: "ci-incident",
-  });
+  }));
   return { messages, humanFallback };
 }
 

package/src/ci/root-missing.ts

@@ -1,4 +1,3 @@
-import { markCiRootMissingNotified } from "../db/ci-incidents.ts";
 import { markCiRootMissingNotifiedAsync } from "../db/ci-incidents-async.ts";
 import { routeCiIncidentNotification } from "./notifications.ts";
 import { resolveCoordinator, type CiTransitionNotifyDeps } from "./transition-notify.ts";
@@ -12,11 +11,11 @@ export interface CiRootMissing {
 
 type Deps = Pick<CiTransitionNotifyDeps, "resolveCoordinator" | "route" | "now">;
 
-function notify(input: CiRootMissing, deps: Deps, fired: boolean): boolean {
+async function notify(input: CiRootMissing, deps: Deps, fired: boolean): Promise<boolean> {
   if (!fired) return false;
   const route = deps.route ?? routeCiIncidentNotification;
   const observedAt = deps.now ?? Date.now();
-  route({
+  await route({
     type: "ci.root_missing",
     payload: { provider: "github-actions", repository: input.repository, repoRoot: input.rootPath, branch: "*", coordinatorAgentId: resolveCoordinator(deps), observedAt },
     alertHuman: true,
@@ -26,10 +25,6 @@ function notify(input: CiRootMissing, deps: Deps, fired: boolean): boolean {
   return true;
 }
 
-export function notifyCiRootMissing(input: CiRootMissing, deps: Deps = {}): boolean {
-  return notify(input, deps, markCiRootMissingNotified(input.repository, deps.now));
-}
-
-export async function notifyCiRootMissingAsync(input: CiRootMissing, deps: Deps = {}): Promise<boolean> {
-  return notify(input, deps, await markCiRootMissingNotifiedAsync(input.repository));
+export async function notifyCiRootMissing(input: CiRootMissing, deps: Deps = {}): Promise<boolean> {
+  return await notify(input, deps, await markCiRootMissingNotifiedAsync(input.repository, deps.now));
 }

package/src/ci/transition-notify.ts

@@ -1,7 +1,7 @@
 import { stewardFallbackTarget } from "../config.ts";
 import { emitRelayEvent } from "../events.ts";
 import type { WorkspaceHumanEscalationResult } from "../workspace-human-escalation.ts";
-import { ingestCiObservation, ingestCiObservationAsync, type CiIncidentIngestResult } from "./incidents.ts";
+import { ingestCiObservationAsync, type CiIncidentIngestResult } from "./incidents.ts";
 import {
   routeCiIncidentNotification,
   type CiFailedNotificationPayload,
@@ -41,8 +41,8 @@ import type { CiObservation, CiRunRef } from "./provider.ts";
 export const CI_MAIN_WATCH_COORDINATOR = "cd-watcher";
 
 export interface CiTransitionNotifyDeps {
-  ingest?: (observation: CiObservation, now?: number) => CiIncidentIngestResult;
-  route?: (input: Parameters<typeof routeCiIncidentNotification>[0]) => RouteCiIncidentNotificationResult;
+  ingest?: (observation: CiObservation, now?: number) => CiIncidentIngestResult | Promise<CiIncidentIngestResult>;
+  route?: (input: Parameters<typeof routeCiIncidentNotification>[0]) => RouteCiIncidentNotificationResult | Promise<RouteCiIncidentNotificationResult>;
   /** Resolve the coordinator/owner agent the relay message addresses. Defaults to the configured
    * steward fallback, then the system watch actor. */
   resolveCoordinator?: () => string | undefined;
@@ -65,16 +65,17 @@ export interface CiTransitionNotifyResult {
  * Detect and (if a flip occurred) alert on a CI red/green transition for a single observed watch.
  * Idempotent per transition — safe to call every poll tick.
  */
-export function notifyCiTransition(
+export async function notifyCiTransition(
   observation: CiObservation | null | undefined,
   deps: CiTransitionNotifyDeps = {},
-): CiTransitionNotifyResult {
+): Promise<CiTransitionNotifyResult> {
   if (!observation) return { transition: "none", notified: false, messages: 0 };
-  const ingest = deps.ingest ?? ingestCiObservation;
+  const ingest = deps.ingest ?? ingestCiObservationAsync;
   const route = deps.route ?? routeCiIncidentNotification;
   const now = deps.now ?? Date.now();
 
-  const result = ingest(observation, now);
+  // Notification emission follows the committed transition (one writer op, #1870), never a pre-write observation.
+  const result = await ingest(observation, deps.now);
   emitCiStatus(result);
 
   if (result.kind === "opened") {
@@ -92,7 +93,7 @@ export function notifyCiTransition(
       failingRunIds: observation.failingRuns.map((run) => run.id),
       failingJobNames: failingJobNames(observation),
     };
-    const routed = route({
+    const routed = await route({
       type: "ci.failed",
       payload,
       alertHuman: true,
@@ -116,7 +117,7 @@ export function notifyCiTransition(
       greenHeadSha: observation.headSha,
       ...(result.incident.resolution ? { resolution: result.incident.resolution } : {}),
     };
-    const routed = route({
+    const routed = await route({
       type: "ci.recovered",
       payload,
       alertHuman: true,
@@ -137,7 +138,7 @@ export function notifyCiTransition(
       firstSeenAt: result.firstSeenAt,
       observedAt: observation.observedAt,
     };
-    const routed = route({
+    const routed = await route({
       type: "ci.never_matched",
       payload,
       alertHuman: true,
@@ -148,46 +149,13 @@ export function notifyCiTransition(
   }
 
   if (result.kind === "config_mismatch") {
-    const routed = route(configMismatchRoute(observation, resolveCoordinator(deps), result.unmatchedJobs));
+    const routed = await route(configMismatchRoute(observation, resolveCoordinator(deps), result.unmatchedJobs));
     return { transition: "config_mismatch", notified: true, messages: routed.messages.length, ...(routed.humanFallback ? { humanFallback: routed.humanFallback } : {}) };
   }
 
   return { transition: "none", ...(result.kind === "deduped" ? { incidentId: result.incident.id } : {}), notified: false, messages: 0 };
 }
 
-/** Gateway-routed companion for async maintenance polling. Notification emission follows the
- * committed transition, never a pre-write observation. */
-export async function notifyCiTransitionAsync(
-  observation: CiObservation | null | undefined,
-  deps: Omit<CiTransitionNotifyDeps, "ingest"> = {},
-): Promise<CiTransitionNotifyResult> {
-  if (!observation) return { transition: "none", notified: false, messages: 0 };
-  const route = deps.route ?? routeCiIncidentNotification;
-  const now = deps.now ?? Date.now();
-  const result = await ingestCiObservationAsync(observation);
-  emitCiStatus(result);
-  if (result.kind === "opened") {
-    const coordinatorAgentId = resolveCoordinator(deps);
-    const routed = route({ type: "ci.failed", payload: { incidentId: result.incident.id, provider: observation.provider, repository: observation.repository, branch: observation.branch, workflow: observation.workflow, failingHeadSha: observation.headSha, coordinatorAgentId, observedAt: observation.observedAt, ...(observation.conclusion ? { conclusion: observation.conclusion } : {}), failingRunIds: observation.failingRuns.map((run) => run.id), failingJobNames: failingJobNames(observation) }, alertHuman: true, subject: redSubject(observation), body: redBody(observation, result.incident.id) });
-    return { transition: "went_red", incidentId: result.incident.id, notified: true, messages: routed.messages.length, ...(routed.humanFallback ? { humanFallback: routed.humanFallback } : {}) };
-  }
-  if (result.kind === "resolved") {
-    const coordinatorAgentId = resolveCoordinator(deps);
-    const routed = route({ type: "ci.recovered", payload: { incidentId: result.incident.id, provider: observation.provider, repository: observation.repository, branch: observation.branch, workflow: observation.workflow, failingHeadSha: result.incident.openedHeadSha, coordinatorAgentId, recoveredAt: now, greenHeadSha: observation.headSha, ...(result.incident.resolution ? { resolution: result.incident.resolution } : {}) }, alertHuman: true, subject: greenSubject(observation), body: greenBody(observation, result.incident.id, result.incident.openedHeadSha) });
-    return { transition: "back_green", incidentId: result.incident.id, notified: true, messages: routed.messages.length, ...(routed.humanFallback ? { humanFallback: routed.humanFallback } : {}) };
-  }
-  if (result.kind === "never_matched") {
-    const coordinatorAgentId = resolveCoordinator(deps);
-    const routed = route({ type: "ci.never_matched", payload: { provider: observation.provider, repository: observation.repository, branch: observation.branch, workflow: observation.workflow, coordinatorAgentId, firstSeenAt: result.firstSeenAt, observedAt: observation.observedAt }, alertHuman: true, subject: neverMatchedSubject(observation), body: neverMatchedBody(observation) });
-    return { transition: "never_matched", notified: true, messages: routed.messages.length, ...(routed.humanFallback ? { humanFallback: routed.humanFallback } : {}) };
-  }
-  if (result.kind === "config_mismatch") {
-    const routed = route(configMismatchRoute(observation, resolveCoordinator(deps), result.unmatchedJobs));
-    return { transition: "config_mismatch", notified: true, messages: routed.messages.length, ...(routed.humanFallback ? { humanFallback: routed.humanFallback } : {}) };
-  }
-  return { transition: "none", ...(result.kind === "deduped" ? { incidentId: result.incident.id } : {}), notified: false, messages: 0 };
-}
-
 /** Live CI view (#3011): one `ci.status` event per watch status transition, never per poll. */
 function emitCiStatus(result: CiIncidentIngestResult): void {
   if (result.statusChange) emitRelayEvent({ type: "ci.status", source: "server", subject: result.watchKey, data: { ...result.statusChange } });

package/src/claude-app/oauth-http.ts

@@ -68,12 +68,12 @@ async function getRuntime(): Promise<Runtime> {
       removeShutdownHook = onShutdown("claude-app-oauth", stopClaudeAppOAuth);
       outcome = { status: "ok", detail: "OAuth available" };
       return { provider, server, base: `http://127.0.0.1:${address.port}` };
-    })().catch(error => withRelayEventDrain(() => {
+    })().catch(error => withRelayEventDrain(async () => {
       runtime = undefined;
       const detail = `OAuth unavailable: ${errMessage(error)}`;
       outcome = { status: "error", detail };
-      raiseOperatorAlarm({ clientId: `claude-app-oauth:${detail}`, source: "claude-app-oauth",
-        subject: "Claude app OAuth unavailable", detail, view: "overview", dedupeEvent: true });
+      (await raiseOperatorAlarm({ clientId: `claude-app-oauth:${detail}`, source: "claude-app-oauth",
+        subject: "Claude app OAuth unavailable", detail, view: "overview", dedupeEvent: true }));
       throw error;
     }));
   }

package/src/cli/cd-pauses.ts

@@ -0,0 +1,19 @@
+import type { CdPause, CdPauseControl } from "../state-adoption/cd-cutover";
+import { apiRequest, ApiRequestError } from "./_shared";
+
+/** The audited maintenance pause API (#1645) shared by local and fleet cutovers (#3470). */
+export const cdWatcherPauses: CdPauseControl = {
+  async pause(holder, reason) {
+    try {
+      return ((await apiRequest("POST", "/api/maintenance/jobs/cd-watcher/pause", { holder, reason, indefinite: true })) as { pause: CdPause }).pause;
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 409) return (error.responseBody as { pause: CdPause }).pause;
+      throw error;
+    }
+  },
+  async current() {
+    const { pauses } = (await apiRequest("GET", "/api/maintenance/pauses")) as { pauses: Array<CdPause & { jobId: string }> };
+    return pauses.find((pause) => pause.jobId === "cd-watcher") ?? null;
+  },
+  async resume() { await apiRequest("POST", "/api/maintenance/jobs/cd-watcher/resume"); },
+};

package/src/cli/orchestrator.ts

@@ -118,7 +118,7 @@ export async function handleOrchestratorCommand(args: string[]): Promise<void> {
   // Install the server package too so a real `humwick` bin lands in the
   // runtime .bin dir (#1421): under bunx there is no global install, so without
   // this the darwin shim below would point at a bin that does not exist.
-  const packageCommand = skipInstall ? [] : ["npm", "install", "--prefix", runtimePrefix, `agent-relay-runner@${version}`, `agent-relay-orchestrator@${version}`, `agent-relay-server@${version}`, OPENCODE_HARNESS_PACKAGE];
+  const packageCommand = skipInstall ? [] : ["npm", "install", "--prefix", runtimePrefix, `@humwick/runner@${version}`, `@humwick/orchestrator@${version}`, `@humwick/server@${version}`, OPENCODE_HARNESS_PACKAGE];
   // W1: on macOS, put `humwick` on the interactive PATH (shim + profile
   // block). Gated to darwin — Linux global-npm installs already get the shim via
   // the postinstall, and we avoid editing Linux user profiles unnecessarily.

package/src/cli/state.ts

@@ -2,8 +2,7 @@ import { readFileSync } from "node:fs";
 import { adoptMacos } from "../state-adoption/macos";
 import { adoptLinux } from "../state-adoption/linux";
 import { adoptState } from "../state-adoption";
-import type { CdPause, CdPauseControl } from "../state-adoption/cd-cutover";
-import { apiRequest, ApiRequestError } from "./_shared";
+import { cdWatcherPauses } from "./cd-pauses";
 
 export const STATE_USAGE = "humwick state adopt|linux-adopt|macos-adopt|cd-cutover|cd-resume --manifest PATH [--interrupt-after STEP] [--rollback] [--systemctl PATH] [--launchctl PATH]";
 const COMMANDS = ["adopt", "linux-adopt", "macos-adopt", "cd-cutover", "cd-resume"];
@@ -43,6 +42,7 @@ export async function handleStateCommand(args: string[]): Promise<void> {
 async function cdCutover(command: string, input: any, options: { rollback: boolean; systemctl?: string; launchctl?: string; interrupt: (step: string) => void }) {
   const { runCutover, resumeCutoverCd } = await import("../state-adoption/cd-cutover");
   if (command === "cd-resume") return resumeCutoverCd(input, cdWatcherPauses);
+  if (input?.fleet) throw new Error("Fleet activation uses bun run release --deploy-only --cutover-manifest PATH under the existing executor");
   const [{ resolveCanonicalRelayDbPath, withDeployLedgerDb }, { resolveReleaseLocalOrchestratorId }] = await Promise.all([
     import("../../scripts/cd-config"), import("../../scripts/release-upgrade")]);
   const dbPath = resolveCanonicalRelayDbPath();
@@ -54,20 +54,3 @@ async function cdCutover(command: string, input: any, options: { rollback: boole
       : adoptLinux(input.handoff, { rollback, systemctl: options.systemctl, interrupt: options.interrupt }),
   });
 }
-
-/** The audited maintenance pause API (#1645) for cd-watcher; an existing pause is returned, ours or not. */
-const cdWatcherPauses: CdPauseControl = {
-  async pause(holder, reason) {
-    try {
-      return ((await apiRequest("POST", "/api/maintenance/jobs/cd-watcher/pause", { holder, reason, indefinite: true })) as { pause: CdPause }).pause;
-    } catch (error) {
-      if (error instanceof ApiRequestError && error.status === 409) return (error.responseBody as { pause: CdPause }).pause;
-      throw error;
-    }
-  },
-  async current() {
-    const { pauses } = (await apiRequest("GET", "/api/maintenance/pauses")) as { pauses: Array<CdPause & { jobId: string }> };
-    return pauses.find((pause) => pause.jobId === "cd-watcher") ?? null;
-  },
-  async resume() { await apiRequest("POST", "/api/maintenance/jobs/cd-watcher/resume"); },
-};

package/src/cli/task-edit.ts

@@ -0,0 +1,22 @@
+import { parseTaskIdValue } from "../validation";
+import { apiRequest } from "./_shared";
+
+const fields: Record<string, string> = { "--title": "title", "--intent": "intent", "--done-when": "doneWhen", "--on-deploy": "onDeploy", "--team": "teamId", "--repo": "repo" };
+
+export async function editTaskCommand(args: string[]): Promise<void> {
+  const create = args[0] === "create";
+  const id = create ? undefined : parseTaskIdValue(args[1] ?? "");
+  if (!create && !id) throw new Error("taskId must be a positive integer (TNNNN accepted)");
+  const body: Record<string, string> = {};
+  for (let i = create ? 1 : 2; i < args.length; i++) {
+    const flag = args[i]!;
+    if (flag === "--json") continue;
+    const field = fields[flag];
+    if (!field || i + 1 >= args.length) throw new Error(`Unknown or missing task ${args[0]} option: ${flag}`);
+    body[field] = args[++i]!;
+  }
+  if (create && (!body.title || !body.intent)) throw new Error("task create requires --title and --intent");
+  if (!Object.keys(body).length) throw new Error("task update requires a field such as --on-deploy");
+  const result = await apiRequest(create ? "POST" : "PATCH", create ? "/api/tasks" : `/api/tasks/${id}`, body);
+  console.log(JSON.stringify(result, null, 2));
+}

package/src/cli/task.ts

@@ -1,3 +1,4 @@
+import { editTaskCommand } from "./task-edit";
 // Task commands — #2518 review-hold control (`humwick task review-hold …`) + #2312
 // withdraw-land (`humwick task withdraw-land …`). Thin HTTP clients (same apiRequest seam
 // as workspace.ts): all policy — coordinator-only authorization, the expected-HEAD CAS,
@@ -11,7 +12,7 @@ function parseTaskId(raw: string | undefined): number | null {
   return raw === undefined ? null : parseTaskIdValue(raw);
 }
 
-export const TASK_USAGE = "Usage: humwick task get <taskId> [--verbose] [--json] | humwick task review-hold <taskId> <status|set|clear> [--expected-head SHA] [--reason TEXT] [--json] | humwick task withdraw-land <workspaceId> [--reason TEXT] [--json]";
+export const TASK_USAGE = "Usage: humwick task create --title TEXT --intent TEXT [--on-deploy TEXT] | humwick task update <taskId> [--on-deploy TEXT] | humwick task get <taskId> [--verbose] [--json] | humwick task review-hold <taskId> <status|set|clear> [--expected-head SHA] [--reason TEXT] [--json] | humwick task withdraw-land <workspaceId> [--reason TEXT] [--json]";
 
 interface ReviewHoldStatusView {
   id: number;
@@ -48,6 +49,7 @@ function renderStatus(task: ReviewHoldStatusView): string {
 
 export async function handleTaskCommand(args: string[]): Promise<void> {
   const sub = args[0];
+  if (sub === "create" || sub === "update") return editTaskCommand(args);
   if (sub === "get") {
     const taskId = parseTaskId(args[1]);
     if (taskId === null) throw new Error(`taskId must be a positive integer (TNNNN accepted). ${TASK_USAGE}`);

package/src/cli/workflow.ts

@@ -1,7 +1,7 @@
 import { apiRequest } from "./_shared";
 import { probeWorkflowDeployment } from "../../scripts/wait-for-deploy";
 
-export const WORKFLOW_USAGE = "Usage: humwick workflow start <workflow> <taskId> [--json] | workflow get <runId> [--verbose] [--include-held] [--results-ref <id>] [--results-cursor <cursor>] [--json] | workflow resume <runId> [--activation <id>]";
+export const WORKFLOW_USAGE = "Usage: humwick workflow start <workflow> <taskId> [--json] | workflow get <runId> [--verbose] [--include-held] [--results-ref <id>] [--results-cursor <cursor>] [--json] | workflow resume <runId> [--activation <id>] [--step <step>] [--pins <json>] [--note <text>] | workflow pause <runId> --reason <text> | workflow unpause <runId>";
 
 export async function handleWorkflowCommand(args: string[]): Promise<void> {
   const [command, runId, ...flags] = args;
@@ -25,10 +25,25 @@ export async function handleWorkflowCommand(args: string[]): Promise<void> {
     }
     return;
   }
-  if (!["get", "resume"].includes(command ?? "") || !runId || runId.startsWith("--")) throw new Error(WORKFLOW_USAGE);
+  if (!["get", "resume", "pause", "unpause"].includes(command ?? "") || !runId || runId.startsWith("--")) throw new Error(WORKFLOW_USAGE);
+  if (command === "pause" || command === "unpause") {
+    // #3757 — a pause says why the run waits; the server refuses an empty reason.
+    if (command === "pause" ? flags.length !== 2 || flags[0] !== "--reason" || !flags[1]?.trim() : flags.length) throw new Error(WORKFLOW_USAGE);
+    console.log(JSON.stringify(await apiRequest("POST", `/api/workflows/runs/${encodeURIComponent(runId)}/${command}`, command === "pause" ? { reason: flags[1] } : {}), null, 2));
+    return;
+  }
   if (command === "resume") {
-    if (flags.length && (flags[0] !== "--activation" || flags.length !== 2 || !flags[1])) throw new Error(WORKFLOW_USAGE);
-    console.log(JSON.stringify(await apiRequest("POST", `/api/workflows/runs/${encodeURIComponent(runId)}/resume`, { ...(flags[1] ? { activationId: flags[1] } : {}) }), null, 2));
+    const body: Record<string, unknown> = {};
+    const fields: Record<string, string> = { "--activation": "activationId", "--step": "step", "--pins": "pins", "--note": "note" };
+    for (let index = 0; index < flags.length; index++) {
+      const flag = flags[index]!;
+      if (flag === "--json") continue;
+      const field = fields[flag];
+      const value = flags[++index];
+      if (!field || !value || value.startsWith("--")) throw new Error(WORKFLOW_USAGE);
+      body[field] = field === "pins" ? JSON.parse(value) : value;
+    }
+    console.log(JSON.stringify(await apiRequest("POST", `/api/workflows/runs/${encodeURIComponent(runId)}/resume`, body), null, 2));
     return;
   }
   const query = new URLSearchParams();

package/src/commands-db.ts

@@ -305,7 +305,7 @@ export { buildListCommandsQuery } from "./db/commands-list-query";
 
 export function listCommands(filters: CommandFilters = {}): Command[] {
   const { sql, params } = buildListCommandsQuery(filters);
-  return (getDb().query(sql).all(...params as any[]) as CommandRow[]).map(rowToCommand);
+  return (getDb().query(sql).all(...params as any[]) as CommandRow[]).map((row) => rowToCommand(row, { slim: filters.slim }));
 }
 
 
@@ -834,13 +834,13 @@ export function deleteCommand(id: string): boolean {
 
 // Race the host claim on the same pending row; only the winning cancellation records stop intent.
 // Legacy landing cancellation stays confined to its unfenced rows.
-export function cancelPendingCommand(id: string, expectedType: string, reason = "canceled before dispatch"): boolean {
+export function cancelPendingCommand(id: string, expectedType: string, reason = "canceled before dispatch", submittedAt: number = Date.now()): boolean {
   if (expectedType === "workspace.merge") {
     const existing = getCommand(id);
     if (!existing || !isLegacyUnfencedWorkspaceMerge(existing)) return false;
   }
   return inWriteTransaction(() => {
-    const now = Date.now();
+    const now = submittedAt;
     const changes = getDb()
       .query(`UPDATE commands SET status = 'canceled', result = ${canceledSpawnResultSql()}, error = ?, updated_at = ? WHERE id = ? AND status = 'pending' AND type = ?`)
       .run(reason, now, id, expectedType).changes;
@@ -920,7 +920,7 @@ export const ACCEPTED_BY_OWNER_SQL = `SELECT * FROM commands INDEXED BY idx_comm
 export function listAcceptedCommandsByOwner(target: string, ownerToken: string): Command[] {
   if (!target || !ownerToken) return [];
   const rows = getDb().query(ACCEPTED_BY_OWNER_SQL).all(target, ownerToken, Date.now()) as CommandRow[];
-  return rows.map(rowToCommand);
+  return rows.map((row) => rowToCommand(row));
 }
 
 // #1452 round-12 HIGH#2 — RE-FENCE a claimed review-publish command IMMEDIATELY before the host's
@@ -978,7 +978,7 @@ export const EXPIRED_PENDING_COMMANDS_SQL = `SELECT * FROM commands WHERE (type
 
 export function expireCommands(
   now: number = Date.now(),
-  opts: { isTargetGone?: (command: Command) => boolean } = {},
+  opts: { isTargetGone?: (command: Command) => boolean; update?: typeof updateCommand } = {},
 ): Command[] {
   const activeRows = getDb().query(EXPIRED_CLAIMED_COMMANDS_SQL).all(now, ...CLAIMED_ACTIVE_STATUSES) as CommandRow[];
   const pendingCandidates = getDb().query(EXPIRED_PENDING_COMMANDS_SQL).all(now) as CommandRow[];
@@ -998,7 +998,7 @@ export function expireCommands(
     // #1452 round-13 — the TTL sweep is an AUTHORIZED terminalizer of a claimed publish (executor:true):
     // it is the fail-closed path that lets the reconciler clean a host-death-after-claim, and timed_out is
     // ambiguous (ref retained), never a ref-drop. External surfaces get no such flag (see updateCommand).
-    updateCommand(row.id, {
+    (opts.update ?? updateCommand)(row.id, {
       status: "timed_out",
       error: row.status === "pending"
         ? ((row.type === "agent.spawn" || row.type === "agent.restart") && hostSpawnsDrained(row.target) ? "host draining: spawns disabled; expired before dispatch" : "command target gone; expired before dispatch")
@@ -1142,7 +1142,7 @@ export function activeRestartSensitiveCommands(now: number = Date.now()): Comman
          AND (type != 'agent.spawn' OR coalesce(json_extract(params, '$.registrationConfirmed'), 0) != 1)
        ORDER BY updated_at ASC`,
     )
-    .all(...CLAIMED_ACTIVE_STATUSES, now, now) as CommandRow[]).map(rowToCommand);
+    .all(...CLAIMED_ACTIVE_STATUSES, now, now) as CommandRow[]).map((row) => rowToCommand(row));
 }
 
 // #1746 RC-2 / issue ask 4 — when a shutdown command settles WITHOUT a confirmed kill (the

package/src/commands-write.ts

@@ -49,6 +49,10 @@ export async function createCommandAsync(
   vaultProjectId?: string,
 ): Promise<Command> {
   const args = await prepareCommandWriteAsync(input, options, vaultActor, vaultProjectId);
+  return submitPreparedCommandAsync(args);
+}
+
+export function submitPreparedCommandAsync(args: CreateCommandWriteArgs): Promise<Command> {
   return getGateway().coalesce(
     "commands.create",
     args,
@@ -82,6 +86,10 @@ export function getCommandAsync(id: string): Promise<Command | null> {
   return getGateway().read("commands.get", { id }) as unknown as Promise<Command | null>;
 }
 
+export function findLatestCommandByCorrelationAsync(type: string, correlationId: string): Promise<Command | null> {
+  return getGateway().read("commands.latestByCorrelation", { type, correlationId }) as unknown as Promise<Command | null>;
+}
+
 /** #2969 — an agent's confirmed effort changes within a chat window's time range, read off-loop. */
 export function listEffortChangesAsync(agentId: string, from: number, to: number, after?: EffortChangeCursor): Promise<{ changes: EffortChange[]; next?: EffortChangeCursor }> {
   return getGateway().read("commands.effortChanges", { agentId, from, to, ...(after ? { after } : {}) }) as unknown as Promise<{ changes: EffortChange[]; next?: EffortChangeCursor }>;

package/src/compaction-watch.ts

@@ -1,6 +1,8 @@
+import { framed } from "./hub-metrics";
+import { createActivityEventAsync } from "./db/activity-async";
 import { timePostBindPhase } from "./post-bind-startup";
 import { guardedInterval, isRecord } from "@humwick/sdk";
-import { getAgent, createActivityEvent } from "./db";
+import { getAgent } from "./db";
 import { emitRelayEvent } from "./events";
 import { isContinuationSelfResumeCommand } from "./self-resume-command";
 import type { AgentCard, Command } from "./types";
@@ -74,7 +76,7 @@ export class CompactionWatch {
   start(): void {
     if (this.timer) return;
     // #3643 — the tick writes an activity event; a BUSY from a bare timer would exit the hub.
-    this.timer = guardedInterval("[compaction-watch] tick", this.tickMs, () => timePostBindPhase("compaction-watch.tick", () => this.tick()));
+    this.timer = guardedInterval("[compaction-watch] tick", this.tickMs, framed("timer compaction-watch", () => timePostBindPhase("compaction-watch.tick", async () => (await this.tick()))));
   }
 
   stop(): void {
@@ -116,7 +118,7 @@ export class CompactionWatch {
     this.pending.delete(agentId);
   }
 
-  tick(): void {
+  async tick(): Promise<void> {
     const now = this.now();
     for (const [agentId, watch] of this.pending) {
       if (watch.deadline > now) continue;
@@ -138,15 +140,15 @@ export class CompactionWatch {
           continue;
         }
         this.pending.delete(agentId);
-        this.emitStalled(watch, true);
+        (await this.emitStalled(watch, true));
         continue;
       }
       this.pending.delete(agentId);
-      this.emitStalled(watch);
+      (await this.emitStalled(watch));
     }
   }
 
-  private emitStalled(watch: PendingWatch, busyCapped = false): void {
+  private async emitStalled(watch: PendingWatch, busyCapped = false): Promise<void> {
     const verb = watch.kind === "compact" ? "Compaction" : "Context clear";
     // #2043 F3 — the busy-capped variant means the agent is STILL taking turns (not stuck at a menu)
     // yet the compaction never started after a bounded wait — the runaway shape from #2043.
@@ -159,7 +161,7 @@ export class CompactionWatch {
       subject: watch.agentId,
       data: { agentId: watch.agentId, commandId: watch.commandId, kind: watch.kind, detail, busyCapped },
     });
-    createActivityEvent({
+    (await createActivityEventAsync({
       clientId: `command-stalled-${watch.commandId}-${this.now()}-${++this.seq}`,
       kind: "state",
       title: `${verb} stalled: ${watch.agentId}`,
@@ -168,7 +170,7 @@ export class CompactionWatch {
       view: "agents",
       agentId: watch.agentId,
       metadata: { source: "compaction-watch", commandId: watch.commandId, kind: watch.kind, stalled: true, detail, busyCapped },
-    });
+    }));
   }
 }
 

package/src/config-store-write.ts

@@ -6,7 +6,8 @@
 
 import { randomUUID } from "node:crypto";
 import { getGateway } from "./db/gateway.ts";
-import type { ConfigEntry } from "./types.ts";
+import { agentProfileDeleteTarget, agentProfileWriteNamespace, savedAgentProfileEntry } from "./config-store.ts";
+import type { AgentProfile, ConfigEntry } from "./types.ts";
 
 /**
  * Set a config entry off-loop (landmine #2). Routes through a single serialized `config.set` writer op
@@ -37,3 +38,14 @@ export function setConfigAsync<T = unknown>(
 export function deleteConfigAsync(namespace: string, key: string, updatedBy?: string): Promise<boolean> {
   return getGateway().write("config.delete", { namespace, key, updatedBy }) as unknown as Promise<boolean>;
 }
+
+/** `setAgentProfile` on the writer thread (#1870 S7). */
+export async function setAgentProfileAsync(profile: AgentProfile, updatedBy?: string, opts: { overrideBuiltIn?: boolean } = {}): Promise<ConfigEntry<AgentProfile>> {
+  return savedAgentProfileEntry(await setConfigAsync(agentProfileWriteNamespace(profile, opts), profile.name, profile, updatedBy));
+}
+
+/** `deleteAgentProfile` on the writer thread (#1870 S7). */
+export async function deleteAgentProfileAsync(name: string, updatedBy?: string, opts: { resetBuiltInOverride?: boolean } = {}): Promise<boolean> {
+  const target = agentProfileDeleteTarget(name, opts);
+  return (await deleteConfigAsync(target.namespace, target.key, updatedBy));
+}