@desplega.ai/agent-swarm 1.131.1 → 1.133.1

package/src/prompts/session-templates.ts

@@ -63,7 +63,7 @@ As the lead agent, you coordinate all worker agents in the swarm.
 
 **Identity:**
 - \`update-profile\`: Update your own or other agents' profile fields (name, role, capabilities, soulMd, identityMd, heartbeatMd, claudeMd, toolsMd, setupScript)
-- \`manage-user\`: Register or update human users (resolve from GitHub/GitLab identity or other source metadata)
+- \`manage-user\`: Register or update human users (resolve from GitHub/GitLab identity or other source metadata). When you learn a requester's stable communication preferences (tone, language, verbosity), persist them with its \`comms\` field so future sessions adapt.
 
 #### Task Routing
 
@@ -803,6 +803,32 @@ When working in a repository, your system prompt may include a **Repository Guid
   category: "system",
 });
 
+registerTemplate({
+  eventType: "system.agent.communication_style",
+  header: "",
+  defaultBody: `
+### Communication Style
+
+Your persona lives in your SOUL.md (see Your Identity, when present). It defines who you are. The rules below define how you write, whoever you are.
+
+They govern everything a human reads from you: Slack, PR and issue comments, tickets, email, pages, and task summaries.
+
+- Write like a person, not a press release. Plain words, direct statements.
+- Lead with the outcome or the answer. Context comes after.
+- Keep sentences short (25 words or fewer). One idea per sentence.
+- Use active voice. Say who did what.
+- Never use em dashes. Use a period, a comma, a colon, or parentheses.
+- No marketing adjectives (seamless, robust, powerful). State the fact that earns the claim instead.
+- No hedge stacks ("might possibly perhaps"). Keep a hedge only when you are genuinely unsure, and keep it: "may have failed" never becomes "failed".
+- No filler ("I hope this helps", "Great question!") and no formal sign-offs.
+- If something is broken, blocked, or a bad idea, say so plainly and say why.
+- Mirror the requester: reply in the language they wrote in, match their register, and answer at the depth they asked. A one-line question gets the answer first, detail after.
+- If a Requester Profile section is present, it wins on tone, depth, and format. Correctness always wins over style.
+`,
+  variables: [],
+  category: "system",
+});
+
 // ============================================================================
 // Per-task prompt templates (category: "task_lifecycle")
 // ============================================================================
@@ -812,12 +838,18 @@ registerTemplate({
   header: "",
   defaultBody: `
 ## Requester Profile
-This task was requested by {{requester_name}}{{requester_role_suffix}}.{{requester_notes_section}}
+This task was requested by {{requester_name}}{{requester_role_suffix}}.{{requester_comms_section}}{{requester_notes_section}}
 Honor this requester profile in tone, depth, and format where it doesn't conflict with correctness or your operating rules.
