@desplega.ai/agent-swarm 1.131.1 → 1.134.0

package/src/tools/update-profile.ts

@@ -3,7 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { getAgentById, updateAgentName, updateAgentProfile } from "@/be/db";
+import { getAgentById, updateAgentProfile } from "@/be/db";
 import { can } from "@/rbac";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 import { type Agent, AgentAvatarSchema, AgentStatusSchema, ProviderNameSchema } from "@/types";
@@ -110,7 +110,7 @@ export const registerUpdateProfileTool = (server: McpServer) => {
           .max(MAX_PROFILE_FILE_LENGTH)
           .optional()
           .describe(
-            "Personal CLAUDE.md content. Loaded on session start and synced back on session end. Use for persistent notes and instructions.",
+            "Personal CLAUDE.md content. Loaded on session start and synced back on session end. Above 20,000 characters, updates may only keep or reduce the stored size; move durable overflow into memory.",
           ),
         soulMd: z
           .string()
@@ -118,7 +118,7 @@ export const registerUpdateProfileTool = (server: McpServer) => {
           .max(MAX_PROFILE_FILE_LENGTH)
           .optional()
           .describe(
-            "Soul content: persona and behavioral directives. Updates both DB and /workspace/SOUL.md. Must be at least 200 characters to prevent accidental corruption.",
+            "Soul content: persona and behavioral directives. Updates both DB and /workspace/SOUL.md. Must be at least 200 characters; above 10,000 characters, updates may only keep or reduce the stored size.",
           ),
         identityMd: z
           .string()
@@ -126,7 +126,7 @@ export const registerUpdateProfileTool = (server: McpServer) => {
           .max(MAX_PROFILE_FILE_LENGTH)
           .optional()
           .describe(
-            "Identity content: expertise and working style. Updates both DB and /workspace/IDENTITY.md. Must be at least 200 characters to prevent accidental corruption.",
+            "Identity content: expertise and working style. Updates both DB and /workspace/IDENTITY.md. Must be at least 200 characters; above 10,000 characters, updates may only keep or reduce the stored size.",
           ),
         setupScript: z
           .string()
@@ -140,7 +140,7 @@ export const registerUpdateProfileTool = (server: McpServer) => {
           .max(MAX_PROFILE_FILE_LENGTH)
           .optional()
           .describe(
-            "Environment-specific operational knowledge. Repos, services, SSH hosts, APIs, device names — anything specific to your setup. Synced to /workspace/TOOLS.md.",
+            "Environment-specific operational knowledge. Synced to /workspace/TOOLS.md. Above 20,000 characters, updates may only keep or reduce the stored size; move durable overflow into memory.",
           ),
         heartbeatMd: z
           .string()
@@ -250,21 +250,14 @@ export const registerUpdateProfileTool = (server: McpServer) => {
           }
         }
 
-        // Update name if provided
-        if (name !== undefined) {
-          agent = updateAgentName(targetAgentId, name);
-          if (!agent) {
-            return toolErr("Target agent not found.", {
-              data: { yourAgentId: requestInfo.agentId },
-            });
-          }
-        }
-
-        // Update profile fields if provided. `avatar` is spread in only when
-        // present so `null` (reset) stays distinguishable from "not provided".
+        // Apply name and profile fields in one DB transaction so validation or
+        // update failures cannot leave a partially-applied combined payload.
+        // `avatar` is spread in only when present so `null` (reset) stays
+        // distinguishable from "not provided".
         agent = updateAgentProfile(
           targetAgentId,
           {
+            name,
             description,
             role,
             capabilities,
@@ -282,6 +275,12 @@ export const registerUpdateProfileTool = (server: McpServer) => {
           },
         );
 
+        // Do not perform audit or workspace-file side effects when the target
+        // disappeared before the transactional update could find it.
+        if (!agent) {
+          return toolErr("Agent not found.", { data: { yourAgentId: requestInfo.agentId } });
+        }
+
         if (setupScript !== undefined && previousSetupScript !== undefined) {
           try {
             const diff = await computeSetupScriptDiff(previousSetupScript, setupScript);
@@ -348,10 +347,6 @@ export const registerUpdateProfileTool = (server: McpServer) => {
           }
         }
 
-        if (!agent) {
-          return toolErr("Agent not found.", { data: { yourAgentId: requestInfo.agentId } });
-        }
-
         const updatedFields: string[] = [];
         if (name !== undefined) updatedFields.push("name");
         if (description !== undefined) updatedFields.push("description");

package/src/tools/utils.ts

@@ -32,6 +32,8 @@ export function markScriptSdkRequestOrigin<T extends object>(meta: T): T {
 export type RequestInfo = {
   sessionId: string | undefined;
   agentId: string | undefined;
+  /** Calling worker process, when multi-runtime mode is on. */
+  runtimeInstanceId: string | undefined;
   sourceTaskId: string | undefined;
   contextKey: string | undefined;
   callOrigin: "mcp" | "script-sdk";
@@ -41,6 +43,8 @@ export const getRequestInfo = (req: Meta): RequestInfo => {
   const agentIdHeader = req.requestInfo?.headers?.["x-agent-id"];
   const sourceTaskIdHeader = req.requestInfo?.headers?.["x-source-task-id"];
   const contextKeyHeader = req.requestInfo?.headers?.["x-context-key"];
+  const runtimeHeader = req.requestInfo?.headers?.["x-runtime-instance-id"];
+  const runtimeInstanceId = Array.isArray(runtimeHeader) ? runtimeHeader[0] : runtimeHeader;
 
   let agentId: string | undefined;
   if (Array.isArray(agentIdHeader)) {
@@ -66,6 +70,7 @@ export const getRequestInfo = (req: Meta): RequestInfo => {
   return {
     sessionId: req.sessionId || undefined,
     agentId,
+    runtimeInstanceId: typeof runtimeInstanceId === "string" ? runtimeInstanceId : undefined,
     sourceTaskId,
     contextKey,
     callOrigin: scriptSdkRequestOrigins.has(req) ? "script-sdk" : "mcp",

package/src/tools/workflows/trigger-workflow.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
+import { resolveTaskAuditUserId } from "@/be/audit-user";
 import { getWorkflow, getWorkflowRun } from "@/be/db";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 import { getExecutorRegistry, startWorkflowExecution } from "@/workflows";
@@ -28,7 +29,7 @@ export const registerTriggerWorkflowTool = (server: McpServer) => {
         triggerSchema: z.record(z.string(), z.unknown()).optional(),
       }),
     },
-    async ({ id, triggerData }) => {
+    async ({ id, triggerData }, requestInfo) => {
       try {
         const workflow = getWorkflow(id);
         if (!workflow) {
@@ -41,6 +42,11 @@ export const registerTriggerWorkflowTool = (server: McpServer) => {
           workflow,
           triggerData ?? {},
           getExecutorRegistry(),
+          {
+            triggerType: "manual",
+            requestedByUserId:
+              resolveTaskAuditUserId(requestInfo.sourceTaskId, requestInfo.agentId) ?? undefined,
+          },
         );
 
         // Check if the run was skipped due to cooldown

package/src/types.ts

@@ -633,6 +633,102 @@ export const AgentTaskSchema = z
   })
   .openapi("AgentTask");
 
+// ─── Create-task input contract ──────────────────────────────────────────────
+//
+// Runtime schema for `createTaskExtended` options (src/be/db.ts). Every task
+// write — REST POST /api/tasks, MCP send-task, the scripts bridge, webhooks,
+// the scheduler, and internal callers — funnels through that function, so
+// this schema is the single enforcement point for task-input shapes. It
+// rejects, never coerces: a type mismatch or out-of-range value throws, and
+// only an ABSENT field falls back to the `??` defaults at the INSERT bind
+// site. Deliberately NOT an `.openapi()` component: it is an internal write
+// contract, not a response shape.
+export const CreateTaskOptionsSchema = z.object({
+  key: z.string().min(1).optional(),
+  agentId: z.string().nullable().optional(),
+  creatorAgentId: z.string().optional(),
+  source: AgentTaskSourceSchema.optional(),
+  taskType: z.string().max(50).optional(),
+  tags: z.array(z.string()).optional(),
+  priority: z.number().int().min(0).max(100).optional(),
+  dependsOn: z.array(z.string()).optional(),
+  offeredTo: z.string().optional(),
+  /** Explicitly set initial status. */
+  status: z.enum(["backlog", "unassigned"]).optional(),
+  slackChannelId: z.string().optional(),
+  slackThreadTs: z.string().optional(),
+  /** Exact Slack message that directly triggered this task; never inherited. */
+  slackTriggerMessageTs: z.string().optional(),
+  slackUserId: z.string().optional(),
+  /**
+   * Opt out of the residual Slack/contextKey normalization (see the
+   * "Residual-mismatch guard" comment near the INSERT in src/be/db.ts): a
+   * deliberate cross-channel/thread dispatch (e.g. `send-task`'s
+   * `overrideSlackContext: true`) sets this so its explicit slackChannelId/
+   * slackThreadTs survive even when they disagree with a slack-family
+   * `contextKey`/parent. Trusted callers that don't set this get normalized —
+   * this boundary must not let a caller silently persist a mismatch.
+   */
+  overrideSlackContext: z.boolean().optional(),
+  vcsProvider: z.enum(["github", "gitlab"]).optional(),
+  vcsRepo: z.string().optional(),
+  vcsEventType: z.string().optional(),
+  vcsNumber: z.number().int().optional(),
+  vcsCommentId: z.number().int().optional(),
+  vcsAuthor: z.string().optional(),
+  vcsUrl: z.string().optional(),
+  vcsInstallationId: z.number().int().optional(),
+  vcsNodeId: z.string().optional(),
+  agentmailInboxId: z.string().optional(),
+  agentmailMessageId: z.string().optional(),
+  agentmailThreadId: z.string().optional(),
+  mentionMessageId: z.string().optional(),
+  mentionChannelId: z.string().optional(),
+  dir: z.string().optional(),
+  parentTaskId: z.string().optional(),
+  model: z.string().optional(),
+  modelTier: ModelTierSchema.optional(),
+  effort: ReasoningEffortSchema.optional(),
+  scheduleId: z.string().optional(),
+  workflowRunId: z.string().optional(),
+  workflowRunStepId: z.string().optional(),
+  sourceTaskId: z.string().optional(),
+  /**
+   * Optional JSON Schema the agent's final output must conform to.
+   *
+   * Enforced via the MCP `store-progress` tool (validated in
+   * `src/tools/store-progress.ts`). NOT enforced when the task runs on
+   * default-mode Devin (no MCP) — see runbooks/harness-providers.md
+   * ("Per-task outputSchema support"). Callers reading `task.output` for
+   * a schema'd task should be defensive about JSON parsing.
+   */
+  outputSchema: z.record(z.string(), z.unknown()).optional(),
+  /**
+   * When a `parentTaskId` is set, the child inherits the parent's `outputSchema`
+   * by default. Set this to `false` to opt out — used by control-plane children
+   * (e.g. the Lead `reroute-decision` task) that must inherit Slack/VCS context
+   * from the parent but must NOT be forced to satisfy the original work's output
+   * contract on completion (which would block the control task — DES-523).
+   */
+  inheritParentOutputSchema: z.boolean().optional(),
+  followUpConfig: FollowUpConfigSchema.optional(),
+  requestedByUserId: z.string().optional(),
+  contextKey: z.string().optional(),
+  /**
+   * Internal control-plane escape hatch for continuations that MUST coexist
+   * with their active Linear parent (for example promoted steering). General
+   * task creation keeps tracker-context dedup enabled.
+   */
+  bypassTrackerContextDedup: z.boolean().optional(),
+  /**
+   * Routing-affinity snapshot gating pool eligibility (see
+   * `isAgentEligibleForTask`). Inherited from the parent (via `parentTaskId`)
+   * when not explicitly set — same treatment as `vcsRepo`/`contextKey`.
+   */
+  routingAffinity: RoutingAffinitySchema.optional(),
+});
+export type CreateTaskOptions = z.infer<typeof CreateTaskOptionsSchema>;
+
 // ============================================================================
 // Task Attachments (Phase 1 — pointer-based artifacts)
 // ============================================================================
@@ -645,11 +741,19 @@ export const AgentTaskSchema = z
 export const TaskAttachmentKindSchema = z.enum(["agent-fs", "url", "shared-fs", "page"]);
 export type TaskAttachmentKind = z.infer<typeof TaskAttachmentKindSchema>;
 
+export const SERVER_GENERATED_ATTACHMENT_CAPABILITY = "_agentSwarmGeneratedBy";
+
+const attachmentCapabilitiesSchema = z
+  .record(z.string(), z.unknown())
+  .refine((capabilities) => !(SERVER_GENERATED_ATTACHMENT_CAPABILITY in capabilities), {
+    message: `${SERVER_GENERATED_ATTACHMENT_CAPABILITY} is reserved for server-generated attachments`,
+  });
+
 const attachmentCommonFields = {
   name: z.string().min(1).describe("Display name for the attachment."),
   providerId: z.string().min(1).optional(),
   providerKey: z.string().min(1).optional(),
-  capabilities: z.record(z.string(), z.unknown()).optional(),
+  capabilities: attachmentCapabilitiesSchema.optional(),
   mimeType: z.string().optional(),
   sizeBytes: z.number().int().min(0).optional(),
   sha256: z.string().optional(),
@@ -755,6 +859,22 @@ export const UserSchema = z
 
 export type User = z.infer<typeof UserSchema>;
 
+/**
+ * Structured communication preferences read from `users.metadata.comms`.
+ * All fields are free-form strings; values render verbatim into the requester
+ * profile prompt. Written merge-safely via the `comms` field on
+ * PATCH /api/users/{id} and the manage-user tool.
+ */
+export const UserCommsPrefsSchema = z
+  .object({
+    tone: z.string().optional(),
+    language: z.string().optional(),
+    verbosity: z.string().optional(),
+  })
+  .openapi("UserCommsPrefs");
+
+export type UserCommsPrefs = z.infer<typeof UserCommsPrefsSchema>;
+
 /**
  * Identity event types — mirrored in lockstep with the CHECK constraint on
  * `user_identity_events.eventType` in migration 064. Drift breaks helper
@@ -1338,6 +1458,8 @@ export const EventNameSchema = z.enum([
   "system.boot",
   "system.migration",
   "system.error",
+  "system.profile_sync_rejected",
+  "system.profile_sync_reconciled",
   // Script catalog events
   "script.global_upsert",
   // Schedule events
@@ -1563,6 +1685,8 @@ export const ActiveSessionSchema = z
     taskDescription: z.string().nullable(),
     runnerSessionId: z.string().nullable(),
     providerSessionId: z.string().nullable(),
+    /** Runtime process that owns this session; null for single-runtime rows. */
+    runtimeInstanceId: z.string().nullable().optional(),
     startedAt: z.iso.datetime(),
     lastHeartbeatAt: z.iso.datetime(),
   })
@@ -1570,6 +1694,45 @@ export const ActiveSessionSchema = z
 
 export type ActiveSession = z.infer<typeof ActiveSessionSchema>;
 
+// ============================================================================
+// Runtime Instance Types (multi-runtime worker tracking)
+// ============================================================================
+
+/**
+ * Lifecycle of a runtime instance. Zod is the source of truth for the allowed
+ * values — the SQL column has no CHECK constraint (migration 132) so adding a
+ * state doesn't require a table rebuild.
+ */
+export const RuntimeInstanceStatusSchema = z.enum(["active", "offline"]);
+
+/**
+ * One worker process serving a logical agent. The `agents` row (AGENT_ID /
+ * X-Agent-ID) keeps durable identity and the logical maxTasks policy; a
+ * runtime instance carries only process-scoped state: liveness and its own
+ * reported execution capacity. A logical agent may be served by 0..N runtime
+ * instances; rows exist only for multi-runtime registrations
+ * (MULTI_RUNTIME_ENABLED).
+ */
+export const RuntimeInstanceSchema = z
+  .object({
+    id: z.string(),
+    agentId: z.string(),
+    status: RuntimeInstanceStatusSchema,
+    /** Runtime-local concurrent task capacity, self-reported at registration. */
+    reportedSlots: z.number().int(),
+    /** Process-local credential readiness; null when never reported. */
+    credentialReady: z.boolean().nullable().optional(),
+    /** Provider-neutral metadata; unused in the initial slice. */
+    metadata: z.record(z.string(), z.unknown()).nullable(),
+    lastSeenAt: z.iso.datetime(),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+  })
+  .openapi("RuntimeInstance");
+
+export type RuntimeInstanceStatus = z.infer<typeof RuntimeInstanceStatusSchema>;
+export type RuntimeInstance = z.infer<typeof RuntimeInstanceSchema>;
+
 // ============================================================================
 // Workflow Engine Types
 // ============================================================================
@@ -2238,6 +2401,7 @@ export const WorkflowRunSchema = z
     triggerData: z.unknown().optional(),
     context: z.record(z.string(), z.unknown()).optional(),
     error: z.string().optional(),
+    createdBy: z.string().optional(),
     startedAt: z.string(),
     lastUpdatedAt: z.string(),
     finishedAt: z.string().optional(),

package/src/utils/github-pull-request.ts

@@ -0,0 +1,76 @@
+export interface GitHubPullRequestUrl {
+  url: string;
+  owner: string;
+  repo: string;
+  number: number;
+}
+
+const CANDIDATE_TOKEN_RE = /[^\s()[\]{}<>"'`]+/g;
+const TRAILING_PROSE_PUNCTUATION_RE = /[)\]},.;:!]+$/;
+const GITHUB_PATH_SEGMENT_RE = /^[\w.-]+$/;
+
+function parseGitHubPullRequestToken(token: string): GitHubPullRequestUrl | null {
+  const candidate = token.replace(TRAILING_PROSE_PUNCTUATION_RE, "");
+  const lowerCandidate = candidate.toLowerCase();
+  if (
+    !lowerCandidate.startsWith("https://github.com/") &&
+    !lowerCandidate.startsWith("http://github.com/") &&
+    !lowerCandidate.startsWith("github.com/")
+  ) {
+    return null;
+  }
+  const withScheme = /^https?:\/\//i.test(candidate) ? candidate : `https://${candidate}`;
+
+  let parsed: URL;
+  try {
+    parsed = new URL(withScheme);
+  } catch {
+    return null;
+  }
+  if (
+    parsed.host.toLowerCase() !== "github.com" ||
+    parsed.username.length > 0 ||
+    parsed.password.length > 0
+  ) {
+    return null;
+  }
+
+  const [owner, repo, pull, numberText] = parsed.pathname.split("/").filter(Boolean);
+  if (
+    !owner ||
+    !repo ||
+    pull?.toLowerCase() !== "pull" ||
+    !numberText ||
+    !GITHUB_PATH_SEGMENT_RE.test(owner) ||
+    !GITHUB_PATH_SEGMENT_RE.test(repo) ||
+    !/^\d+$/.test(numberText)
+  ) {
+    return null;
+  }
+
+  return {
+    url: `https://github.com/${owner}/${repo}/pull/${numberText}`,
+    owner,
+    repo,
+    number: Number(numberText),
+  };
+}
+
+/** Extract distinct canonical GitHub pull-request URLs from free text. */
+export function extractGitHubPullRequestUrls(
+  text: string | null | undefined,
+): GitHubPullRequestUrl[] {
+  if (!text) return [];
+
+  const results: GitHubPullRequestUrl[] = [];
+  const seen = new Set<string>();
+  for (const match of text.matchAll(CANDIDATE_TOKEN_RE)) {
+    const pullRequest = parseGitHubPullRequestToken(match[0]);
+    if (!pullRequest) continue;
+    const dedupeKey = pullRequest.url.toLowerCase();
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    results.push(pullRequest);
+  }
+  return results;
+}

package/src/utils/identity-field-budget.ts

@@ -0,0 +1,73 @@
+import { BOOTSTRAP_MAX_CHARS } from "../prompts/base-prompt";
+
+export const SOUL_MD_MAX_CHARS = 10_000;
+export const IDENTITY_MD_MAX_CHARS = 10_000;
+
+export const IDENTITY_FIELD_BUDGETS = {
+  soulMd: SOUL_MD_MAX_CHARS,
+  identityMd: IDENTITY_MD_MAX_CHARS,
+  claudeMd: BOOTSTRAP_MAX_CHARS,
+  toolsMd: BOOTSTRAP_MAX_CHARS,
+} as const;
+
+export type BudgetedIdentityField = keyof typeof IDENTITY_FIELD_BUDGETS;
+
+export interface IdentityFieldBudgetRejection {
+  field: BudgetedIdentityField;
+  dbSize: number;
+  diskSize: number;
+  budget: number;
+  delta: number;
+  reason: string;
+}
+
+export type IdentityFieldBudgetResult =
+  | { ok: true }
+  | ({ ok: false } & IdentityFieldBudgetRejection);
+
+export function checkIdentityFieldBudget({
+  field,
+  currentValue,
+  nextValue,
+}: {
+  field: BudgetedIdentityField;
+  currentValue: string;
+  nextValue: string;
+}): IdentityFieldBudgetResult {
+  const budget = IDENTITY_FIELD_BUDGETS[field];
+  if (nextValue.length <= budget || nextValue.length <= currentValue.length) {
+    return { ok: true };
+  }
+
+  const delta = nextValue.length - currentValue.length;
+  const remediation =
+    field === "toolsMd"
+      ? ` Content past the ${budget}-character cap is already silently dropped at read time, so shrinking that tail loses nothing sessions currently receive. Move durable content into memories and keep pointers to it in this field.`
+      : field === "claudeMd"
+        ? ` The tail past the ${budget}-character cap is dropped from the base prompt and only reaches harnesses with a native CLAUDE.md loader. Move durable content into memories and keep pointers to it in this field.`
+        : " Move durable content into memories and keep pointers to it in this field.";
+
+  return {
+    ok: false,
+    field,
+    dbSize: currentValue.length,
+    diskSize: nextValue.length,
+    budget,
+    delta,
+    reason:
+      `Update rejected for ${field}: current size ${currentValue.length} characters, ` +
+      `budget ${budget} characters, delta ${delta >= 0 ? "+" : ""}${delta} characters.` +
+      remediation,
+  };
+}
+
+export class IdentityFieldBudgetError extends Error {
+  constructor(
+    readonly rejection: IdentityFieldBudgetRejection,
+    readonly dbHash: string,
+    readonly diskHash: string,
+  ) {
+    super(rejection.reason);
+    this.name = "IdentityFieldBudgetError";
+  }
+}

package/src/utils/multi-runtime.ts

@@ -0,0 +1,20 @@
+import { parseEnvFlag } from "./env-flag";
+
+/**
+ * Opt-in, default off: allows one logical agent to be served by several
+ * worker processes. Lives outside `src/be` so worker-side code can import it
+ * without crossing the DB boundary.
+ */
+export function isMultiRuntimeEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  return parseEnvFlag(env.MULTI_RUNTIME_ENABLED, false);
+}
+
+/**
+ * Per-boot runtime identity the runner stamps into the process environment
+ * before any provider session exists. Adapters read it here to send the
+ * X-Runtime-Instance-ID header on the swarm MCP session — runtime identity is
+ * process/auth context, never a tool argument.
+ */
+export function swarmRuntimeInstanceId(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  return env.SWARM_RUNTIME_INSTANCE_ID || undefined;
+}

package/src/utils/requester-comms.ts

@@ -0,0 +1,24 @@
+import type { User, UserCommsPrefs } from "../types";
+
+function pickString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+/**
+ * Extract structured communication preferences from `users.metadata.comms`.
+ * `metadata` is a free-form JSON blob with no write-side validation, so only
+ * non-empty string fields survive; returns undefined when nothing usable is set.
+ */
+export function getUserCommsPrefs(
+  user: Pick<User, "metadata"> | null | undefined,
+): UserCommsPrefs | undefined {
+  const comms = user?.metadata?.comms;
+  if (!comms || typeof comms !== "object" || Array.isArray(comms)) return undefined;
+  const record = comms as Record<string, unknown>;
+  const prefs: UserCommsPrefs = {
+    tone: pickString(record.tone),
+    language: pickString(record.language),
+    verbosity: pickString(record.verbosity),
+  };
+  return prefs.tone || prefs.language || prefs.verbosity ? prefs : undefined;
+}

package/src/workflows/engine.ts

@@ -76,7 +76,13 @@ export async function startWorkflowExecution(
   // Cooldown check
   if (workflow.cooldown && shouldSkipCooldown(workflow.id, workflow.cooldown)) {
     const runId = crypto.randomUUID();
-    createWorkflowRun({ id: runId, workflowId: workflow.id, triggerData });
+    createWorkflowRun({
+      id: runId,
+      workflowId: workflow.id,
+      triggerType: options.triggerType ?? "manual",
+      triggerData,
+      createdBy: options.requestedByUserId,
+    });
     updateWorkflowRun(runId, {
       status: "skipped",
       error: "cooldown",
@@ -86,7 +92,13 @@ export async function startWorkflowExecution(
   }
 
   const runId = crypto.randomUUID();
-  createWorkflowRun({ id: runId, workflowId: workflow.id, triggerData });
+  createWorkflowRun({
+    id: runId,
+    workflowId: workflow.id,
+    triggerType: options.triggerType ?? "manual",
+    triggerData,
+    createdBy: options.requestedByUserId,
+  });
   telemetry.workflow("started", {
     workflowId: workflow.id,
     nodeCount: workflow.definition.nodes.length,
@@ -160,6 +172,14 @@ export async function walkGraph(
   secretKeys: Set<string> = new Set(),
   options: WorkflowExecutionOptions = {},
 ): Promise<void> {
+  // Initial triggers carry the requester in options. Resumes, retries, and
+  // recovery start from persisted state, so rehydrate it from the run.
+  if (!options.requestedByUserId) {
+    options = {
+      ...options,
+      requestedByUserId: getWorkflowRun(runId)?.createdBy,
+    };
+  }
   let nodeExecutionCount = 0;
   // `run.id` is a context builtin (like `trigger` / `input`) so nodes can reference
   // their own run — e.g. an audit/receipt node correlating its output with the run