@humwick/server 0.130.2 → 0.130.4

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

@@ -42,6 +42,6 @@ export async function relayProfileTrust(auth: McpAuthContext, args: Record<strin
   const capability = optionalEnum(args.capability, "capability", PROJECT_TRUST_CAPABILITIES);
   if (!capability) throw new ValidationError("capability is required");
   if (args.action === "ack") return { ack: (await updateProfileProjectTrustAsync(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 === "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-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-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

@@ -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, pause/unpause, or answer/escalate a decision.",
+      "Resume, pause/unpause, re-pin, or answer decisions.",
     requiredScopes: ["task:write"],
     inputSchema: {
       type: "object",
@@ -113,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", "paused", "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]]));
 }
 
@@ -125,8 +126,9 @@ 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 });

package/src/memory-area-injection.ts

@@ -1,3 +1,4 @@
+import { createCommandAsync } from "./commands-write";
 // #3410 — on-touch area memory. The runner reports the first file an agent touches in a path area
 // (`.agent-relay/areas.json`) in a context generation. This selects that area's memories of the
 // agent's own project that the startup block holds out (#3409, #3508), renders them, and
@@ -6,10 +7,10 @@
 
 import { injectsAtStartup, cleanAreasConfig, type AreaDefinition } from "@humwick/sdk/areas";
 import { isRecord, stringValue, type AreaEnteredInput, type AreaEnteredResult } from "@humwick/sdk";
-import { createCommand } from "./commands-db";
+
 import { emitCommandEvent } from "./command-events";
 import { contextInjectUnsupported } from "./context-injection-channel";
-import { listActiveEntriesInArea, ValidationError } from "./db";
+import { listActiveEntriesInAreaAsync, ValidationError } from "./db";
 import { entryInjectability } from "./memory-inject-filter";
 import { memoryHeadline, neutralizeMemoryMarkers } from "./memory-preamble";
 import { memorySeamForAgent, projectMemoryEnabledForSeam } from "./memory-seam";
