@humwick/server 0.130.0 → 0.130.2

package/src/routes/agents.ts

@@ -2,7 +2,7 @@
 import { messageViewerForRequest, visibleMessages } from "./message-viewer";
 import { attachPrincipal, attachPrincipals } from "../agent-principal";
 import { VALID_AGENT_STATUSES, agentSessionStatus, auditEvent, canViewAgentRoute, error, json, normalizeAgentSessionGuard, parseBody, parseId, parseQueryInt, visibleAgentIdsForRequest, type Handler } from "./_shared";
-import { ValidationError, deleteAgentAsync, getAgent, getAgentAsync, getAgentIdentityAsync, getAgentQuotaSnapshotsAsync, getAgentTimelineAsync, getCrashReport, recordHeartbeat, listAgentChatHistoryAsync, listAgents, listAgentsAsync, listArtifactsForEntityAsync, listContextSnapshotsAsync, listPendingReplyObligationsAsync, markReadyAsync, searchAgentsAsync, setLabelAsync, setStatusAsync, setTagsAsync, validateAgentSession } from "../db";
+import { ValidationError, deleteAgentAsync, getAgent, getAgentAsync, getAgentIdentityAsync, getAgentQuotaSnapshotsAsync, getAgentTimelineAsync, getCrashReport, recordHeartbeatAsync, listAgentChatHistoryAsync, listAgents, listAgentsAsync, listArtifactsForEntityAsync, listContextSnapshotsAsync, listPendingReplyObligationsAsync, markReadyAsync, searchAgentsAsync, setLabelAsync, setStatusAsync, setTagsAsync, validateAgentSession } from "../db";
 import { attachBranchState, attachBranchStates } from "../agent-branch-state";
 import { redactAgentCardLaunchShape } from "../agent-launch-shape-redaction";
 import { attachChannelBinding, attachChannelBindings } from "../agent-channel-binding";
