@humwick/server 0.130.1 → 0.130.3

package/src/mcp-maintenance-tools.ts

@@ -11,7 +11,7 @@
 
 import { ValidationError } from "./db";
 import { McpNotFoundError } from "./mcp-errors";
-import { listMaintenanceJobs } from "./maintenance";
+import { listMaintenanceJobsAsync } from "./maintenance";
 import { listPauses, pauseJob, resumeJobAsync } from "./maintenance/pauses";
 import { authContextFromMcp } from "./services/auth-context";
 import { cleanString } from "./validation";
@@ -72,7 +72,7 @@ export async function relayMaintenanceTool(auth: McpAuthLike, name: string, args
   }
 
   if (name === "relay_maintenance_jobs") {
-    const jobs = listMaintenanceJobs();
+    const jobs = await listMaintenanceJobsAsync();
     const jobId = cleanString(args.jobId, "jobId", { max: 120 });
     if (!jobId) return { jobs, count: jobs.length };
     const job = jobs.find(candidate => candidate.id === jobId);

package/src/mcp-merge-tools.ts

@@ -29,24 +29,24 @@ export const MERGE_TOOLS = [
 
 type McpAuthLike = Parameters<typeof authContextFromMcp>[0];
 
-export function relayMergeTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Record<string, unknown> {
+export async function relayMergeTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Promise<Record<string, unknown>> {
   const ctx = authContextFromMcp(auth);
   if (name === "relay_merge_pauses") {
     const pauses = listAutoMergePauses();
     return { pauses, count: pauses.length };
   }
   if (name === "relay_merge_pause") {
-    const result = pauseAutoMerge({
+    const result = (await pauseAutoMerge({
       repoRoot: cleanString(args.repoRoot, "repoRoot", { required: true, max: 1024 })!,
       baseRef: cleanString(args.baseRef, "baseRef", { max: 240 }),
       holder: cleanString(args.holder, "holder", { max: 240 }) ?? ctx.callerAgentId ?? ctx.actor.id,
       reason: cleanString(args.reason, "reason", { max: 1000 }),
       ttlMs: optionalPositiveInt(args.ttlMs, "ttlMs"),
-    });
+    }));
     return result.ok ? { ok: true, pause: result.pause } : { ok: false, error: "merge target already paused", pause: result.pause };
   }
   if (name === "relay_merge_renew") {
-    const pause = renewAutoMergePause(cleanString(args.id, "id", { required: true, max: 120 })!, optionalPositiveInt(args.ttlMs, "ttlMs"));
+    const pause = (await renewAutoMergePause(cleanString(args.id, "id", { required: true, max: 120 })!, optionalPositiveInt(args.ttlMs, "ttlMs")));
     if (!pause) throw new McpNotFoundError("merge pause not found or expired");
     return { pause };
   }
@@ -54,7 +54,7 @@ export function relayMergeTool(auth: McpAuthLike, name: string, args: Record<str
     const id = cleanString(args.id, "id", { max: 120 });
     const repoRoot = cleanString(args.repoRoot, "repoRoot", { max: 1024 });
     if (!id && !repoRoot) throw new ValidationError("id or repoRoot required");
-    return { released: resumeAutoMerge({ id, repoRoot, baseRef: cleanString(args.baseRef, "baseRef", { max: 240 }) }) };
+    return { released: (await resumeAutoMerge({ id, repoRoot, baseRef: cleanString(args.baseRef, "baseRef", { max: 240 }) })) };
   }
   throw new ValidationError(`unknown tool: ${name}`);
 }

package/src/mcp-notification-subscription-tools.ts

@@ -1,5 +1,5 @@
+import { addSubscriptionAsync, addSubscriptionsAsync, removeSubscriptionAsync } from "./db/lifecycle-tail-async";
 import {
-  addSubscription,
   childStreamFromSubscriptionType,
   childStreamSubscriptionType,
   cleanChildStream,
@@ -9,7 +9,6 @@ import {
   listSubscriptions,
   NOTIFICATION_SUBSCRIPTION_MODES,
   NOTIFICATION_SUBSCRIPTION_TYPES,
-  removeSubscription,
   type ConfigurableChildStream,
   type ChildStream,
   type NotificationSubscriptionMode,
@@ -112,14 +111,14 @@ export async function relayNotificationSubscriptionTool(
     if (Object.prototype.hasOwnProperty.call(args, "streams")) {
       const scope = cleanChildStreamScope(args, agentId);
       const streams = cleanChildStreams(args.streams);
-      const subscriptions = streams
+      const subscriptions = await addSubscriptionsAsync(streams
         .filter((stream): stream is ConfigurableChildStream => stream !== "responses")
-        .map((stream) => addSubscription({
+        .map((stream) => ({
           agentId,
           type: childStreamSubscriptionType(stream),
           mode: cleanModeOrDefault(args.mode),
           scopeMatch: scope,
-        }));
+        })));
       return {
         subscriptions,
         childStreamFilter: {
@@ -132,21 +131,21 @@ export async function relayNotificationSubscriptionTool(
     if (Object.prototype.hasOwnProperty.call(args, "taskId")) {
       const scope = await taskScope(ctx, args.taskId, args.scope);
       const mode = cleanModeOrDefault(args.mode);
-      const subscriptions = TASK_NOTIFICATION_TYPES.map((type) => addSubscription({
+      const subscriptions = await addSubscriptionsAsync(TASK_NOTIFICATION_TYPES.map((type) => ({
         agentId,
         type,
         mode,
         scopeMatch: scope,
-      }));
+      })));
       return { subscriptions, taskFilter: scope };
     }
     if (args.type === undefined || args.type === null) throw new ValidationError("type or streams required");
-    const subscription = addSubscription({
+    const subscription = (await addSubscriptionAsync({
       agentId,
       type: cleanSubscriptionType(args.type),
       mode: cleanModeOrDefault(args.mode),
       scopeMatch: cleanScope(args.scope),
-    });
+    }));
     return { subscription };
   }
   if (name === "relay_unsubscribe") {
@@ -157,12 +156,12 @@ export async function relayNotificationSubscriptionTool(
       let removed = 0;
       for (const stream of streams) {
         if (stream === "responses") continue;
-        removed += removeSubscription({
+        removed += (await removeSubscriptionAsync({
           agentId,
           type: childStreamSubscriptionType(stream),
           mode: args.mode === undefined || args.mode === null ? undefined : cleanSubscriptionMode(args.mode),
           scopeMatch: scope,
-        });
+        }));
       }
       return { removed, responsesAlwaysOn: true };
     }
@@ -173,24 +172,24 @@ export async function relayNotificationSubscriptionTool(
         : [cleanSubscriptionType(args.type)];
       let removed = 0;
       for (const type of types) {
-        removed += removeSubscription({
+        removed += (await removeSubscriptionAsync({
           agentId,
           type,
           mode: args.mode === undefined || args.mode === null ? undefined : cleanSubscriptionMode(args.mode),
           scopeMatch: scope,
-        });
+        }));
       }
       return { removed };
     }
     const type = args.type === undefined || args.type === null ? undefined : cleanSubscriptionType(args.type);
     if (!id && !type) throw new ValidationError("id or type required");
-    const removed = removeSubscription({
+    const removed = (await removeSubscriptionAsync({
       agentId,
       id,
       type,
       mode: args.mode === undefined || args.mode === null ? undefined : cleanSubscriptionMode(args.mode),
       ...(Object.prototype.hasOwnProperty.call(args, "scope") ? { scopeMatch: cleanScope(args.scope) } : {}),
-    });
+    }));
     return { removed };
   }
   if (name === "relay_list_subscriptions") {

package/src/mcp-output-levels.test-fixture.ts

@@ -58,7 +58,7 @@ export async function seedOutputFixture(database: ReturnType<typeof db.getDb>) {
   await call("relay_decision", { action: "file", title: "Choose output convention", context: OUTPUT_BODY, questions: [{ prompt: "Adopt canonical verbosity?", kind: "text" }] });
   db.upsertWorkspace({ id: "output-ws", repoRoot: process.cwd(), sourceCwd: process.cwd(), worktreePath: process.cwd(), branch: "agent/output", orchestratorId: "output-host", ownerAgentId: caller, mode: "isolated", status: "active", metadata: {} });
   db.recordCrashReport({ agentId: "output-worker-0", parentId: caller, reason: "Provider exited", diagnosis: { cause: "provider-crash", confidence: "high", summary: "Provider exited with nonzero status", evidence: [OUTPUT_BODY], detectedAt: 1000 }, createdAt: 1000 });
-  const notification = routeNotification({ type: "agent.ready", scope: { agentId: "output-worker-0", parent: caller }, recipients: [caller], message: { body: "Worker ready" } })[0]!;
+  const notification = (await routeNotification({ type: "agent.ready", scope: { agentId: "output-worker-0", parent: caller }, recipients: [caller], message: { body: "Worker ready" } }))[0]!;
   const host = createSqliteModuleHost({ db: database, clock: createControllableClock(1000) });
   host.register(timers);
   const timer = await host.invoke(timers, "create", { actor: `runner:${caller}`, grants: ["timers:write"] }, { fireAt: 2000 }) as Timer;

package/src/mcp-profile-trust-tools.ts

@@ -3,7 +3,7 @@ import { INCLUDED_TOOL_SCOPE_NEEDS } from "./mcp/tool-groups";
 import { ValidationError } from "./db";
 import { callerAgentId } from "./mcp/identity";
 import { optionalEnum } from "./validation";
-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 type { McpAuthContext, ToolDefinition } from "./mcp/types";
 
 export const PROFILE_TRUST_TOOL: ToolDefinition = {
@@ -31,17 +31,17 @@ function text(args: Record<string, unknown>, field: string): string {
   return value.trim();
 }
 
-export function relayProfileTrust(auth: McpAuthContext, args: Record<string, unknown>): unknown {
+export async function relayProfileTrust(auth: McpAuthContext, args: Record<string, unknown>): Promise<unknown> {
   const name = text(args, "profile");
   const by = callerAgentId(auth) ?? auth.actor;
   if (args.action === "set-review") {
     const review = optionalEnum(args.review, "review", PROJECT_REVIEW_MODES);
     if (!review) throw new ValidationError("review is required");
-    return { trust: updateProfileProjectTrust(name, { review }, by).value.sources?.project?.trust };
+    return { trust: (await updateProfileProjectTrustAsync(name, { review }, by)).value.sources?.project?.trust };
   }
   const capability = optionalEnum(args.capability, "capability", PROJECT_TRUST_CAPABILITIES);
   if (!capability) throw new ValidationError("capability is required");
-  if (args.action === "ack") return { ack: updateProfileProjectTrust(name, { ack: [capability] }, by).value.sources?.project?.[capability]?.ack };
-  if (args.action === "approve") return { approval: approveProfileProjectTrust({ name, capability, repoKey: text(args, "repoKey"), value: text(args, "value"), by }) };
+  if (args.action === "ack") return { ack: (await updateProfileProjectTrustAsync(name, { ack: [capability] }, by)).value.sources?.project?.[capability]?.ack };
+  if (args.action === "approve") return { approval: (await approveProfileProjectTrust({ name, capability, repoKey: text(args, "repoKey"), value: text(args, "value"), by })) };
   throw new ValidationError("action must be set-review, ack or approve");
 }

package/src/mcp-project-journal-tools.ts

@@ -1,13 +1,5 @@
-import {
-  isProjectJournalField,
-  listProjectJournal,
-  listProjectJournalHistory,
-  PROJECT_JOURNAL_FIELDS,
-  PROJECT_JOURNAL_FIELD_LABELS,
-  setProjectJournalFields,
-  ValidationError,
-  type ProjectJournalField,
-} from "./db";
+import { setProjectJournalFieldsAsync } from "./db/runtime-tail-async";
+import { isProjectJournalField, listProjectJournal, listProjectJournalHistory, PROJECT_JOURNAL_FIELDS, PROJECT_JOURNAL_FIELD_LABELS, ValidationError, type ProjectJournalField } from "./db";
 import { callerProjectId } from "./mcp-project-tools";
 import { formatRelativeTime } from "./mcp/presentation";
 import { authContextFromMcp, type AuthContext } from "./services/auth-context";
@@ -109,7 +101,7 @@ function journalFieldViews(projectId: string, profile: string, filter: ProjectJo
     });
 }
 
-export function relayProjectJournalTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Record<string, unknown> {
+export async function relayProjectJournalTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Promise<Record<string, unknown>> {
   const ctx = authContextFromMcp(auth);
   const { projectId, profile } = journalScope(ctx);
 
@@ -127,7 +119,7 @@ export function relayProjectJournalTool(auth: McpAuthLike, name: string, args: R
       }
       fields[field] = value;
     }
-    setProjectJournalFields({ projectId, profile, fields, changedBy: authorId(ctx) });
+    (await setProjectJournalFieldsAsync({ projectId, profile, fields, changedBy: authorId(ctx) }));
     return { ok: true };
   }
 

package/src/mcp-project-tools.ts

@@ -1,33 +1,32 @@
-import { validateProjectEntryText } from "./validation";
+import { validateProjectEntryText, cleanString, cleanStringArray, optionalEnum } from "./validation";
 import { bindProjectCheckout, unbindProjectCheckout } from "./services/project-checkout-binding";
 import type { ToolDefinition } from "./mcp/types";
 import { PROJECT_ENTRY_SEARCH_PROPERTIES } from "./mcp/project-entry-search-schema";
 import { archiveProject, checkoutStatus, removeCheckout, onboardProject, registerProjectRoot } from "./services/project-onboarding";
 import {
-  addEdge,
+  addEdgeAsync,
   edgesFor,
   getAgent,
   getProject,
-  getProjectEntry,
+  getProjectEntryAsync,
   listProjects,
-  promoteBlackboardEntry,
+  promoteBlackboardEntryAsync,
   readMemoryEntriesByIdsAsync,
-  removeEdge,
+  removeEdgeAsync,
   resolveProject,
   resolveProjectEntriesAsync,
   resolveProjectForCwd,
-  retractProjectEntry,
+  retractProjectEntryAsync,
   rootsForProject,
   searchProjectEntriesAsync,
   ValidationError,
-  writeProjectEntry,
+  writeProjectEntryAsync,
 } from "./db";
 import { McpAuthError, McpNotFoundError } from "./mcp-errors";
 import { authContextFromMcp, type AuthContext } from "./services/auth-context";
 import { callerMemoryIdentity, callerProfile, resolveAgentWriteInject, resolveMemoryAudience } from "./services/memory-identity";
 import { areaCallerFromCtx, MEMORY_AREAS_SCHEMA, areaDeliveryReport, resolveWriteAreas } from "./services/memory-areas";
 import { ingestProjectClaudeMd } from "./services/project";
-import { cleanString, cleanStringArray, optionalEnum } from "./validation";
 import { PROJECT_EDGE_KINDS, PROJECT_ENTRY_INJECT_TIERS, PROJECT_ENTRY_KINDS, PROJECT_ENTRY_SOURCES, type ProjectEdgeKind, type ProjectEntry, type ProjectEntryInject, type ProjectEntryKind, type ProjectEntrySource } from "./types";
 
 const PROJECT_EDGE_INPUT_SCHEMA = {
@@ -267,8 +266,8 @@ function requireProjectId(ref: unknown, field: string): string {
 /** Load `entryId` and confirm it belongs to `projectId`, or throw not-found. Returns the entry
  * (not just void) so a supersede caller can reuse it — e.g. to inherit its audience (#2268)
  * instead of re-fetching. */
-function ensureSameProject(entryId: string, projectId: string): ProjectEntry {
-  const entry = getProjectEntry(entryId);
+async function ensureSameProject(entryId: string, projectId: string): Promise<ProjectEntry> {
+  const entry = await getProjectEntryAsync(entryId);
   if (!entry) throw new McpNotFoundError("project entry not found");
   if (entry.projectId !== projectId) throw new McpNotFoundError("project entry not found");
   return entry;
@@ -326,7 +325,7 @@ export async function relayProjectTool(auth: McpAuthLike, name: string, args: Re
     // previously-universal (`all`) rule silently stops injecting for every other role the moment
     // anyone re-saves it without naming an audience. Only true omission inherits; `self` still
     // means "just me" even here.
-    const priorEntry = supersedes ? ensureSameProject(supersedes, projectId) : undefined;
+    const priorEntry = supersedes ? await ensureSameProject(supersedes, projectId) : undefined;
     const anchor = getProject(projectId);
     if (!anchor) throw new McpNotFoundError("project not found");
     const areas = await resolveWriteAreas(anchor, areaCallerFromCtx(ctx), args.areas, { prior: priorEntry?.areas });
@@ -335,7 +334,7 @@ export async function relayProjectTool(auth: McpAuthLike, name: string, args: Re
       callerProfile(ctx),
       { kind, ...(priorEntry ? { priorInject: priorEntry.inject } : {}) },
     );
-    const entry = writeProjectEntry({
+    const entry = await writeProjectEntryAsync({
       projectId,
       authorId: authorId(ctx),
       kind,
@@ -354,7 +353,7 @@ export async function relayProjectTool(auth: McpAuthLike, name: string, args: Re
       inject: tier.inject,
       areas,
     });
-    return { ...entry, ...(tier.note ? { injectNote: tier.note } : {}), ...areaDeliveryReport(entry) } as unknown as Record<string, unknown>;
+    return { ...entry, ...(tier.note ? { injectNote: tier.note } : {}), ...await areaDeliveryReport(entry) } as unknown as Record<string, unknown>;
   }
 
   if (name === "relay_project_read") {
@@ -386,8 +385,8 @@ export async function relayProjectTool(auth: McpAuthLike, name: string, args: Re
   if (name === "relay_project_retract") {
     const projectId = targetProjectId(ctx, cleanString(args.project, "project", { max: 200 }));
     const id = cleanString(args.id, "id", { required: true, max: 120 })!;
-    ensureSameProject(id, projectId);
-    const entry = retractProjectEntry(id);
+    await ensureSameProject(id, projectId);
+    const entry = await retractProjectEntryAsync(id);
     if (!entry) throw new McpNotFoundError("project entry not found");
     return entry as unknown as Record<string, unknown>;
   }
@@ -395,21 +394,21 @@ export async function relayProjectTool(auth: McpAuthLike, name: string, args: Re
   if (name === "relay_project_add_edge") {
     const from = requireProjectId(args.from, "from");
     const to = requireProjectId(args.to, "to");
-    const edge = addEdge(from, to, cleanEdgeKind(args.kind));
+    const edge = await addEdgeAsync(from, to, cleanEdgeKind(args.kind));
     return { edge: edge as unknown as Record<string, unknown> };
   }
 
   if (name === "relay_project_remove_edge") {
     const from = requireProjectId(args.from, "from");
     const to = requireProjectId(args.to, "to");
-    const removed = removeEdge(from, to, cleanEdgeKind(args.kind));
+    const removed = await removeEdgeAsync(from, to, cleanEdgeKind(args.kind));
     return { removed };
   }
 
   if (name === "relay_project_promote_entry") {
     const projectId = targetProjectId(ctx, cleanString(args.project, "project", { max: 200 }));
     const blackboardEntryId = cleanString(args.blackboardEntryId, "blackboardEntryId", { required: true, max: 120 })!;
-    return promoteBlackboardEntry({ blackboardEntryId, projectId }) as unknown as Record<string, unknown>;
+    return await promoteBlackboardEntryAsync({ blackboardEntryId, projectId }) as unknown as Record<string, unknown>;
   }
 
   if (name === "relay_project_ingest_claudemd") {

package/src/mcp-provider-catalog.ts

@@ -1,9 +1,9 @@
-import { VALID_EFFORTS, isRecord } from "@humwick/sdk";
+import { isRecord } from "@humwick/sdk";
 import { effectiveProviderEffortLevelsAsync } from "./db";
 
 export async function providerCatalogToolInputSchema(name: string, inputSchema: Record<string, unknown>): Promise<Record<string, unknown>> {
   if (name !== "relay_spawn_agent") return inputSchema;
   const efforts = await effectiveProviderEffortLevelsAsync();
   const properties = isRecord(inputSchema.properties) ? inputSchema.properties : {};
-  return { ...inputSchema, properties: { ...properties, effort: { type: "string", enum: efforts.length ? efforts : VALID_EFFORTS } } };
+  return { ...inputSchema, properties: { ...properties, effort: { type: "string", enum: efforts }, selfEffortCeiling: { type: "string", enum: efforts } } };
 }

package/src/mcp-routing-policy-tools.ts

@@ -27,9 +27,10 @@ export const ROUTING_POLICY_TOOLS: ToolDefinition[] = [
   },
 ];
 
-export function relayRoutingPolicyTool(auth: McpAuthContext, name: string, args: Record<string, unknown>): unknown {
+export async function relayRoutingPolicyTool(auth: McpAuthContext, name: string, args: Record<string, unknown>): Promise<unknown> {
   if (name === "relay_routing_policy_get") return getRoutingPolicyEnvelope();
   if (name !== "relay_routing_policy_set") throw new ValidationError(`unknown tool: ${name}`);
   if (!isRecord(args.policy)) throw new ValidationError("policy must be an object");
-  return saveRoutingPolicy(args.policy, args.expectedRevision, callerAgentId(auth) ?? "mcp");
+  const { revision } = await saveRoutingPolicy(args.policy, args.expectedRevision, callerAgentId(auth) ?? "mcp");
+  return { revision };
 }

package/src/mcp-task-tools.ts

@@ -74,7 +74,7 @@ const TASK_ID_PROP = { oneOf: [{ type: "integer", minimum: 1 }, { type: "string"
 export const TASK_TOOLS = [
   {
     name: "relay_task_create",
-    description: "Create a durable Task. fromIssue digests GitHub title, body, acceptance, labels and references; explicit fields win.",
+    description: "Create Task; fromIssue imports GitHub content; explicit fields win.",
     requiredScopes: ["task:write"],
     inputSchema: {
       type: "object",
@@ -84,9 +84,11 @@ export const TASK_TOOLS = [
         intent: { type: "string" },
         fromIssue: { type: "string", description: "GitHub URL or owner/repo#number. Fetch once before atomic create." },
         tags: { type: "array", items: { type: "string" } },
+        paths: { type: "array", items: { type: "string" } },
         complexity: { type: "string", enum: TASK_DISPATCH_COMPLEXITIES },
         context: { type: "string" },
-        terminalStage: { type: "string", enum: TASK_TERMINAL_STAGES },
+        terminalStage: { enum: TASK_TERMINAL_STAGES },
+        onDeploy: { type: "string" },
         doneWhen: { type: "string" },
         teamId: { type: "string" },
         projectId: { type: "string" },
@@ -108,8 +110,8 @@ export const TASK_TOOLS = [
     },
   },
   { name: "relay_task_get", description: "Read a lean Task hydration; verbose:true includes full intent, gates and history projections.", requiredScopes: ["task:read"], inputSchema: { type: "object", properties: { taskId: TASK_ID_PROP, verbose: { type: "boolean" } }, required: ["taskId"], additionalProperties: false } },
-  { name: "relay_task_list", description: "List your Tasks by default; mine:false lists all. mode:brief is id/label/status; lean is default.", requiredScopes: ["task:read"], inputSchema: { type: "object", properties: { status: { type: "string", enum: DELIVERABLE_STATUS_ENUM }, deliverableStage: { type: "string", enum: TASK_DELIVERABLE_STAGES }, teamId: { type: "string" }, projectId: { type: "string" }, repo: { type: "string" }, mine: { type: "boolean" }, inFlight: { type: "boolean" }, staleOwnerGone: { type: "boolean" }, limit: { type: "integer", minimum: 1, maximum: 500 }, mode: { type: "string", enum: ["brief", "lean", "full"] }, verbose: { type: "boolean" } }, additionalProperties: false } },
-  { name: "relay_task_update", description: "Update Task intent, steer, criteria or dispatch.", requiredScopes: ["task:write"], inputSchema: { type: "object", properties: { taskId: TASK_ID_PROP, refreshIssue: { type: "object", description: "Explicit source refresh: {expectedRevision, resolutions?: {title|intent|doneWhen|tags: source|local}}. Conflicts require resolution." }, verbose: { type: "boolean" }, title: { type: "string" }, label: { type: "string" }, intent: { type: "string" }, complexity: { type: "string", enum: TASK_DISPATCH_COMPLEXITIES }, context: { type: "string" }, latestSteer: { type: "string" }, doneWhen: { type: "string" }, terminalStage: { anyOf: [{ type: "string", enum: TASK_TERMINAL_STAGES }, { type: "null" }] }, dispatch: DISPATCH_SHAPE_SCHEMA, teamId: { type: "string" }, projectId: { type: "string" }, repo: { type: "string" } }, required: ["taskId"], additionalProperties: false } },
+  { name: "relay_task_list", description: "List your Tasks by default; mine:false lists all. mode:brief is id/label/status; lean is default.", requiredScopes: ["task:read"], inputSchema: { type: "object", properties: { status: { enum: DELIVERABLE_STATUS_ENUM }, deliverableStage: { enum: [...TASK_DELIVERABLE_STAGES, "awaiting-deploy"] }, teamId: { type: "string" }, projectId: { type: "string" }, repo: { type: "string" }, mine: { type: "boolean" }, inFlight: { type: "boolean" }, staleOwnerGone: { type: "boolean" }, limit: { type: "integer", minimum: 1, maximum: 500 }, mode: { type: "string", enum: ["brief", "lean", "full"] }, verbose: { type: "boolean" } }, additionalProperties: false } },
+  { name: "relay_task_update", description: "Update Task intent, steer, criteria or dispatch.", requiredScopes: ["task:write"], inputSchema: { type: "object", properties: { taskId: TASK_ID_PROP, refreshIssue: { type: "object", description: "{expectedRevision, resolutions?: {title|intent|doneWhen|tags: source|local}}." }, verbose: { type: "boolean" }, title: { type: "string" }, label: { type: "string" }, intent: { type: "string" }, complexity: { type: "string", enum: TASK_DISPATCH_COMPLEXITIES }, context: { type: "string" }, latestSteer: { type: "string" }, onDeploy: { type: "string" }, doneWhen: { type: "string" }, terminalStage: { enum: [...TASK_TERMINAL_STAGES, null] }, dispatch: DISPATCH_SHAPE_SCHEMA, teamId: { type: "string" }, projectId: { type: "string" }, repo: { type: "string" }, paths: { type: "array", items: { type: "string" } } }, required: ["taskId"], additionalProperties: false } },
   { name: "relay_task_set_status", description: "Transition Task execution status. done requires met validation; force requires explicit override authority.", requiredScopes: ["task:write"], inputSchema: { type: "object", properties: { taskId: TASK_ID_PROP, status: { type: "string", enum: DELIVERABLE_STATUS_ENUM }, force: { type: "boolean" }, blockedBy: { type: "array", items: BLOCKER_SCHEMA }, note: { type: "string" }, verbose: { type: "boolean" } }, required: ["taskId", "status"], additionalProperties: false } },
   { name: "relay_task_set_stage", description: "Set Task delivery stage/branch/commit; normally maintained by the land/deploy pipeline.", requiredScopes: ["task:write"], inputSchema: { type: "object", properties: { taskId: TASK_ID_PROP, deliverableStage: { type: "string", enum: TASK_DELIVERABLE_STAGES }, branch: { type: "string" }, commit: COMMIT_SCHEMA }, required: ["taskId", "deliverableStage"], additionalProperties: false } },
   { name: "relay_task_confirm_carry", description: "Confirm a protected-tip revert's delivered change was carried to current main; clears only carry-pending.", requiredScopes: ["task:write"], inputSchema: { type: "object", properties: { taskId: TASK_ID_PROP, commit: COMMIT_SCHEMA, branch: { type: "string" }, note: { type: "string" } }, required: ["taskId"], additionalProperties: false } },
@@ -175,6 +177,7 @@ export async function relayTaskTool(auth: McpAuthLike, name: string, args: Recor
       complexity: optionalEnum(args.complexity, "complexity", TASK_DISPATCH_COMPLEXITIES),
       context: cleanString(args.context, "context", { max: 1_000_000 }),
       terminalStage: optionalEnum(args.terminalStage, "terminalStage", TASK_TERMINAL_STAGES),
+      onDeploy: cleanString(args.onDeploy, "onDeploy", { max: 500 }),
       doneWhen: cleanString(args.doneWhen, "doneWhen", { max: 1_000_000 }),
       teamId: cleanString(args.teamId, "teamId", { max: 200 }),
       projectId: cleanString(args.projectId, "projectId", { max: 120 }),
@@ -182,6 +185,7 @@ export async function relayTaskTool(auth: McpAuthLike, name: string, args: Recor
       branch: cleanString(args.branch, "branch", { max: 500 }),
       dispatch: args.dispatch as TaskDispatch | undefined,
       tags: args.tags as string[] | undefined,
+      paths: args.paths as string[] | undefined,
       // Alias-tolerant (#2214): a ref passed as `refs`/`issues`/`externalKey`/… used to be dropped
       // silently, leaving the Task's issues[] empty and its spawn brief without the linked spec.
       issueRefs: issueRefsFromArgs(args),
@@ -218,7 +222,7 @@ export async function relayTaskTool(auth: McpAuthLike, name: string, args: Recor
   if (name === "relay_task_list") {
     const tasks = await listTaskEntitySummariesAsync({
       status: optionalEnum(args.status, "status", DELIVERABLE_STATUS_ENUM),
-      deliverableStage: optionalEnum(args.deliverableStage, "deliverableStage", TASK_DELIVERABLE_STAGES),
+      deliverableStage: optionalEnum(args.deliverableStage, "deliverableStage", [...TASK_DELIVERABLE_STAGES, "awaiting-deploy"] as const),
       teamId: cleanString(args.teamId, "teamId", { max: 200 }),
       projectId: cleanString(args.projectId, "projectId", { max: 120 }),
       repo: cleanString(args.repo, "repo", { max: 500 }),
@@ -246,12 +250,14 @@ export async function relayTaskTool(auth: McpAuthLike, name: string, args: Recor
       ...(args.complexity !== undefined ? { complexity: optionalEnum(args.complexity, "complexity", TASK_DISPATCH_COMPLEXITIES) } : {}),
       ...(args.context !== undefined ? { context: cleanString(args.context, "context", { max: 1_000_000 }) ?? "" } : {}),
       ...(args.latestSteer !== undefined ? { latestSteer: cleanString(args.latestSteer, "latestSteer", { max: 1_000_000 }) ?? "" } : {}),
+      ...(args.onDeploy !== undefined ? { onDeploy: cleanString(args.onDeploy, "onDeploy", { max: 500 }) ?? "" } : {}),
       ...(args.doneWhen !== undefined ? { doneWhen: cleanString(args.doneWhen, "doneWhen", { max: 1_000_000 }) ?? "" } : {}),
       ...(args.terminalStage !== undefined ? { terminalStage: args.terminalStage === null ? null : optionalEnum(args.terminalStage, "terminalStage", TASK_TERMINAL_STAGES) } : {}),
       ...(args.dispatch !== undefined ? { dispatch: args.dispatch as TaskDispatch } : {}),
       ...(args.teamId !== undefined ? { teamId: cleanString(args.teamId, "teamId", { max: 200 }) ?? "" } : {}),
       ...(args.projectId !== undefined ? { projectId: cleanString(args.projectId, "projectId", { max: 120 }) ?? "" } : {}),
       ...(args.repo !== undefined ? { repo: cleanString(args.repo, "repo", { max: 500 }) ?? "" } : {}),
+      ...(args.paths !== undefined ? { paths: args.paths as string[] | null } : {}),
     };
     const task = await updateTaskEntityAsync(taskIdArg(args.taskId), { ...patch, actor });
     if (args.verbose === true) return task as unknown as Record<string, unknown>;

package/src/mcp-team-template-tools.ts

@@ -2,7 +2,7 @@ import { INCLUDED_TOOL_SCOPE_NEEDS } from "./mcp/tool-groups";
 import { APPROVAL_MODES, SPAWN_PROVIDERS, VALID_AGENT_LIFECYCLES, VALID_WORKSPACE_MODES } from "@humwick/sdk";
 import { McpAuthError } from "./mcp-errors";
 import { authContextFromMcp } from "./services/auth-context";
-import { deleteTeamTemplate, getTeamTemplate, instantiateTeamTemplate, listTeamTemplates, saveTeamTemplate } from "./services/team-templates";
+import { deleteTeamTemplateAsync, getTeamTemplate, instantiateTeamTemplate, listTeamTemplates, saveTeamTemplateAsync } from "./services/team-templates";
 import { summarizeSpawnCommandForCaller } from "./services/spawn-agent";
 import { ValidationError } from "./db";
 
@@ -111,7 +111,7 @@ function slugArg(args: Record<string, unknown>): string {
 export async function relayTeamTemplateTool(auth: McpAuthLike, name: string, args: Record<string, unknown>): Promise<Record<string, unknown>> {
   if (name === "relay_team_template_save") {
     requireScope(auth, "teams:write");
-    return saveTeamTemplate(args, auth.actor) as unknown as Record<string, unknown>;
+    return await saveTeamTemplateAsync(args, auth.actor) as unknown as Record<string, unknown>;
   }
   if (name === "relay_team_template_list") return { templates: listTeamTemplates() };
   if (name === "relay_team_template_get") {
@@ -121,7 +121,7 @@ export async function relayTeamTemplateTool(auth: McpAuthLike, name: string, arg
   }
   if (name === "relay_team_template_delete") {
     requireScope(auth, "teams:write");
-    return { slug: slugArg(args), deleted: deleteTeamTemplate(slugArg(args), auth.actor) };
+    return { slug: slugArg(args), deleted: await deleteTeamTemplateAsync(slugArg(args), auth.actor) };
   }
   if (name === "relay_team_spawn_from_template") {
     requireScope(auth, "teams:write");

package/src/mcp-team-tools.ts

@@ -164,23 +164,23 @@ export async function relayTeamTool(auth: McpAuthLike, name: string, args: Recor
       return { ...projectTeamPayload(payload, args), ...(payload.team.spawnDelegation || payload.team.parentTeamId ? { spawnDelegationState: await getTeamSpawnDelegation(ctx, payload.team.parentTeamId ?? payload.team.id) } : {}) };
     }
     if (name === "relay_team_set_brief") {
-      const payload = setCallerTeamBrief(ctx, {
+      const payload = (await setCallerTeamBrief(ctx, {
         title: cleanString(args.title, "title", { max: 240 }),
         brief: cleanString(args.brief, "brief", { max: 16_000 }),
         definitionOfDone: cleanString(args.definitionOfDone, "definitionOfDone", { max: 4000 }),
-      });
+      }));
       return projectTeamPayload(payload, args);
     }
     if (name === "relay_team_claim") {
-      const payload = claimTeamForCaller(
+      const payload = (await claimTeamForCaller(
         ctx,
         cleanString(args.teamId, "teamId", { required: true, max: 240 })!,
         cleanString(args.reason, "reason", { max: 2000 }),
-      );
+      ));
       return projectTeamPayload(payload, args);
     }
     if (name === "relay_team_dissolve") {
-      return dissolveCallerTeam(ctx, {
+      return (await dissolveCallerTeam(ctx, {
         outcomeStatus: optionalEnum(args.outcomeStatus, "outcomeStatus", OUTCOME_STATUSES) as Team["outcomeStatus"] | undefined,
         outcomeSummary: cleanString(args.outcomeSummary, "outcomeSummary", { max: 4000 }),
         landsClean: args.landsClean === undefined || args.landsClean === null
@@ -188,7 +188,7 @@ export async function relayTeamTool(auth: McpAuthLike, name: string, args: Recor
           : typeof args.landsClean === "boolean"
             ? args.landsClean
             : (() => { throw new ValidationError("landsClean must be a boolean"); })(),
-      }) as unknown as Record<string, unknown>;
+      })) as unknown as Record<string, unknown>;
     }
   } catch (error) {
     mapTeamError(error);

package/src/mcp-workflow-tools.ts

@@ -5,7 +5,7 @@ import { McpAuthError } from "./mcp-errors";
 import { ValidationError } from "./db";
 import { authContextFromMcp } from "./services/auth-context";
 import { ServiceAuthError } from "./services/errors";
-import { cancelWorkflowRun, getWorkflowRun, resumeWorkflowRun, startWorkflowRun } from "./services/workflow-runs";
+import { cancelWorkflowRun, getWorkflowRun, pauseWorkflowRun, resumeWorkflowRun, startWorkflowRun } from "./services/workflow-runs";
 import { parseWorkflowPins } from "./services/workflow-pins";
 import { cleanString, taskIdField } from "./validation";
 
@@ -35,6 +35,7 @@ export const WORKFLOW_TOOLS = [
       properties: {
         workflow: { type: "string" },
         taskId: TASK_ID_PROP,
+        cwd: { type: "string", description: "Project checkout; defaults to the caller or Task repo." },
         pins: PINS_PROP,
         budget: { type: "object",  properties: { tokenCap: { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER } }, required: ["tokenCap"], additionalProperties: false },
         inputs: { type: "object" },
@@ -48,7 +49,7 @@ export const WORKFLOW_TOOLS = [
   {
     name: "relay_workflow_resume",
     description:
-      "Resume or answer/escalate a decision.",
+      "Resume, pause/unpause, re-pin, or answer decisions.",
     requiredScopes: ["task:write"],
     inputSchema: {
       type: "object",
@@ -66,6 +67,7 @@ export const WORKFLOW_TOOLS = [
         activationId: { type: "string" },
         step: { type: "string" },
         note: { type: "string" },
+        pause: { type: "boolean" },
         pins: PINS_PROP,
       },
       required: ["runId"],
@@ -112,7 +114,7 @@ type McpAuthLike = Parameters<typeof authContextFromMcp>[0];
 
 function mutationReceipt(full: Record<string, unknown>, verbose: unknown): Record<string, unknown> {
   if (verbose === true) return full;
-  const fields = ["runId", "taskId", "workflow", "status", "step", "round", "callerAgentId", "budget", "existing", "resumed", "cancelled", "reason", "warnings"];
+  const fields = ["runId", "taskId", "workflow", "status", "step", "round", "callerAgentId", "budget", "existing", "resumed", "pinsUpdated", "cancelled", "paused", "reason", "warnings"];
   return Object.fromEntries(fields.filter(key => full[key] !== undefined).map(key => [key, full[key]]));
 }
 
@@ -124,14 +126,21 @@ export async function relayWorkflowTool(auth: McpAuthLike, name: string, args: R
     if (name === "relay_workflow_start") {
       const workflow = cleanString(args.workflow, "workflow", { max: 64 });
       if (!workflow) throw new ValidationError("workflow is required");
+      const cwd = cleanString(args.cwd, "cwd", { max: 4000 });
       const pins = parseWorkflowPins(args.pins);
-      return mutationReceipt(await startWorkflowRun({ workflow, ...(args.inputs !== undefined ? { inputs: args.inputs as Record<string, unknown> } : {}), ...(args.requestKey ? { requestKey: String(args.requestKey) } : {}), taskId: taskIdField(args.taskId), ...(pins ? { pins } : {}), budget: args.budget }, ctx), args.verbose);
+      return mutationReceipt(await startWorkflowRun({ workflow, ...(cwd ? { cwd } : {}), ...(args.inputs !== undefined ? { inputs: args.inputs as Record<string, unknown> } : {}), ...(args.requestKey ? { requestKey: String(args.requestKey) } : {}), taskId: taskIdField(args.taskId), ...(pins ? { pins } : {}), budget: args.budget }, ctx), args.verbose);
     }
     if (name === "relay_workflow_resume") {
       const runId = cleanString(args.runId, "runId", { max: 200 });
       if (!runId) throw new ValidationError("runId is required");
       const step = cleanString(args.step, "step", { max: 64 });
       const note = cleanString(args.note, "note", { max: 8000 });
+      if (args.pause !== undefined) {
+        // #3757 — pause (note is the required reason) or unpause; nothing else rides along.
+        if (typeof args.pause !== "boolean") throw new ValidationError("pause must be a boolean");
+        if (step || args.pins !== undefined || args.decision !== undefined || args.activationId !== undefined) throw new ValidationError("pause takes only runId and, to pause, note as the reason");
+        return mutationReceipt(await pauseWorkflowRun({ runId, pause: args.pause, ...(note ? { reason: note } : {}) }, ctx), args.verbose);
+      }
       const pins = parseWorkflowPins(args.pins);
       return mutationReceipt(await resumeWorkflowRun({ runId, decision: parseWorkflowDecisionResponse(args.decision), activationId: cleanString(args.activationId, "activationId", { max: 2000 }), ...(step ? { step } : {}), ...(note ? { note } : {}), ...(pins ? { pins } : {}) }, ctx), args.verbose);
     }