+If this task reveals new stable communication preferences for this requester, persist them: the lead updates \`comms\` (tone, language, verbosity) via \`manage-user\`.
 `,
   variables: [
     { name: "requester_name", description: "The requesting user's display name" },
     { name: "requester_role_suffix", description: "Formatted role suffix, including parentheses" },
+    {
+      name: "requester_comms_section",
+      description:
+        "Formatted communication preferences (tone/language/verbosity) sourced from users.metadata.comms, or empty string",
+    },
     {
       name: "requester_notes_section",
       description: "Formatted notes section sourced from users.notes, or empty string",
@@ -859,7 +891,8 @@ registerTemplate({
 
 {{@template[system.agent.system]}}
 {{@template[system.agent.share_urls]}}
-{{@template[system.agent.code_quality]}}`,
+{{@template[system.agent.code_quality]}}
+{{@template[system.agent.communication_style]}}`,
   variables: [
     { name: "role", description: "The agent's role" },
     { name: "agentId", description: "The agent's unique identifier" },
@@ -881,7 +914,8 @@ registerTemplate({
 
 {{@template[system.agent.system]}}
 {{@template[system.agent.share_urls]}}
-{{@template[system.agent.code_quality]}}`,
+{{@template[system.agent.code_quality]}}
+{{@template[system.agent.communication_style]}}`,
   variables: [
     { name: "role", description: "The agent's role" },
     { name: "agentId", description: "The agent's unique identifier" },
@@ -910,7 +944,8 @@ registerTemplate({
 
 {{@template[system.agent.system]}}
 {{@template[system.agent.share_urls]}}
-{{@template[system.agent.code_quality]}}`,
+{{@template[system.agent.code_quality]}}
+{{@template[system.agent.communication_style]}}`,
   variables: [
     { name: "role", description: "The agent's role" },
     { name: "agentId", description: "The agent's unique identifier" },
@@ -939,7 +974,8 @@ registerTemplate({
 
 {{@template[system.agent.system]}}
 {{@template[system.agent.share_urls]}}
-{{@template[system.agent.code_quality]}}`,
+{{@template[system.agent.code_quality]}}
+{{@template[system.agent.communication_style]}}`,
   variables: [
     { name: "role", description: "The agent's role" },
     { name: "agentId", description: "The agent's unique identifier" },
@@ -982,7 +1018,9 @@ registerTemplate({
   header: "",
   defaultBody: `{{@template[system.agent.role]}}
 
-{{@template[system.agent.worker.remote]}}`,
+{{@template[system.agent.worker.remote]}}
+
+{{@template[system.agent.communication_style]}}`,
   variables: [
     { name: "role", description: "The agent's role" },
     { name: "agentId", description: "The agent's unique identifier" },

package/src/providers/claude-adapter.ts

@@ -19,6 +19,7 @@ import {
   trackErrorFromJson,
 } from "../utils/error-tracker";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
+import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
 import { buildOtelTraceparentEnv, isHarnessOtelEnabled } from "./otel-env";
@@ -332,6 +333,7 @@ export function mergeMcpConfig(
   installedServers: Record<string, Record<string, unknown>> | null,
   taskId: string,
   contextKey?: string,
+  runtimeInstanceId?: string,
 ): { mcpServers: Record<string, unknown> } {
   const config: { mcpServers: Record<string, unknown> } = {
     mcpServers: { ...(baseConfig?.mcpServers ?? {}) },
@@ -360,6 +362,9 @@ export function mergeMcpConfig(
     if (contextKey) {
       (server.headers as Record<string, string>)["X-Context-Key"] = contextKey;
     }
+    if (runtimeInstanceId) {
+      (server.headers as Record<string, string>)["X-Runtime-Instance-ID"] = runtimeInstanceId;
+    }
   }
 
   return config;
@@ -434,6 +439,7 @@ export async function createSessionMcpConfig(
       installedServers ?? null,
       taskId,
       contextKey,
+      swarmRuntimeInstanceId(),
     );
     const sessionConfigPath = `/tmp/mcp-${taskId}.json`;
     await writeFile(sessionConfigPath, JSON.stringify(config, null, 2));

package/src/providers/codex-adapter.ts

@@ -77,6 +77,7 @@ import {
 } from "../utils/context-window";
 import { SessionErrorTracker } from "../utils/error-tracker";
 import { summarizeSession as runSummarize } from "../utils/internal-ai";
+import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { type CodexAgentsMdHandle, writeCodexAgentsMd } from "./codex-agents-md";
 import { computeCodexCostUsd, getCodexContextWindow, resolveCodexModel } from "./codex-models";
@@ -365,12 +366,17 @@ export async function buildCodexConfig(
   // (2) Swarm MCP server — Streamable HTTP transport.
   // Field names verified against https://developers.openai.com/codex/mcp:
   // `url`, `http_headers`, `enabled`, `startup_timeout_sec`, `tool_timeout_sec`.
+  // Same per-boot runtime identity the runner registers with — dispatch tools
+  // require it in multi-runtime mode, and it travels as request context, not
+  // as a tool argument.
+  const runtimeInstanceId = swarmRuntimeInstanceId();
   mcpServers["agent-swarm"] = {
     url: `${config.apiUrl}/mcp`,
     http_headers: {
       Authorization: `Bearer ${config.apiKey}`,
       "X-Agent-ID": config.agentId,
       "X-Source-Task-Id": config.taskId ?? "",
+      ...(runtimeInstanceId ? { "X-Runtime-Instance-ID": runtimeInstanceId } : {}),
     },
     enabled: true,
     startup_timeout_sec: 30,

package/src/providers/opencode-adapter.ts

@@ -19,6 +19,7 @@ import {
 } from "../utils/context-window";
 import { validateOpencodeCredentials } from "../utils/credentials";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
+import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
 import { DEFAULT_OPENROUTER_BASE_URL, getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
@@ -726,6 +727,10 @@ export class OpencodeAdapter implements ProviderAdapter {
     const installedMcp =
       (await fetchInstalledMcpServers(config.apiUrl, config.apiKey, config.agentId, "opencode")) ??
       {};
+    // Same per-boot runtime identity the runner registers with — dispatch
+    // tools require it in multi-runtime mode, and it travels as request
+    // context, not as a tool argument.
+    const runtimeInstanceId = swarmRuntimeInstanceId();
     const mcpConfig: Config["mcp"] = {
       swarm: {
         type: "remote",
@@ -733,6 +738,7 @@ export class OpencodeAdapter implements ProviderAdapter {
         headers: {
           Authorization: `Bearer ${config.apiKey}`,
           "X-Agent-ID": config.agentId,
+          ...(runtimeInstanceId ? { "X-Runtime-Instance-ID": runtimeInstanceId } : {}),
         },
       },
       ...installedMcp,

package/src/providers/pi-mono-adapter.ts

@@ -28,6 +28,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { type TSchema, Type } from "typebox";
 import { classifyAwsSdkError } from "../utils/aws-error-classifier";
+import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
 import { DEFAULT_OPENROUTER_BASE_URL, getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { readPkgVersion } from "./harness-version";
@@ -1089,6 +1090,13 @@ export class PiMonoAdapter implements ProviderAdapter {
           config.agentId,
           config.taskId,
         );
+        // Same per-boot runtime identity the runner registers with — dispatch
+        // tools require it in multi-runtime mode, and it travels as request
+        // context, not as a tool argument.
+        const runtimeInstanceId = swarmRuntimeInstanceId();
+        if (runtimeInstanceId) {
+          mcpClient.customHeaders["X-Runtime-Instance-ID"] = runtimeInstanceId;
+        }
         await mcpClient.initialize();
         const tools = await mcpClient.listTools();
         customTools = mcpToolsToDefinitions(mcpClient, tools);

package/src/providers/pricing-sources.md

@@ -84,6 +84,30 @@ Unlike token rates — where a missing rate marks the whole row
 That asymmetry is deliberate (a small request fee shouldn't unprice an entire
 session) and is documented in the cost-and-context-computation guide.
 
+## Attribution reporting contract
+
+Usage reporting keeps total spend separate from the cost population that can
+truthfully carry a human requester:
+
+- `attributableCostUsd` is total cost minus structurally human-free work;
+  coverage is `attributedCostUsd / attributableCostUsd`.
+- `excludedCostUsd` and `excludedTaskCount` retain visibility into the removed
+  population. A stale requester id on structurally human-free work does not put
+  that cost back into either side of the coverage ratio.
+- Human-free seeds are the `heartbeat`, `heartbeat-checklist`, and
+  `boot-triage` task types; legacy JSON tag rows matched by the `heartbeat`
+  tags `LIKE` check; creatorless schedules (including their workflow roots);
+  and requester-less system follow-ups of requester-less parents.
+- The classification propagates through requester-less descendants. An
+  explicitly attributed child is a human handoff and stops propagation down
+  that branch.
+
+The per-person report uses the same requester data model without grouping the
+cost denominator or turning it into a leaderboard. Human-requested root tasks
+determine Problems Initiated and Problems Shipped; their full task trees
+determine Agents, Repos, and Surfaces Reached. Requester-less autonomous roots
+and heartbeat-classified roots are omitted, and the metrics remain separate.
+
 ## Provider pricing caveats
 
 - **Claude Sonnet 5 introductory rate:** Anthropic's pricing page lists

package/src/queue-stall-alarm.ts

@@ -0,0 +1,216 @@
+import { getDb } from "./be/db";
+import { getSlackApp } from "./slack/app";
+import { scrubSecrets } from "./utils/secret-scrubber";
+
+export const QUEUE_STALL_THRESHOLD_MS = 30 * 60 * 1000;
+export const QUEUE_STALL_CHECK_INTERVAL_MS = 5 * 60 * 1000;
+const QUEUE_STALL_STARTUP_DELAY_MS = 10_000;
+
+export interface QueueStallSnapshot {
+  claimableCount: number;
+  oldestTaskId: string | null;
+  oldestClaimableAt: string | null;
+  oldestAgeMs: number;
+  recentPickupCount: number;
+}
+
+type QueueStallNotifier = (message: string) => Promise<void>;
+
+let alarmInterval: ReturnType<typeof setInterval> | null = null;
+let startupTimeout: ReturnType<typeof setTimeout> | null = null;
+let checkInFlight = false;
+let alarmActive = false;
+
+/**
+ * Read the queue denominator and oldest age in one snapshot. Tasks with unmet
+ * dependencies are excluded because a worker cannot start them yet.
+ */
+export function getQueueStallSnapshot(now = new Date()): QueueStallSnapshot {
+  const oldest = getDb()
+    .prepare<
+      { claimableCount: number; oldestTaskId: string | null; oldestClaimableAt: string | null },
+      []
+    >(
+      `WITH queued AS (
+         SELECT
+           t.id,
+           t.dependsOn,
+           COALESCE(
+             (
+               SELECT MAX(entry.createdAt)
+               FROM agent_log entry
+               WHERE entry.taskId = t.id
+                 AND entry.newValue = t.status
+                 AND entry.eventType IN (
+                   'task_created',
+                   'task_status_change',
+                   'task_released',
+                   'task_accepted',
+                   'task_rejected'
+                 )
+             ),
+             t.createdAt
+           ) AS queueEnteredAt
+         FROM agent_tasks t
+         WHERE t.status IN ('pending', 'unassigned')
+       ),
+       claimable AS (
+         SELECT
+           queued.id,
+           MAX(
+             queued.queueEnteredAt,
+             COALESCE(
+               (
+                 SELECT MAX(COALESCE(prerequisite.finishedAt, prerequisite.createdAt))
+                 FROM json_each(COALESCE(queued.dependsOn, '[]')) dep
+                 JOIN agent_tasks prerequisite ON prerequisite.id = dep.value
+               ),
+               queued.queueEnteredAt
+             )
+           ) AS claimableAt
+         FROM queued
+         WHERE NOT EXISTS (
+             SELECT 1
+             FROM json_each(COALESCE(queued.dependsOn, '[]')) dep
+             LEFT JOIN agent_tasks prerequisite ON prerequisite.id = dep.value
+             WHERE prerequisite.id IS NULL OR prerequisite.status != 'completed'
+           )
+       ),
+       oldest AS (
+         SELECT id, claimableAt FROM claimable ORDER BY claimableAt ASC LIMIT 1
+       )
+       SELECT
+         (SELECT COUNT(*) FROM claimable) AS claimableCount,
+         (SELECT id FROM oldest) AS oldestTaskId,
+         (SELECT claimableAt FROM oldest) AS oldestClaimableAt`,
+    )
+    .get();
+
+  const pickupCutoff = new Date(now.getTime() - QUEUE_STALL_THRESHOLD_MS).toISOString();
+  const recentPickupCount =
+    getDb()
+      .prepare<{ count: number }, [string]>(
+        `SELECT COUNT(*) AS count
+         FROM agent_log
+         WHERE eventType IN ('task_status_change', 'task_claimed')
+           AND oldValue IN ('pending', 'unassigned')
+           AND newValue = 'in_progress'
+           AND createdAt >= ?`,
+      )
+      .get(pickupCutoff)?.count ?? 0;
+
+  const oldestClaimableAt = oldest?.oldestClaimableAt ?? null;
+  return {
+    claimableCount: oldest?.claimableCount ?? 0,
+    oldestTaskId: oldest?.oldestTaskId ?? null,
+    oldestClaimableAt,
+    oldestAgeMs: oldestClaimableAt
+      ? Math.max(0, now.getTime() - new Date(oldestClaimableAt).getTime())
+      : 0,
+    recentPickupCount,
+  };
+}
+
+export function isQueueStalled(snapshot: QueueStallSnapshot): boolean {
+  return snapshot.claimableCount > 0 && snapshot.oldestAgeMs >= QUEUE_STALL_THRESHOLD_MS;
+}
+
+function formatAge(ageMs: number): string {
+  return `${Math.floor(ageMs / 60_000)}m`;
+}
+
+function formatCheckFailure(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return `[Queue Stall Alarm] Check or notification failed: ${scrubSecrets(message)}`;
+}
+
+async function notifySlack(message: string): Promise<void> {
+  const channel = process.env.SLACK_ALERTS_CHANNEL?.trim();
+  if (!channel) throw new Error("SLACK_ALERTS_CHANNEL is not configured");
+
+  const app = getSlackApp();
+  if (!app) throw new Error("Slack is not connected");
+
+  await app.client.chat.postMessage({
+    channel,
+    text: message,
+    unfurl_links: false,
+    unfurl_media: false,
+  });
+}
+
+/** Run one detector tick. Exported so tests and operators can exercise it directly. */
+export async function checkQueueStall(
+  now = new Date(),
+  notify: QueueStallNotifier = notifySlack,
+): Promise<QueueStallSnapshot> {
+  const snapshot = getQueueStallSnapshot(now);
+  const stalled = isQueueStalled(snapshot);
+
+  if (stalled && !alarmActive) {
+    await notify(
+      `🚨 *Agent Swarm queue pickup stalled*\n` +
+        `Claimable tasks: *${snapshot.claimableCount}*\n` +
+        `Oldest wait: *${formatAge(snapshot.oldestAgeMs)}* (task \`${snapshot.oldestTaskId}\`)\n` +
+        `Pickups in the last 30m: *${snapshot.recentPickupCount}*\n\n` +
+        "This alarm runs in the API process and does not require an agent to claim a task.",
+    );
+    alarmActive = true;
+    console.error(
+      `[Queue Stall Alarm] Fired: claimable=${snapshot.claimableCount}, oldest=${snapshot.oldestTaskId}, age=${formatAge(snapshot.oldestAgeMs)}, recent_pickups=${snapshot.recentPickupCount}`,
+    );
+  } else if (!stalled && alarmActive) {
+    await notify(
+      `✅ *Agent Swarm queue pickup recovered*\nClaimable tasks: *${snapshot.claimableCount}*\nPickups in the last 30m: *${snapshot.recentPickupCount}*`,
+    );
+    alarmActive = false;
+    console.log("[Queue Stall Alarm] Recovery notification sent");
+  }
+
+  return snapshot;
+}
+
+function scheduleCheck(): void {
+  if (checkInFlight) return;
+  checkInFlight = true;
+  checkQueueStall()
+    .catch((error) => {
+      console.error(formatCheckFailure(error));
+    })
+    .finally(() => {
+      checkInFlight = false;
+    });
+}
+
+export function startQueueStallAlarm(): void {
+  if (alarmInterval || startupTimeout) return;
+
+  console.log(
+    `[Queue Stall Alarm] Starting (threshold ${formatAge(QUEUE_STALL_THRESHOLD_MS)}, interval ${formatAge(QUEUE_STALL_CHECK_INTERVAL_MS)})`,
+  );
+  startupTimeout = setTimeout(() => {
+    startupTimeout = null;
+    scheduleCheck();
+  }, QUEUE_STALL_STARTUP_DELAY_MS);
+  alarmInterval = setInterval(scheduleCheck, QUEUE_STALL_CHECK_INTERVAL_MS);
+}
+
+export function stopQueueStallAlarm(): void {
+  if (startupTimeout) {
+    clearTimeout(startupTimeout);
+    startupTimeout = null;
+  }
+  if (alarmInterval) {
+    clearInterval(alarmInterval);
+    alarmInterval = null;
+  }
+  checkInFlight = false;
+}
+
+export const _test = {
+  formatCheckFailure,
+  resetState(): void {
+    stopQueueStallAlarm();
+    alarmActive = false;
+  },
+};

package/src/scheduler/scheduler.ts

@@ -4,6 +4,7 @@ import {
   getDb,
   getDueScheduledTasks,
   getScheduledTaskById,
+  getUserById,
   getWorkflow,
   updateScheduledTask,
 } from "@/be/db";
@@ -117,10 +118,16 @@ export interface DispatchScheduleResult {
   task?: AgentTask;
 }
 
+function withoutDeletedRequester(schedule: ScheduledTask): ScheduledTask {
+  if (!schedule.createdBy || getUserById(schedule.createdBy)) return schedule;
+  return { ...schedule, createdBy: undefined };
+}
+
 export async function dispatchScheduleTarget(
   schedule: ScheduledTask,
   extraTags: string[] = [],
 ): Promise<DispatchScheduleResult> {
+  schedule = withoutDeletedRequester(schedule);
   switch (schedule.targetType) {
     case "workflow": {
       if (!schedule.workflowId) {

package/src/script-workflows/executor.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { mkdir, rm } from "node:fs/promises";
 import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { ScriptRun } from "../types";
 import {
   buildSandboxedCommand,
@@ -40,7 +41,7 @@ export interface ScriptExecutor {
 
 export function getScriptWorkflowHarnessPath(): string {
   const runtimeDir = process.env.SCRIPT_WORKFLOW_RUNTIME_DIR;
-  if (!runtimeDir) return new URL("./harness.ts", import.meta.url).pathname;
+  if (!runtimeDir) return fileURLToPath(new URL("./harness.ts", import.meta.url));
 
   const bundledHarness = `${resolve(runtimeDir)}/harness.bundle.js`;
   if (!existsSync(bundledHarness)) {

package/src/scripts-runtime/executors/native.ts

@@ -1,3 +1,4 @@
+import { fileURLToPath } from "node:url";
 import {
   buildSandboxedCommand,
   readStreamCapped,
@@ -120,7 +121,7 @@ export class NativeScriptExecutor implements ScriptExecutor {
     // subprocesses cannot access. Use the pre-built bundle from real filesystem instead.
     const harnessPath = process.env.SCRIPT_RUNTIME_DIR
       ? `${process.env.SCRIPT_RUNTIME_DIR}/eval-harness.bundle.js`
-      : new URL("../eval-harness.ts", import.meta.url).pathname;
+      : fileURLToPath(new URL("../eval-harness.ts", import.meta.url));
     const controller = new AbortController();
     let timedOut = false;
     let killed = input.signal?.aborted ?? false;

package/src/scripts-runtime/executors/types.ts

@@ -10,6 +10,11 @@ export type SwarmConfigPayload = {
     apiKey: { value: string; isSecret: true };
     agentId: { value: string; isSecret: false };
     mcpBaseUrl: { value: string; isSecret: false };
+    /**
+     * Per-boot runtime identity of the invoking worker process. System
+     * context like the agent identity — scripts never supply or override it.
+     */
+    runtimeInstanceId?: { value: string; isSecret: false };
   };
   user: Record<string, { value: string; isSecret: boolean }>;
   egressSecrets?: EgressSecretEntry[];

package/src/scripts-runtime/loader.ts

@@ -19,6 +19,8 @@ export type RunScriptInput = {
   args?: unknown;
   fsMode?: ScriptFsMode;
   agentId: string;
+  /** Per-boot runtime identity of the invoking worker; system context, never script input. */
+  runtimeInstanceId?: string;
   signal?: AbortSignal;
   timeoutMs?: number;
   mcpBaseUrl?: string;
@@ -50,6 +52,9 @@ async function buildConfigPayload(input: RunScriptInput): Promise<SwarmConfigPay
         value: input.mcpBaseUrl ?? process.env.MCP_BASE_URL ?? "http://localhost:3013",
         isSecret: false,
       },
+      ...(input.runtimeInstanceId
+        ? { runtimeInstanceId: { value: input.runtimeInstanceId, isSecret: false as const } }
+        : {}),
     },
     user: input.userConfig ?? {},
     egressSecrets: input.egressSecrets ?? (await buildEgressSecrets()),

package/src/scripts-runtime/swarm-config.ts

@@ -5,6 +5,8 @@ export class SwarmConfig {
   readonly apiKey: RedactedValue<string>;
   readonly agentId: RedactedValue<string>;
   readonly mcpBaseUrl: RedactedValue<string>;
+  /** Per-boot runtime identity of the invoking worker; system context, never script input. */
+  readonly runtimeInstanceId: RedactedValue<string> | undefined;
 
   private readonly userValues: Map<string, RedactedValue<string>>;
 
@@ -21,6 +23,12 @@ export class SwarmConfig {
       type: "system",
       isSecret: payload.system.mcpBaseUrl.isSecret,
     });
+    this.runtimeInstanceId = payload.system.runtimeInstanceId
+      ? Redacted.make(payload.system.runtimeInstanceId.value, {
+          type: "system",
+          isSecret: payload.system.runtimeInstanceId.isSecret,
+        })
+      : undefined;
     this.userValues = new Map(
       Object.entries(payload.user ?? {}).map(([key, value]) => [
         key,

package/src/scripts-runtime/swarm-sdk.ts

@@ -14,6 +14,12 @@ function headers(config: SwarmConfig): Record<string, string> {
   return {
     Authorization: `Bearer ${Redacted.value(config.apiKey)}`,
     "X-Agent-ID": Redacted.value(config.agentId),
+    // Per-boot identity of the invoking worker process (system context, not
+    // script input) — work-acquisition endpoints gate on it in multi-runtime
+    // mode.
+    ...(config.runtimeInstanceId
+      ? { "X-Runtime-Instance-ID": Redacted.value(config.runtimeInstanceId) }
+      : {}),
     "Content-Type": "application/json",
   };
 }
@@ -168,6 +174,7 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
           hideCompleted: body.hideCompleted,
           consecutiveErrorsMin: body.consecutiveErrorsMin,
           lastRunStatus: body.lastRunStatus,
+          fields: body.includeFull ? "full" : undefined,
         }),
       };
     case "schedule_create":

package/src/scripts-runtime/types/stdlib.d.ts

@@ -158,6 +158,7 @@ declare module "swarm-sdk" {
       hideCompleted?: boolean;
       consecutiveErrorsMin?: number;
       lastRunStatus?: "failed" | "succeeded";
+      includeFull?: boolean;
     }): Promise<unknown>;
     // --- scripts ---
     script_search(args: { query?: string; scope?: ScriptScope; limit?: number }): Promise<unknown>;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -140,6 +140,7 @@ declare module "swarm-sdk" {
       hideCompleted?: boolean;
       consecutiveErrorsMin?: number;
       lastRunStatus?: "failed" | "succeeded";
+      includeFull?: boolean;
     }): Promise<unknown>;
     // --- scripts ---
     script_search(args: { query?: string; scope?: ScriptScope; limit?: number }): Promise<unknown>;

package/src/tests/budget-claim-gate.test.ts

@@ -128,6 +128,7 @@ describe("Phase 3 — /api/poll budget admission gate", () => {
     if ("error" in body) throw new Error("unexpected error response");
     expect(body.trigger?.type).toBe("task_assigned");
     expect((body.trigger as { taskId: string }).taskId).toBe(task.id);
+    expect(getAgentById(worker.id)?.status).toBe("busy");
   });
 
   test("pending task trigger includes requester role and notes", async () => {
@@ -272,6 +273,25 @@ describe("Phase 3 — /api/poll budget admission gate", () => {
     expect(claimedTriggers).toHaveLength(1);
     expect(nullTriggers).toHaveLength(1);
   });
+
+  test("pool claim marks the agent busy before the poll transaction returns", async () => {
+    const worker = createAgent({
+      name: "claim-status",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+    });
+    const pooled = createTaskExtended("claim status task", {});
+
+    expect(getAgentById(worker.id)?.status).toBe("idle");
+
+    const { body } = await callPoll(worker.id);
+
+    if ("error" in body) throw new Error("unexpected error response");
+    expect(body.trigger?.type).toBe("task_assigned");
+    expect((body.trigger as { taskId: string }).taskId).toBe(pooled.id);
+    expect(getAgentById(worker.id)?.status).toBe("busy");
+  });
 });
 
 // ─── MCP task-action accept tests ───────────────────────────────────────────