@@ -258,8 +258,8 @@ function cleanAgentStatus(value: unknown): AgentStatusValue {
 // #3606 — a reported status/readiness equal to the live card is a liveness tick, not a transition: no
 // row write, no agent.status event. Presence still advances through the coalescing heartbeat buffer,
 // except for a terminal row, which a beat would resurrect.
-function noteUnchangedLifecycle(agentId: string, current: AgentCard, guard: AgentSessionGuard | undefined): void {
-  if (current.status !== "offline" && current.status !== "stale") recordHeartbeat(agentId, { guard });
+async function noteUnchangedLifecycle(agentId: string, current: AgentCard, guard: AgentSessionGuard | undefined): Promise<void> {
+  if (current.status !== "offline" && current.status !== "stale") await recordHeartbeatAsync(agentId, { guard });
 }
 
 async function applyAgentStatus(agentId: string, status: AgentStatusValue, guard: AgentSessionGuard | undefined, before: AgentCard | null): Promise<boolean> {
@@ -309,7 +309,7 @@ export const patchAgentStatus: Handler = async (req, params) => {
     const session = validateAgentSession(params.id!, guard);
     if (!session.ok) return error(session.error!, agentSessionStatus(session.error));
     const before = getAgent(params.id!);
-    if (before?.status === status) noteUnchangedLifecycle(params.id!, before, guard);
+    if (before?.status === status) await noteUnchangedLifecycle(params.id!, before, guard);
     else if (!(await applyAgentStatus(params.id!, status, guard, before))) return error("agent not found", 404);
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);
@@ -349,7 +349,7 @@ export const postHeartbeat: Handler = async (req, params) => {
     // A reported terminal status must not be undone by the beat's offline/stale resurrection.
     if (status !== "offline" && status !== "stale") {
       // #1468 — route the API heartbeat through the same coalescing buffer as the bus path.
-      if (!recordHeartbeat(params.id!, { guard })) return error("agent not found", 404);
+      if (!(await recordHeartbeatAsync(params.id!, { guard }))) return error("agent not found", 404);
     }
     if (wasUnavailable) {
       const after = getAgent(params.id!);
@@ -429,7 +429,7 @@ export const patchAgentReady: Handler = async (req, params) => {
     const session = validateAgentSession(params.id!, guard);
     if (!session.ok) return error(session.error!, agentSessionStatus(session.error));
     const before = getAgent(params.id!);
-    if (before?.ready === body.ready) noteUnchangedLifecycle(params.id!, before, guard);
+    if (before?.ready === body.ready) await noteUnchangedLifecycle(params.id!, before, guard);
     else if (!(await applyAgentReady(params.id!, body.ready, guard, before))) return error("agent not found", 404);
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);

package/src/routes/commands-listing.ts

@@ -32,6 +32,10 @@ export const getCommands: Handler = async (req) => {
     limit: limitRaw ?? undefined,
     dispatchableOnly,
     oldestFirst: dispatchableOnly && status === "pending",
+    // #3391 — a listing omits each spawn's inline agentProfile (13.9 MB per 30 rows blocked the hub
+    // loop); `GET /api/commands/:id` returns the full row. The executor dispatch feed runs the rows it
+    // polls, so it keeps the profile.
+    slim: !dispatchableOnly,
   });
   return json(commands.map((command) => serializeCommandForRead(command, ctx)));
 };

package/src/routes/commands.ts

@@ -29,7 +29,7 @@ import { KERNEL_CORRELATION_PREFIX, isReservedKernelCorrelationId } from "../ser
 import { prepareScheduledCommandResultForStorage, settleScheduledCommandTimer } from "../services/scheduler-command";
 import { ServiceAuthError } from "../services/errors";
 import { applyIdleRefreshResult } from "../maintenance/workspaces";
-import { seedMigratedProviderConfigs } from "../provider-config-store";
+import { seedMigratedProviderConfigsAsync } from "../provider-config-store";
 import { notifyAgentSpawnFailed } from "../agent-lifecycle-events";
 import { scheduleRepoMerge } from "../workspace-auto-merge";
 import { settleMemoryInjectionAfterContextCommand } from "../memory-injection";
@@ -559,7 +559,7 @@ export const patchCommand: Handler = async (req, params) => {
     if (command.type === "orchestrator.migrate-provider-config" && command.status === "succeeded" && isRecord(result)) {
       // Seed central rows from the reported host-local files with server authority (#465); idempotent, a
       // stored row wins. Seeds from the request: the persisted result holds only fingerprints (#3403).
-      const migration = seedMigratedProviderConfigs(result);
+      const migration = await seedMigratedProviderConfigsAsync(result);
       if (migration?.seeded.length) {
         const { host, seeded } = migration;
         await auditEvent({

package/src/routes/continuation-archives.ts

@@ -1,7 +1,7 @@
 // Auto-split from routes.ts (#299). Domain: continuation archives.
 import { isRecord } from "@humwick/sdk";
 import { resolveCallerAgentId } from "../agent-ref";
-import { archiveContinuationSegmentAsync, appendContinuationArchiveRefs, getAgent, listAgents, ValidationError } from "../db";
+import { archiveContinuationSegmentAsync, appendContinuationArchiveRefsAsync, getAgent, listAgents, ValidationError } from "../db";
 import { getComponentAuth } from "../security";
 import { cleanEpoch, cleanPositiveId, cleanString } from "../validation";
 import { error, json, parseBody, type Handler } from "./_shared";
@@ -21,7 +21,7 @@ export const postContinuationArchiveRoute: Handler = async (req) => {
       generation: cleanPositiveId(parsed.body.generation, "generation"),
       now: cleanEpoch(parsed.body.occurredAt, "occurredAt"),
     });
-    const envelope = appendContinuationArchiveRefs(agentId, [archive.ref]);
+    const envelope = await appendContinuationArchiveRefsAsync(agentId, [archive.ref]);
     return json({ archive, envelope }, 201);
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);

package/src/routes/host-resource-control.ts

@@ -38,7 +38,10 @@ export function cleanHostResourceControl(value: unknown): HostGateResourceContro
   })) as Partial<Record<HostGateKind, HostGateKindStatus>> : undefined;
   return { ...(kinds && HOST_GATE_KINDS.every(name => kinds[name]) ? { kinds: kinds as Record<HostGateKind, HostGateKindStatus> } : {}),
     ...(count(value.iterateOverflow) ? { iterateOverflow: value.iterateOverflow as number } : {}),
-    ...(typeof value.gateMemoryBytes === "number" && Number.isFinite(value.gateMemoryBytes) && value.gateMemoryBytes > 0 ? { gateMemoryBytes: value.gateMemoryBytes } : {}), ...(gateLimits ? { gateLimits } : {}), ...(reservations ? { projectGateReservations: reservations } : {}), ...(work ? { work, workTruncated: value.workTruncated === true || (value.work as unknown[]).length > 50 } : {}),
+    ...Object.fromEntries((["gateMemoryBytes", "gateMemoryUsedBytes", "runMemoryBytes"] as const).flatMap(key => {
+      const bytes = value[key];
+      return typeof bytes === "number" && Number.isSafeInteger(bytes) && bytes >= 0 ? [[key, bytes]] : [];
+    })), ...(gateLimits ? { gateLimits } : {}), ...(reservations ? { projectGateReservations: reservations } : {}), ...(work ? { work, workTruncated: value.workTruncated === true || (value.work as unknown[]).length > 50 } : {}),
     ...mechanism, usableCpus: usableCpus as number, gateCpus: gateCpus as number,
     memoryBytes: memoryBytes as number, slots: slots as number, held: held as number, waiters: waiters as number,
     ...(paths ? { paths } : {}) };

package/src/routes/index.ts

@@ -70,6 +70,7 @@ import { postIssueLifecycleReopenRoute } from "./issue-lifecycle";
 import { deleteIssueRefRoute, getIssueRefRoute, listIssueRefsRoute, patchIssueRefRoute, postIssueRefRoute, resolveIssueRefRoute } from "./issue-refs";
 import { deleteProjectEntryRoute, getProjectEntriesRoute, getProjectEntryRoute, getProjectInjectionPreviewRoute, getProjectResolveRoute, getProjectRoute, getProjectsRoute, patchProjectEntryRoute, postProjectEntryRoute } from "./projects";
 import { getPromptHistoryRoute, postPromptRevisionRoute, getPromptTemplateRoute, getPromptTemplatesRoute, postPromptTemplateResetRoute, putPromptTemplateRoute } from "./prompt-templates";
+import { projectProfileInstructionsRoute } from "./project-profile-instructions";
 import { getRecipeByName, getRecipeInstanceArtifacts, getRecipeInstanceById, getRecipeInstances, getRecipes, postRecipeInstanceArtifacts, postRecipeStart, postRecipeStop } from "./recipes";
 import { getSettingRoute, getSettingsNamespaceRoute, getSettingsRoute, putSettingRoute, putSettingsDefaultRoute } from "./settings";
 import { postNotificationPreviewRoute } from "./notifications";
@@ -85,7 +86,7 @@ import { postMcp } from "../mcp";
 import { postOrchestratorBootstrap, postOrchestratorBootstrapExchange } from "./orchestrator-bootstrap";
 import { getDeploysRoute } from "./deploys";
 import { getGateStatsRoute, getShippingBoardRoute, getShippingStatsRoute, postRedMainAbandonRoute } from "./shipping";
-import { getWorkflowCatalogRoute, getWorkflowDefinitionsRoute, getWorkflowRunBudgetRoute, getWorkflowRunRoute, getWorkflowRunsRoute, getWorkflowStatsRoute, patchWorkflowRunBudgetRoute, postWorkflowRunCancelRoute, postWorkflowRunResumeRoute, postWorkflowRunStartRoute } from "./workflows";
+import { getWorkflowCatalogRoute, getWorkflowDefinitionsRoute, getWorkflowRunBudgetRoute, getWorkflowRunRoute, getWorkflowRunsRoute, getWorkflowStatsRoute, patchWorkflowRunBudgetRoute, postWorkflowRunCancelRoute, postWorkflowRunPauseRoute, postWorkflowRunResumeRoute, postWorkflowRunStartRoute, postWorkflowRunUnpauseRoute } from "./workflows";
 import { getRestartEpochRoute, postRestartEpochAbandonRoute } from "./restart-epochs";
 import { getFleetConvergenceRoute } from "./fleet-convergence";
 import { postTimerMessageOperator } from "./kernel-timers-operator";
@@ -318,6 +319,7 @@ const routes: Route[] = [
   route("DELETE", "/api/commands/:id", deleteCommandById),
   route("POST", "/api/system/timer-message-cutover/:verb", postTimerMessageOperator),
   route("GET", "/api/agent-profiles", getAgentProfilesRoute),
+  route("GET", "/api/agent-profiles/:name/project-instructions", projectProfileInstructionsRoute),
   route("GET", "/api/agent-profiles/tool-groups", getAgentProfileToolGroupsRoute),
   route("POST", "/api/agent-profiles/preview", postAgentProfilePreviewRoute),
   route("GET", "/api/agent-profiles/:name/resolved", getResolvedAgentProfileRoute),
@@ -546,6 +548,11 @@ const routes: Route[] = [
   route("PATCH", "/api/issue-refs/:id", patchIssueRefRoute),
   route("DELETE", "/api/issue-refs/:id", deleteIssueRefRoute),
   route("GET", "/api/projects", getProjectsRoute),
+  route("GET", "/api/projects/:id/profile-instructions", projectProfileInstructionsRoute),
+  route("GET", "/api/projects/:id/profile-instructions/:profile", projectProfileInstructionsRoute),
+  route("PUT", "/api/projects/:id/profile-instructions/:profile", projectProfileInstructionsRoute),
+  route("GET", "/api/projects/:id/profile-instructions/:profile/history", projectProfileInstructionsRoute),
+  route("POST", "/api/projects/:id/profile-instructions/:profile/restore", projectProfileInstructionsRoute),
   route("POST", "/api/projects", postProjectOnboardRoute),
   route("POST", "/api/projects/:id/checkouts/bind", postProjectBindCheckoutRoute),
   route("POST", "/api/projects/:id/checkouts/unbind", postProjectUnbindCheckoutRoute),
@@ -600,6 +607,8 @@ const routes: Route[] = [
   route("GET", "/api/workflows/runs/:runId/budget", getWorkflowRunBudgetRoute),
   route("PATCH", "/api/workflows/runs/:runId/budget", patchWorkflowRunBudgetRoute),
   route("POST", "/api/workflows/runs/:runId/cancel", postWorkflowRunCancelRoute),
+  route("POST", "/api/workflows/runs/:runId/pause", postWorkflowRunPauseRoute),
+  route("POST", "/api/workflows/runs/:runId/unpause", postWorkflowRunUnpauseRoute),
   route("POST", "/api/workflows/runs/:runId/resume", postWorkflowRunResumeRoute),
   route("GET", "/api/workflows/stats", getWorkflowStatsRoute),
   route("GET", "/api/workflows/definitions", getWorkflowDefinitionsRoute),

package/src/routes/integrations.ts

@@ -1,7 +1,8 @@
+import type { IntegrationRegistryInput } from "../db/integrations";
 // Auto-split from routes.ts (#299). Domain: integrations.
 import { INTEGRATION_RATE_LIMIT_PER_MINUTE, MAX_BODY_BYTES, getIntegrationTokens, type IntegrationTokenConfig } from "../config";
 import { VALID_ARTIFACT_KINDS, VALID_ARTIFACT_ROLES, VALID_TASK_STATUSES, agentSessionStatus, authorizeRoute, cleanAttachmentRefs, dispatchTaskCallbacksInBackground, error, json, normalizeAgentSessionGuard, parseBody, reactionEmoji, sendReactionNotificationToAuthor, validateChannelAttachmentSourceRef, withPayloadAttachments, type Handler } from "./_shared";
-import { ValidationError, evaluatePoolBindingsAsync, findMessageByTelegramSourceAsync, getAgent, getChannelAsync, getMessage, ingestIntegrationEvent, isIntegrationRegistryEnabled, listChannelBindingsAsync, listChannelsAsync, listIntegrationRegistry, listIntegrationTaskStats, resolveChannelRoutesAsync, sendMessageWithResult, setMessageReactionAsync, upsertChannelBindingAsync, upsertIntegrationRegistry, validateAgentSession } from "../db";
+import { ValidationError, evaluatePoolBindingsAsync, findMessageByTelegramSourceAsync, getAgent, getChannelAsync, getMessage, ingestIntegrationEvent, isIntegrationRegistryEnabled, listChannelBindingsAsync, listChannelsAsync, listIntegrationTaskStatsAsync, reconcileIntegrationRegistryAsync, resolveChannelRoutesAsync, sendMessageWithResult, setMessageReactionAsync, upsertChannelBindingAsync, upsertIntegrationRegistry, validateAgentSession } from "../db";
 import { cleanMeta, cleanString, cleanStringArray, optionalEnum } from "../validation";
 import { emitChannelActivity, emitMessageQueued, emitMessageReactionUpdated, emitNewMessage, emitTaskChanged } from "../sse";
 import { getComponentAuth, getIntegrationAuth, hasIntegrationScope, isRequestAuthorizedFor } from "../security";
@@ -256,24 +257,7 @@ function normalizeIntegrationEvent(body: unknown): IntegrationEventInput {
   };
 }
 
-function normalizeIntegrationRegistryInput(name: string, body: unknown): {
-  name: string;
-  displayName?: string;
-  description?: string;
-  enabled?: boolean;
-  scopes?: string[];
-  targets?: string[];
-  channels?: string[];
-  type?: string;
-  icon?: string;
-  accentColor?: string;
-  tags?: string[];
-  homepageUrl?: string;
-  repositoryUrl?: string;
-  docsUrl?: string;
-  manifest?: Record<string, unknown>;
-  source: "api";
-} {
+function normalizeIntegrationRegistryInput(name: string, body: unknown): IntegrationRegistryInput & { source: "api" } {
   if (!isRecord(body)) throw new ValidationError("body must be an object");
   if (body.enabled !== undefined && typeof body.enabled !== "boolean") throw new ValidationError("enabled must be a boolean");
   return {
@@ -364,40 +348,30 @@ function safeCallbackHost(url: string | undefined): string | undefined {
   }
 }
 
-function reconcileIntegrationRegistry(configured: Map<string, IntegrationTokenConfig>, observedStats: Map<string, ReturnType<typeof listIntegrationTaskStats>[number]>): Map<string, ReturnType<typeof listIntegrationRegistry>[number]> {
-  for (const config of configured.values()) {
-    upsertIntegrationRegistry({
-      name: config.name,
-      displayName: config.displayName,
-      description: config.description,
-      scopes: config.scopes,
-      targets: config.targets,
-      channels: config.channels,
-      type: config.type,
-      icon: config.icon,
-      accentColor: config.accentColor,
-      tags: config.tags,
-      homepageUrl: config.homepageUrl,
-      repositoryUrl: config.repositoryUrl,
-      docsUrl: config.docsUrl,
-      manifest: config.manifest,
-      source: "env",
-    });
-  }
-  for (const stats of observedStats.values()) {
-    upsertIntegrationRegistry({
-      name: stats.source,
-      enabled: true,
-      source: "observed",
-    });
-  }
-  return new Map(listIntegrationRegistry().map((integration) => [integration.name, integration]));
+async function reconcileRegistry(configured: Map<string, IntegrationTokenConfig>, observedSources: string[]) {
+  const registry = await reconcileIntegrationRegistryAsync([...configured.values()].map((config) => ({
+    name: config.name,
+    displayName: config.displayName,
+    description: config.description,
+    scopes: config.scopes,
+    targets: config.targets,
+    channels: config.channels,
+    type: config.type,
+    icon: config.icon,
+    accentColor: config.accentColor,
+    tags: config.tags,
+    homepageUrl: config.homepageUrl,
+    repositoryUrl: config.repositoryUrl,
+    docsUrl: config.docsUrl,
+    manifest: config.manifest,
+  })), observedSources);
+  return new Map(registry.map((integration) => [integration.name, integration]));
 }
 
-export const getIntegrations: Handler = () => {
+export const getIntegrations: Handler = async () => {
   const configured = new Map(getIntegrationTokens().map((integration) => [integration.name, integration]));
-  const observedStats = new Map(listIntegrationTaskStats().map((stats) => [stats.source, stats]));
-  const registry = reconcileIntegrationRegistry(configured, observedStats);
+  const observedStats = new Map((await listIntegrationTaskStatsAsync()).map((stats) => [stats.source, stats]));
+  const registry = await reconcileRegistry(configured, [...observedStats.keys()]);
   const names = [...new Set([...configured.keys(), ...observedStats.keys(), ...registry.keys()])].sort((a, b) => a.localeCompare(b));
   const now = Date.now();
 

package/src/routes/issue-refs.ts

@@ -1,4 +1,4 @@
-import { deleteIssueRefMapping, getIssueRef, listIssueRefs, patchIssueRefMapping, resolveIssueRefMapping, upsertIssueRefMapping, type ListIssueRefsOptions } from "../services/issue-refs";
+import { deleteIssueRefMappingAsync, getIssueRef, listIssueRefs, patchIssueRefMappingAsync, resolveIssueRefMappingAsync, upsertIssueRefMappingAsync, type ListIssueRefsOptions } from "../services/issue-refs";
 import { getIssueRefByExternalKey, issueRefClosedCompleted, issueRefForRefString } from "../db/issue-refs";
 import { advanceTerminalPlanRefsAsync } from "../services/plan-terminal-refs";
 import { cleanEnum, cleanString, optionalEnum } from "../validation";
@@ -76,7 +76,7 @@ export const postIssueRefRoute: Handler = async (req) => {
   try {
     const body = cleanUpsertBody(parsed.body);
     const before = getIssueRefByExternalKey(body.provider, body.repo, body.externalKey);
-    const issueRef = upsertIssueRefMapping(body);
+    const issueRef = await upsertIssueRefMappingAsync(body);
     // #2520 — a completed close cached here propagates to the plan nodes bound to this ref.
     if (issueRefClosedCompleted(before, issueRef)) await advanceTerminalPlanRefsAsync({ issueRefId: issueRef.id });
     return json({ issueRef });
@@ -98,7 +98,7 @@ export const resolveIssueRefRoute: Handler = async (req) => {
       ? issueRefForRefString(ref, cleanString(value.defaultRepo ?? value.repo, "defaultRepo", { max: 500 }))
       : getIssueRefByExternalKey(cleanProvider(value.provider), cleanString(value.repo, "repo", { required: true, max: 500 })!, cleanString(value.externalKey, "externalKey", { required: true, max: 240 })!);
     const issueRef = ref
-      ? resolveIssueRefMapping({
+      ? await resolveIssueRefMappingAsync({
         ref,
         defaultRepo: cleanString(value.defaultRepo ?? value.repo, "defaultRepo", { max: 500 }),
         provider: optionalEnum(value.provider, "provider", ISSUE_PROVIDERS, "github") as IssueProvider,
@@ -107,7 +107,7 @@ export const resolveIssueRefRoute: Handler = async (req) => {
         closeReason: cleanCloseReason(value.closeReason),
         statusSyncedAt: cleanTimestamp(value.statusSyncedAt),
       })
-      : resolveIssueRefMapping({
+      : await resolveIssueRefMappingAsync({
         provider: cleanProvider(value.provider),
         repo: cleanString(value.repo, "repo", { required: true, max: 500 })!,
         externalKey: cleanString(value.externalKey, "externalKey", { required: true, max: 240 })!,
@@ -142,7 +142,7 @@ export const patchIssueRefRoute: Handler = async (req, params) => {
   try {
     const id = cleanString(params.id, "id", { required: true, max: 120 })!;
     const before = getIssueRef(id);
-    const issueRef = patchIssueRefMapping(id, cleanPatchBody(parsed.body));
+    const issueRef = await patchIssueRefMappingAsync(id, cleanPatchBody(parsed.body));
     if (!issueRef) return error("issue ref not found", 404);
     // #2520 — a completed close cached here propagates to the plan nodes bound to this ref.
     if (issueRefClosedCompleted(before, issueRef)) await advanceTerminalPlanRefsAsync({ issueRefId: issueRef.id });
@@ -152,9 +152,9 @@ export const patchIssueRefRoute: Handler = async (req, params) => {
   }
 };
 
-export const deleteIssueRefRoute: Handler = (_req, params) => {
+export const deleteIssueRefRoute: Handler = async (_req, params) => {
   try {
-    const deleted = deleteIssueRefMapping(cleanString(params.id, "id", { required: true, max: 120 })!);
+    const deleted = await deleteIssueRefMappingAsync(cleanString(params.id, "id", { required: true, max: 120 })!);
     if (!deleted) return error("issue ref not found", 404);
     return json({ deleted });
   } catch (err) {

package/src/routes/orchestrator-bootstrap.ts

@@ -6,7 +6,7 @@ import { authorizeRoute, cleanSafeNumber, error, json, parseBody, type Handler }
 import { cleanString, cleanStringArray } from "../validation";
 import { createTokenAsync, revokeTokenAsync } from "../token-db-write";
 import { getComponentAuth } from "../security";
-import { issueOrchestratorRuntimeToken } from "../runtime-tokens";
+import { issueOrchestratorRuntimeTokenAsync } from "../runtime-tokens";
 import { type SpawnProvider } from "../types";
 
 export const postOrchestratorBootstrap: Handler = async (req) => {
@@ -50,7 +50,7 @@ export const postOrchestratorBootstrap: Handler = async (req) => {
       "--yes",
     ];
     for (const entry of pathPrefix ?? []) args.push("--path-prefix", entry);
-    const command = ["bunx", `agent-relay-server@${version}`, ...args].map(quoteInstallCommandArg).join(" ");
+    const command = ["bunx", `@humwick/server@${version}`, ...args].map(quoteInstallCommandArg).join(" ");
     return json({
       command,
       relayUrl,
@@ -80,7 +80,7 @@ export const postOrchestratorBootstrapExchange: Handler = async (req) => {
     if (denied) return denied;
     const auth = getComponentAuth(req);
     if (!auth || auth.role !== "orchestrator-bootstrap") return error("bootstrap token required", 403);
-    const runtimeToken = issueOrchestratorRuntimeToken({
+    const runtimeToken = await issueOrchestratorRuntimeTokenAsync({
       orchestratorId: id,
       baseDir,
       createdBy: auth.jti ? `bootstrap:${auth.jti}` : "bootstrap",

package/src/routes/orchestrator-host-registration.ts

@@ -4,7 +4,7 @@
 // upsert, and fanning the operator-facing events out as activity events — lives here.
 import { isRecord } from "@humwick/sdk";
 import type { HostHardware } from "@humwick/sdk";
-import { upsertHostFromRegistrationAsync, type HostRegistrationEvent } from "../db";
+import { conflictingHardwareFields, upsertHostFromRegistrationAsync, type HostRegistrationEvent } from "../db";
 import { auditEvent, cleanSafeNumber } from "./_shared";
 import { recordOrchestratorUtilization } from "./orchestrator-host-utilization";
 import { cleanString } from "../validation";
@@ -55,7 +55,7 @@ async function emitHostRegistrationEvents(events: readonly HostRegistrationEvent
         clientId: `host-identity-conflict-${ev.hostId}-${ev.orchestratorId}-${Date.now()}`,
         kind: "state",
         title: "Host identity conflict",
-        body: `${ev.hostname}: reported hardware differs from the stored fingerprint — bound anyway, kept first-seen (conflict:pending)`,
+        body: `${ev.hostname}: reported hardware differs from the stored fingerprint (${conflictingHardwareFields(ev.stored, ev.reported).join(", ")} changed) — bound anyway, kept first-seen (conflict:pending)`,
         meta: ev.hostId,
         icon: "ti-alert-triangle",
         view: "orchestrators",

package/src/routes/orchestrator-host-utilization.ts

@@ -141,6 +141,7 @@ export function cleanHostUtilizationSample(value: unknown, now: number): HostUti
   const swapUsedMb = nonNegative(value.swapUsedMb);
   const diskTotalMb = nonNegative(value.diskTotalMb);
   const diskFreeMb = nonNegative(value.diskFreeMb);
+  const diskPath = optionalString(value.diskPath, "utilization.diskPath", 200);
 
   return {
     at,
@@ -162,7 +163,7 @@ export function cleanHostUtilizationSample(value: unknown, now: number): HostUti
     ...(swapTotalMb !== undefined && swapUsedMb !== undefined && swapUsedMb <= swapTotalMb
       ? { swapTotalMb, swapUsedMb } : {}),
     ...(diskTotalMb !== undefined && diskFreeMb !== undefined && diskFreeMb <= diskTotalMb
-      ? { diskTotalMb, diskFreeMb } : {}),
+      ? { diskTotalMb, diskFreeMb, ...(diskPath ? { diskPath } : {}) } : {}),
     memPressure,
     agentCountThisDaemon,
     queuedSpawnsThisDaemon,
@@ -207,6 +208,7 @@ export function toMachineSample(sample: HostUtilizationSample): HostMachineSampl
     ...(sample.swapTotalMb !== undefined ? { swapTotalMb: sample.swapTotalMb } : {}),
     ...(sample.diskFreeMb !== undefined ? { diskFreeMb: sample.diskFreeMb } : {}),
     ...(sample.diskTotalMb !== undefined ? { diskTotalMb: sample.diskTotalMb } : {}),
+    ...(sample.diskPath ? { diskPath: sample.diskPath } : {}),
     memPressure: sample.memPressure,
   };
 }

package/src/routes/orchestrator-proxy.ts

@@ -1,6 +1,6 @@
 // Auto-split from routes.ts (#299). Domain: orchestrator-proxy.
 import { RELAY_TOKEN_HEADER, SPAWN_PROVIDERS, isRecord } from "@humwick/sdk";
-import { ValidationError, getOrchestrator, orchestratorHeartbeat } from "../db";
+import { ValidationError, getOrchestrator, orchestratorHeartbeatAsync } from "../db";
 import { authorizeRoute, cleanJsonArray, error, json, type Handler } from "./_shared";
 import { cleanStringArray } from "../validation";
 import { emitOrchestratorStatus } from "../sse";
@@ -136,7 +136,7 @@ export const getOrchestratorProviders: Handler = async (req, params) => {
         }
       }
     }
-    const updated = orchestratorHeartbeat(params.id!, {
+    const updated = await orchestratorHeartbeatAsync(params.id!, {
       providers,
       providerStatus: cleanJsonArray(payload.providerStatus, "providerStatus") as OrchestratorRuntimeInput["providerStatus"],
       providerCatalog: cleanJsonArray(payload.providerCatalog, "providerCatalog") as OrchestratorRuntimeInput["providerCatalog"],

package/src/routes/orchestrator.ts

@@ -6,7 +6,7 @@ import { CONTRACT_VERSIONS, parseRuntimeCapabilities, parseRuntimeContracts, par
 import { notifyAgentOffline, notifyAgentSpawnQueued } from "../agent-lifecycle-events";
 import { diagnoseReportedExit } from "../services/reported-exit-death";
 import { VERSION } from "../config";
-import { ValidationError, deleteOrchestrator, effectiveProviderCatalogListAsync, getAgent, getOrchestrator, getOrchestratorAsync, listOrchestrators, listOrchestratorsAsync, orchestratorHeartbeat, orchestratorHeartbeatAsync, recordAgentExitDiagnosticsAsync, reportOrchestratorRosterAsync, setOrchestratorUpgradeState, upsertOrchestratorAsync } from "../db";
+import { ValidationError, deleteOrchestrator, effectiveProviderCatalogListAsync, getAgent, getOrchestrator, getOrchestratorAsync, listOrchestrators, listOrchestratorsAsync, orchestratorHeartbeatAsync, recordAgentExitDiagnosticsAsync, reportOrchestratorRosterAsync, setOrchestratorUpgradeStateAsync, upsertOrchestratorAsync } from "../db";
 import { reconcileOrchestratorSchedulerCommands } from "../services/scheduler-recovery.ts";
 import { recoverRegisteredOrchestrator } from "../services/orchestrator-registration-recovery";
 import { recoverOrchestratorLegacyLandings } from "../services/orchestrator-landing-recovery";
@@ -18,7 +18,7 @@ import { cleanMeta, cleanString, cleanStringArray, cleanWorkspaceMetadata, optio
 import { createCommandAsync } from "../commands-write";
 import { emitAgentStatus, emitOrchestratorStatus } from "../sse";
 import { getLifecycleManager } from "../lifecycle-manager";
-import { issueOrchestratorRuntimeToken } from "../runtime-tokens";
+import { issueOrchestratorRuntimeTokenAsync } from "../runtime-tokens";
 import { authContextFromRequest } from "../services/auth-context";
 import { serializeCommandForRead } from "../services/dispatch-command";
 import { isOrchestratorRegistrationAuthorized } from "../security";
@@ -198,7 +198,7 @@ export const postOrchestrator: Handler = async (req) => {
 	      metadata: { orchestratorId: id, providers: orch.providers, ...authAuditMetadata(req) },
 	    });
     const runtimeToken = isRootCredentialRequest(req)
-      ? issueOrchestratorRuntimeToken({ orchestratorId: id, baseDir, createdBy: `orchestrator:${id}` })
+      ? await issueOrchestratorRuntimeTokenAsync({ orchestratorId: id, baseDir, createdBy: `orchestrator:${id}` })
       : undefined;
     const hostProviders = await hostProviderSync(id, envProviders);
     return json({ ...orch, ...(runtimeToken ? { runtimeToken } : {}), hostProviders, gateBudget: gateBudgetForOrchestrator(id) }, 201);
@@ -624,7 +624,7 @@ export const postOrchestratorAction: Handler = async (req, params) => {
           ...(mode === "git-checkout" ? { mode, commitSha, repoUrl } : (npmReuseRepoUrl ? { repoUrl: npmReuseRepoUrl } : {})),
         },
       });
-      setOrchestratorUpgradeState(orch.id, {
+      await setOrchestratorUpgradeStateAsync(orch.id, {
         desiredVersion: targetVersion, ...(mode === "git-checkout" && commitSha ? { targetGitSha: commitSha } : {}),
         status: "pending",
         commandId: command.id,

package/src/routes/project-profile-instructions.ts

@@ -0,0 +1,27 @@
+import { cleanString } from "../validation";
+import { ValidationError } from "../db/connection";
+import { authorizeRoute, error, json, parseBody, type Handler } from "./_shared";
+import { authContextFromRequest } from "../services/auth-context";
+import { PromptVersionConflictError } from "../prompt-version-errors";
+import { listProjectProfileInstructions, mutateProjectProfileInstructions, projectProfileInstructionHistory, readProjectProfileInstructions } from "../services/project-profile-instructions";
+
+export const projectProfileInstructionsRoute: Handler = async (req, params) => {
+  const denied = authorizeRoute(req, { scope: req.method === "GET" ? "agent:read" : "agent:write" });
+  if (denied) return denied;
+  try {
+    const projectId = cleanString(params.id, "projectId", { max: 200 });
+    const profile = cleanString(params.profile ?? params.name, "profile", { max: 200 });
+    if (!projectId || !profile) return json(await listProjectProfileInstructions({ projectId, profile }));
+    const path = new URL(req.url).pathname;
+    if (req.method === "GET") return json(path.endsWith("/history")
+      ? await projectProfileInstructionHistory(projectId, profile)
+      : await readProjectProfileInstructions(projectId, profile));
+    const body = await parseBody<unknown>(req);
+    if (!body.ok) return error(body.error, body.status);
+    return json(await mutateProjectProfileInstructions(authContextFromRequest(req), projectId, profile, body.body, path.endsWith("/restore")));
+  } catch (err) {
+    if (err instanceof PromptVersionConflictError) return json({ error: err.message, current: err.current }, 409);
+    if (err instanceof ValidationError) return error(err.message, /not found/.test(err.message) ? 404 : 400);
+    throw err;
+  }
+};

package/src/routes/project-trust.ts

@@ -5,7 +5,7 @@
 // code runs, and built-in profiles are admin-edited anyway.
 import { isRecord } from "@humwick/sdk";
 import { ValidationError } from "../db";
-import { approveProfileProjectTrust, PROJECT_REVIEW_MODES, PROJECT_TRUST_CAPABILITIES, updateProfileProjectTrust } from "../services/profile-trust";
+import { approveProfileProjectTrust, PROJECT_REVIEW_MODES, PROJECT_TRUST_CAPABILITIES, updateProfileProjectTrustAsync } from "../services/profile-trust";
 import { cleanString, optionalEnum } from "../validation";
 import { auditEvent, error, isAdminRequest, json, normalizeConfigPathParam, parseBody, requestUserAddress, type Handler } from "./_shared";
 import { getAgentProfile } from "../config-store";
@@ -57,7 +57,7 @@ export const patchProjectTrustRoute: Handler = async (req, params) => {
     if (body.ack !== undefined && !Array.isArray(body.ack)) return error("ack must be an array of hooks|mcp", 400);
     const ack = (body.ack as unknown[] | undefined)?.map((capability) => optionalEnum(capability, "ack", PROJECT_TRUST_CAPABILITIES)!);
     const by = requestUserAddress(req);
-    const saved = updateProfileProjectTrust(name, { ...(review ? { review } : {}), ...(ack ? { ack } : {}) }, by);
+    const saved = await updateProfileProjectTrustAsync(name, { ...(review ? { review } : {}), ...(ack ? { ack } : {}) }, by);
     await auditEvent({
       kind: "state",
       title: `Project trust updated: ${saved.value.name}`,

package/src/routes/provider-config.ts

@@ -3,9 +3,10 @@ import { ValidationError, effectiveProviderCatalogListAsync, listOrchestrators,
 import { chooseProviderDefaultModel } from "../services/provider-catalog";
 import { applyCommandToRecipe } from "../recipe-runner";
 import { cleanString, cleanStringArray, optionalEnum } from "../validation";
-import { deleteCommand, getCommand } from "../commands-db";
+import { getCommand } from "../commands-db";
+import { deleteCommandAsync } from "../commands-write";
 import { emitCommand, error, json, parseBody, type Handler } from "./_shared";
-import { getProviderConfigEntry, listProviderConfigEntries, migrateLocalProviderConfigs, providerConfigPublic, setProviderConfig, VALID_PROVIDER_CONFIGS } from "../provider-config-store";
+import { getProviderConfigEntry, listProviderConfigEntries, migrateLocalProviderConfigsAsync, providerConfigPublic, setProviderConfigAsync, VALID_PROVIDER_CONFIGS } from "../provider-config-store";
 import { cleanProviderModelLimits } from "../provider-catalog-store";
 import { emitConfigChanged } from "../sse";
 import { setConfigAsync } from "../config-store-write";
@@ -27,9 +28,9 @@ export const getProvidersRoute: Handler = async () => {
   });
 };
 
-export const getProviderConfigsRoute: Handler = (req) => {
+export const getProviderConfigsRoute: Handler = async (req) => {
   const host = new URL(req.url).searchParams.get("host") ?? undefined;
-  migrateLocalProviderConfigs();
+  await migrateLocalProviderConfigsAsync();
   const entries = listProviderConfigEntries(host);
   return json(Object.fromEntries(VALID_PROVIDER_CONFIGS.map((provider) => {
     return [provider, providerConfigPublic(entries[provider] ?? getProviderConfigEntry(provider, host))];
@@ -126,12 +127,12 @@ export const deleteProviderModelRoute: Handler = async (_req, params) => {
   }
 };
 
-export const getProviderConfigRoute: Handler = (_req, params) => {
+export const getProviderConfigRoute: Handler = async (_req, params) => {
   const provider = optionalEnum(params.provider, "provider", VALID_PROVIDER_CONFIGS);
   if (!provider) return error("provider required");
   const host = new URL(_req.url).searchParams.get("host") ?? undefined;
   const includeSecrets = new URL(_req.url).searchParams.get("includeSecrets") === "1";
-  migrateLocalProviderConfigs();
+  await migrateLocalProviderConfigsAsync();
   return json(providerConfigPublic(getProviderConfigEntry(provider, host), { maskEnv: !includeSecrets }));
 };
 
@@ -144,7 +145,7 @@ export const putProviderConfigRoute: Handler = async (req, params) => {
     if (!isRecord(parsed.body)) return error("provider config body must be an object");
     const host = new URL(req.url).searchParams.get("host") ?? undefined;
     const updatedBy = cleanString(parsed.body.updatedBy, "updatedBy", { max: 200 });
-    const entry = setProviderConfig(provider, parsed.body, { host, updatedBy });
+    const entry = await setProviderConfigAsync(provider, parsed.body, { host, updatedBy });
     emitConfigChanged(entry.namespace, entry.key, entry.version);
     return json(providerConfigPublic(entry), entry.version === 1 ? 201 : 200);
   } catch (e) {
@@ -222,7 +223,7 @@ function optionalFraction(value: unknown, field: string): number | undefined {
 }
 
 export const deleteCommandById: Handler = async (_req, params) => {
-  if (!deleteCommand(params.id!)) return error("command not found or cannot be canceled", 404);
+  if (!await deleteCommandAsync(params.id!)) return error("command not found or cannot be canceled", 404);
   const command = getCommand(params.id!);
   if (command) {
     await applyCommandToRecipe(command);

package/src/routes/provider-quota-config.ts

@@ -8,7 +8,7 @@ import { error, json, parseBody, type Handler } from "./_shared";
 import {
   getProviderQuotaConfig,
   listProviderQuotaConfigs,
-  setProviderQuotaConfig,
+  setProviderQuotaConfigAsync,
   VALID_QUOTA_CONFIG_PROVIDERS,
 } from "../provider-quota-config-store";
 import { cleanString, optionalEnum } from "../validation";
@@ -40,7 +40,7 @@ export const putProviderQuotaConfigRoute: Handler = async (req, params) => {
   if (!parsed.ok) return error(parsed.error, parsed.status);
   try {
     const updatedBy = isRecord(parsed.body) ? cleanString(parsed.body.updatedBy, "updatedBy", { max: 200 }) : undefined;
-    return json(setProviderQuotaConfig(provider, parsed.body, { updatedBy }));
+    return json(await setProviderQuotaConfigAsync(provider, parsed.body, { updatedBy }));
   } catch (e) {
     if (e instanceof ValidationError) return error(e.message, 400);
     throw e;

package/src/routes/settings.ts

@@ -4,7 +4,7 @@ import { ValidationError } from "../db";
 import { getConfig } from "../config-store";
 import { setConfigAsync } from "../config-store-write";
 import { getUserSettingAsync, setUserSettingAsync } from "../user-settings-async";
-import { ensureProviderConfigDescriptors, migrateLocalProviderConfigs } from "../provider-config-store";
+import { ensureProviderConfigDescriptors, migrateLocalProviderConfigsAsync } from "../provider-config-store";
 import { ensureNotificationSettingDescriptors } from "../notification-settings-store";
 import { NOTIFICATIONS_NAMESPACE } from "../notification-settings";
 import { getSettingDescriptor, listSettingDescriptors, validateSettingValue, PROVIDER_CONFIG_NAMESPACE } from "../settings/registry";
@@ -23,7 +23,7 @@ type SettingEnvelope = SettingEntry;
 // as before the migration (back-compat). Server-runtime/bootstrap/browser tiers ignore this.
 
 export const getSettingsRoute: Handler = async (req) => {
-  migrateLocalProviderConfigs();
+  await migrateLocalProviderConfigsAsync();
   ensureProviderConfigDescriptors();
   ensureNotificationSettingDescriptors();
   return json({ settings: await listVisibleSettings(req) });
@@ -31,7 +31,7 @@ export const getSettingsRoute: Handler = async (req) => {
 
 export const getSettingsNamespaceRoute: Handler = async (req, params) => {
   const namespace = normalizeConfigPathParam(params.namespace, "namespace");
-  migrateLocalProviderConfigs();
+  await migrateLocalProviderConfigsAsync();
   ensureProviderConfigDescriptors();
   if (namespace === NOTIFICATIONS_NAMESPACE) ensureNotificationSettingDescriptors();
   const settings = await listVisibleSettings(req);
@@ -41,7 +41,7 @@ export const getSettingsNamespaceRoute: Handler = async (req, params) => {
 export const getSettingRoute: Handler = async (req, params) => {
   const namespace = normalizeConfigPathParam(params.namespace, "namespace");
   const key = normalizeConfigPathParam(params.key, "key");
-  migrateLocalProviderConfigs();
+  await migrateLocalProviderConfigsAsync();
   ensureProviderConfigDescriptors(namespace === PROVIDER_CONFIG_NAMESPACE ? [key] : []);
   if (namespace === NOTIFICATIONS_NAMESPACE) ensureNotificationSettingDescriptors([key]);
   const descriptor = getSettingDescriptor(namespace, key);
@@ -82,7 +82,7 @@ async function putSetting(req: Request, namespaceRaw: string | undefined, keyRaw
   if (!Object.prototype.hasOwnProperty.call(parsed.body, "value")) return error("value required", 400);
 
   try {
-    migrateLocalProviderConfigs();
+    await migrateLocalProviderConfigsAsync();
     ensureProviderConfigDescriptors(namespace === PROVIDER_CONFIG_NAMESPACE ? [key] : []);
     if (namespace === NOTIFICATIONS_NAMESPACE) ensureNotificationSettingDescriptors([key]);
     const descriptor = getSettingDescriptor(namespace, key);