@@ -45,8 +46,8 @@ export function parseAreaEnteredInput(body: unknown): AreaEnteredInput {
 
 /** The agent's own project's active entries for `area` that its startup block does not carry
  *  (#3508), and it may receive: pinned first, then newest. Ancestor projects are not walked. */
-export function selectAreaEntries(projectId: string, area: string, profile: string | undefined, exclude: ReadonlySet<string>, now: number): ProjectEntry[] {
-  const selected = listActiveEntriesInArea(projectId, area).filter((entry) =>
+export async function selectAreaEntries(projectId: string, area: string, profile: string | undefined, exclude: ReadonlySet<string>, now: number): Promise<ProjectEntry[]> {
+  const selected = (await listActiveEntriesInAreaAsync(projectId, area)).filter((entry) =>
     entry.areas?.includes(area)
     && !injectsAtStartup(entry)
     && !exclude.has(entry.id)
@@ -123,7 +124,7 @@ async function selectForAgent(agent: AgentCard, input: AreaEnteredInput, now: nu
   const projectId = seam.identity.projectId;
   if (!projectId) return { definition, entries: [], skipped: "no-project" };
   if (!projectMemoryEnabledForSeam(seam)) return { definition, entries: [], skipped: "project-memory-off" };
-  return { definition, entries: selectAreaEntries(projectId, input.area, seam.identity.profile, new Set(input.exclude), now) };
+  return { definition, entries: await selectAreaEntries(projectId, input.area, seam.identity.profile, new Set(input.exclude), now) };
 }
 
 function areaSummary(area: string, entries: number, tokens: number): string {
@@ -143,7 +144,7 @@ export async function enqueueAreaMemoryInjection(agent: AgentCard, input: AreaEn
   const tokens = selected ? block.tokens : 0;
   const omitted = selected ? block.omitted : 0;
   if (queued) {
-    const command = createCommand({
+    const command = (await createCommandAsync({
       type: "agent.injectContext",
       source: "system",
       target: agent.id,
@@ -158,10 +159,10 @@ export async function enqueueAreaMemoryInjection(agent: AgentCard, input: AreaEn
         tokens,
         omitted,
       },
-    });
+    }));
     emitCommandEvent(command, "command.requested");
   }
-  emitRelayInjectionEvent({
+  (await emitRelayInjectionEvent({
     agentId: agent.id,
     category: AREA_MEMORY_REASON,
     summary: areaSummary(input.area, entryIds.length, tokens),
@@ -178,12 +179,12 @@ export async function enqueueAreaMemoryInjection(agent: AgentCard, input: AreaEn
       ...(skipped ? { skipped } : {}),
     },
     timestamp: now,
-  });
+  }));
   return { area: input.area, queued, entryIds, tokens, omitted, ...(input.inline ? { content: selected ? block.content : "" } : {}) };
 }
 
 /** A `memory-area` inject the runner reported delivered: one more event, `delivered: true`. A stale-generation skip is not one. */
-export function settleAreaMemoryCommand(command: Command, now: number = Date.now()): void {
+export async function settleAreaMemoryCommand(command: Command, now: number = Date.now()): Promise<void> {
   if (command.type !== "agent.injectContext" || command.status !== "succeeded" || command.params.reason !== AREA_MEMORY_REASON) return;
   // #3411 — the runner drops an inject queued before a context reset and reports it in providerResult.
   const providerResult = command.result?.providerResult;
@@ -194,7 +195,7 @@ export function settleAreaMemoryCommand(command: Command, now: number = Date.now
   const generation = typeof params.generation === "number" ? params.generation : 0;
   const entryIds = Array.isArray(params.memoryIds) ? params.memoryIds.filter((id): id is string => typeof id === "string") : [];
   const tokens = typeof params.tokens === "number" ? params.tokens : 0;
-  emitRelayInjectionEvent({
+  (await emitRelayInjectionEvent({
     agentId: command.target,
     category: AREA_MEMORY_REASON,
     summary: `${areaSummary(area, entryIds.length, tokens)} delivered`,
@@ -212,5 +213,5 @@ export function settleAreaMemoryCommand(command: Command, now: number = Date.now
     },
     timestamp: now,
     idempotencyKey: `memory-area:${command.id}:settled`,
-  });
+  }));
 }

package/src/memory-boundary-capture.ts

@@ -138,12 +138,12 @@ export function isBoundaryCaptureDefect(clause: BoundaryCaptureClause): boolean
  * abort the boundary AFTER the continuation envelope has already been advanced. Both are strictly
  * worse outcomes than a missing sentence, so every path here ends in a string.
  */
-export function boundaryCaptureClause(input: {
+export async function boundaryCaptureClause(input: {
   seam: BoundaryCaptureSeam;
   agentId: string;
   slug?: string;
   now?: number;
-}): string {
+}): Promise<string> {
   let clause: BoundaryCaptureClause;
   try {
     clause = resolveBoundaryCaptureClause(input.seam, input.slug);
@@ -157,7 +157,7 @@ export function boundaryCaptureClause(input: {
       error: errMessage(error),
     };
   }
-  if (isBoundaryCaptureDefect(clause)) reportBoundaryCaptureDefect(clause, input.agentId, input.now ?? Date.now());
+  if (isBoundaryCaptureDefect(clause)) (await reportBoundaryCaptureDefect(clause, input.agentId, input.now ?? Date.now()));
   return clause.text;
 }
 
@@ -180,9 +180,9 @@ function describeBoundaryCaptureDefect(clause: BoundaryCaptureClause): string {
  * timeline write itself fails there is nowhere left to say so — the boundary still proceeds, which
  * is the outcome that matters.
  */
-function reportBoundaryCaptureDefect(clause: BoundaryCaptureClause, agentId: string, now: number): void {
+async function reportBoundaryCaptureDefect(clause: BoundaryCaptureClause, agentId: string, now: number): Promise<void> {
   try {
-    emitRelayInjectionEvent({
+    (await emitRelayInjectionEvent({
       agentId,
       category: "memory",
       summary: describeBoundaryCaptureDefect(clause),
@@ -198,7 +198,7 @@ function reportBoundaryCaptureDefect(clause: BoundaryCaptureClause, agentId: str
       },
       timestamp: now,
       idempotencyKey: `memory-capture-clause:${clause.seam}:${agentId}:${clause.status}`,
-    });
+    }));
   } catch {
     // Intentionally swallowed: see the doc comment above. A boundary must not fail because its
     // capture ask could not be announced.