@sema-agent/core 5.2.0 → 5.4.0

package/dist/core/exec-output-tail.d.ts

@@ -30,4 +30,3 @@ export declare function sliceStreamIncrement(s: StreamCursorState, terminal: boo
     droppedBeforeCursor: number;
 };
 export declare function markTruncated(text: string, droppedBytes: number): string;
-export declare function markLiveSpoolRotations(text: string, liveRotations: number): string;

package/dist/core/exec-output-tail.js

@@ -73,9 +73,3 @@ export function markTruncated(text, droppedBytes) {
         ? `[... ${droppedBytes} earlier byte(s) truncated; showing last ${Buffer.byteLength(text, "utf8")} ...]\n${text}`
         : text;
 }
-export function markLiveSpoolRotations(text, liveRotations) {
-    if (liveRotations <= 0)
-        return text;
-    const note = `[spool reclaimed ${liveRotations} time(s) while the process was still writing; bytes appended during those windows may be missing beyond any counted truncation]`;
-    return text === "" ? note : `${text}${text.endsWith("\n") ? "" : "\n"}${note}`;
-}

package/dist/core/mcp.d.ts

@@ -1,3 +1,4 @@
+import { type ProtocolId } from "./protocol-table.js";
 import type { AgentTool } from "../internal/harness-types.js";
 import type { ImageContent, TextContent } from "../internal/llm.js";
 import { type McpImageResizer } from "./image-downsample.js";
@@ -69,14 +70,20 @@ export declare function mcpIdleTimeoutMs(kind: "stdio" | "http"): number;
 export declare function describeMcpSpecErrorCode(code: unknown): string | undefined;
 export declare function collapseMcpErrorPrefix(message: string): string;
 export declare function networkErrorCode(err: unknown, depth?: number): string | undefined;
-export declare function normalizeMcpName(name: string): string;
-export declare function clampNameSegment(seg: string, max?: number): string;
+export interface HttpTransportFailure {
+    condition: string;
+    delivered: "no" | "unknown";
+    httpStatus?: number;
+}
+export declare function describeHttpTransportFailure(err: unknown): HttpTransportFailure | undefined;
+export { normalizeNameSegment as normalizeMcpName, clampNameSegment } from "./protocol-naming.js";
 export * from "./image-downsample.js";
 export declare function inferCompactSchema(value: unknown, depth?: number): string;
-export declare function resolveMcpHttpHeaders(t: {
+export interface ProtocolHttpAuth {
     headers?: Record<string, string>;
     principalHeader?: string;
-}, principal?: string): Record<string, string> | undefined;
+}
+export declare function resolveProtocolHttpHeaders(protocol: ProtocolId, t: ProtocolHttpAuth, principal?: string): Record<string, string> | undefined;
 interface McpContentItem {
     type: string;
     text?: string;

package/dist/core/mcp.js

@@ -1,5 +1,5 @@
-import { createHash } from "node:crypto";
 import { MCP_NAMESPACE } from "./protocol-table.js";
+import { mintNamespacePrefix, mintNamespacedToolName, normalizeNameSegment } from "./protocol-naming.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport, StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -12,7 +12,6 @@ import { sliceHeadSafe, sliceTailSafe } from "./surrogate-safe-slice.js";
 import { truncateError } from "./tool-errors.js";
 import { delimitUntrusted, inlineUntrusted, sanitizeUntrustedText } from "./untrusted-text.js";
 import { validateJsonSchemaShape } from "./runner/strict-output-schema.js";
-const NAME_SEP = "__";
 export const MCP_PREFIX = MCP_NAMESPACE.prefix;
 const MCP_OUTPUT_TOKENS_DEFAULT = 25_000;
 const MCP_CHARS_PER_TOKEN = 4;
@@ -198,7 +197,7 @@ export function networkErrorCode(err, depth = 0) {
     }
     return networkErrorCode(err.cause, depth + 1);
 }
-function describeHttpTransportFailure(err) {
+export function describeHttpTransportFailure(err) {
     if (err instanceof McpError)
         return undefined;
     if (err instanceof StreamableHTTPError) {
@@ -297,19 +296,7 @@ function throwDeadServer(server, what) {
     e.details = { server };
     throw e;
 }
-export function normalizeMcpName(name) {
-    const charset = name.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return clampNameSegment(charset);
-}
-export function clampNameSegment(seg, max = 64) {
-    if (seg === "")
-        return "_";
-    if (seg.length <= max)
-        return seg;
-    const digest = createHash("sha256").update(seg).digest("hex").slice(0, 8);
-    const keep = max - digest.length - 1;
-    return keep > 0 ? `${seg.slice(0, keep)}_${digest}` : digest.slice(0, max);
-}
+export { normalizeNameSegment as normalizeMcpName, clampNameSegment } from "./protocol-naming.js";
 export * from "./image-downsample.js";
 const MCP_BLOB_DIR = join(tmpdir(), "sema-mcp-blobs");
 function extensionForMime(mimeType) {
@@ -345,7 +332,7 @@ function extensionForMime(mimeType) {
 async function persistMcpBlob(base64Data, mimeType, server) {
     const bytes = Buffer.from(base64Data, "base64");
     const ext = extensionForMime(mimeType);
-    const filePath = join(MCP_BLOB_DIR, `mcp-${normalizeMcpName(server ?? "server")}-blob-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${ext}`);
+    const filePath = join(MCP_BLOB_DIR, `mcp-${normalizeNameSegment(server ?? "server")}-blob-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${ext}`);
     try {
         await mkdir(MCP_BLOB_DIR, { recursive: true, mode: 0o700 });
         const st = await lstat(MCP_BLOB_DIR);
@@ -409,10 +396,10 @@ export function inferCompactSchema(value, depth = 2) {
     }
     return typeof value;
 }
-export function resolveMcpHttpHeaders(t, principal) {
+export function resolveProtocolHttpHeaders(protocol, t, principal) {
     if (t.principalHeader && principal !== undefined) {
         if (/[\r\n]/.test(principal))
-            throw new Error("mcp: principal must not contain CR/LF (header injection guard)");
+            throw new Error(`${protocol}: principal must not contain CR/LF (header injection guard)`);
         return { ...t.headers, [t.principalHeader]: principal };
     }
     return t.headers;
@@ -426,7 +413,7 @@ function buildTransport(spec, principal) {
             env: t.env,
         });
     }
-    const headers = resolveMcpHttpHeaders(t, principal);
+    const headers = resolveProtocolHttpHeaders(MCP_NAMESPACE.id, t, principal);
     return new StreamableHTTPClientTransport(new URL(t.url), {
         requestInit: headers ? { headers } : undefined,
     });
@@ -667,7 +654,7 @@ export async function materializeMcpTools(specs, principal, onElicit, imageResiz
         droppedTools,
         statuses,
         refresh: async (server) => {
-            const prefixOf = (name) => `${MCP_PREFIX}${normalizeMcpName(name)}${NAME_SEP}`;
+            const prefixOf = (name) => mintNamespacePrefix(MCP_NAMESPACE, name);
             const targets = server !== undefined ? serverHandles.filter((h) => h.name === server) : serverHandles;
             const results = [];
             if (server !== undefined && targets.length === 0) {
@@ -1149,14 +1136,14 @@ function intakeListedTools(listed, spec, client, health, imageResizer) {
         }
         const normalized = normalizeMcpToolSchema(t.inputSchema);
         let effectiveInputSchema = t.inputSchema;
-        let effectiveDescription = t.description;
+        let effectiveDescription = t.description !== undefined ? sanitizeUntrustedText(t.description) : undefined;
         if (normalized.outcome === "drop") {
             dropped.push({ tool: inlineUntrusted(t.name), reason: inlineUntrusted(normalized.reason, 240) });
             continue;
         }
         if (normalized.outcome === "normalized") {
             effectiveInputSchema = normalized.schema;
-            effectiveDescription = normalized.note + (t.description ? `\n\n${t.description}` : "");
+            effectiveDescription = normalized.note + (effectiveDescription ? `\n\n${effectiveDescription}` : "");
         }
         const schemaProblem = mcpToolSchemaProblem(effectiveInputSchema);
         if (schemaProblem !== undefined) {
@@ -1164,14 +1151,7 @@ function intakeListedTools(listed, spec, client, health, imageResizer) {
             continue;
         }
         const remoteName = t.name;
-        const namespacedName = (() => {
-            const TOOL_MIN = 16;
-            const fixed = MCP_PREFIX.length + NAME_SEP.length;
-            const serverBudget = Math.max(1, 64 - fixed - TOOL_MIN);
-            const server = clampNameSegment(normalizeMcpName(spec.name), serverBudget);
-            const prefix = `${MCP_PREFIX}${server}${NAME_SEP}`;
-            return `${prefix}${clampNameSegment(normalizeMcpName(remoteName), Math.max(1, 64 - prefix.length))}`;
-        })();
+        const namespacedName = mintNamespacedToolName(MCP_NAMESPACE, spec.name, remoteName);
         const hintAxis = mcpAxisFor(namespacedName, t.annotations);
         const axis = applyCallerAxisOverride(namespacedName, hintAxis, spec.toolAxes?.[remoteName]);
         if (axis)

package/dist/core/protocol-naming.d.ts

@@ -0,0 +1,7 @@
+import type { ProtocolNamespace } from "./protocol-table.js";
+export declare const TOOL_NAME_MAX_CHARS = 64;
+export declare const MINTED_TOOL_SEGMENT_MIN_CHARS = 16;
+export declare function normalizeNameSegment(name: string): string;
+export declare function clampNameSegment(seg: string, max?: number): string;
+export declare function mintNamespacePrefix(ns: ProtocolNamespace, peer: string): string;
+export declare function mintNamespacedToolName(ns: ProtocolNamespace, peer: string, tool: string): string;

package/dist/core/protocol-naming.js

@@ -0,0 +1,32 @@
+import { createHash } from "node:crypto";
+export const TOOL_NAME_MAX_CHARS = 64;
+export const MINTED_TOOL_SEGMENT_MIN_CHARS = 16;
+const SEGMENT_DIGEST_CHARS = 8;
+const NAME_SEP = "__";
+export function normalizeNameSegment(name) {
+    return clampNameSegment(name.replace(/[^a-zA-Z0-9_-]/g, "_"));
+}
+const SEGMENT_DIGEST_JOIN = "-";
+export function clampNameSegment(seg, max = TOOL_NAME_MAX_CHARS) {
+    if (seg === "")
+        return "_";
+    if (seg.length <= max)
+        return seg;
+    const digest = createHash("sha256").update(seg).digest("hex").slice(0, SEGMENT_DIGEST_CHARS);
+    const keep = max - digest.length - SEGMENT_DIGEST_JOIN.length;
+    return keep > 0 ? `${seg.slice(0, keep)}${SEGMENT_DIGEST_JOIN}${digest}` : digest.slice(0, max);
+}
+function settlePeerSegment(clamped) {
+    const folded = clamped.replace(/_{2,}/g, "_").replace(/_+$/, "");
+    if (folded !== "")
+        return folded;
+    return createHash("sha256").update(clamped).digest("hex").slice(0, SEGMENT_DIGEST_CHARS);
+}
+export function mintNamespacePrefix(ns, peer) {
+    const peerBudget = Math.max(1, TOOL_NAME_MAX_CHARS - ns.prefix.length - NAME_SEP.length - MINTED_TOOL_SEGMENT_MIN_CHARS);
+    return `${ns.prefix}${settlePeerSegment(clampNameSegment(normalizeNameSegment(peer), peerBudget))}${NAME_SEP}`;
+}
+export function mintNamespacedToolName(ns, peer, tool) {
+    const prefix = mintNamespacePrefix(ns, peer);
+    return `${prefix}${clampNameSegment(normalizeNameSegment(tool), Math.max(1, TOOL_NAME_MAX_CHARS - prefix.length))}`;
+}

package/dist/core/protocol-table.d.ts

@@ -1,4 +1,4 @@
-export type ProtocolId = "mcp";
+export type ProtocolId = "mcp" | "a2a";
 export interface ProtocolPeerTool {
     peer: string;
     tool: string;
@@ -11,7 +11,9 @@ export interface ProtocolNamespace<P extends string = string> {
     displayGroupKey(name: string): string;
 }
 declare const MCP_PREFIX_NAME: "mcp__";
+declare const A2A_PREFIX_NAME: "a2a__";
 export declare const MCP_NAMESPACE: ProtocolNamespace<typeof MCP_PREFIX_NAME>;
+export declare const A2A_NAMESPACE: ProtocolNamespace<typeof A2A_PREFIX_NAME>;
 export declare const PROTOCOL_TABLE: readonly ProtocolNamespace[];
 export declare function protocolOf(name: string): ProtocolNamespace | undefined;
 export {};

package/dist/core/protocol-table.js

@@ -1,37 +1,42 @@
 const NAME_SEP = "__";
+function makeProtocolNamespace(id, prefix) {
+    const parse = (name) => {
+        if (!name.startsWith(prefix))
+            return undefined;
+        const rest = name.slice(prefix.length);
+        const sep = rest.indexOf(NAME_SEP);
+        if (sep <= 0)
+            return undefined;
+        const tool = rest.slice(sep + NAME_SEP.length);
+        if (tool.length === 0)
+            return undefined;
+        return { peer: rest.slice(0, sep), tool };
+    };
+    const makeName = (peer, tool) => {
+        if (peer.length === 0 || tool.length === 0) {
+            throw new Error(`protocol table (${id}): peer and tool must both be non-empty (got peer=${JSON.stringify(peer)}, tool=${JSON.stringify(tool)})`);
+        }
+        if (peer.includes(NAME_SEP)) {
+            throw new Error(`protocol table (${id}): peer must not contain the ${NAME_SEP} separator (got ${JSON.stringify(peer)}) — the composed name would parse back as a DIFFERENT peer`);
+        }
+        return `${prefix}${peer}${NAME_SEP}${tool}`;
+    };
+    return {
+        id,
+        prefix,
+        makeName,
+        parse,
+        displayGroupKey: (name) => {
+            const p = parse(name);
+            return p === undefined ? name : `${prefix}${p.peer}${NAME_SEP}*`;
+        },
+    };
+}
 const MCP_PREFIX_NAME = `mcp${NAME_SEP}`;
-const parseMcpName = (name) => {
-    if (!name.startsWith(MCP_PREFIX_NAME))
-        return undefined;
-    const rest = name.slice(MCP_PREFIX_NAME.length);
-    const sep = rest.indexOf(NAME_SEP);
-    if (sep <= 0)
-        return undefined;
-    const tool = rest.slice(sep + NAME_SEP.length);
-    if (tool.length === 0)
-        return undefined;
-    return { peer: rest.slice(0, sep), tool };
-};
-const makeMcpName = (peer, tool) => {
-    if (peer.length === 0 || tool.length === 0) {
-        throw new Error(`protocol table (mcp): peer and tool must both be non-empty (got peer=${JSON.stringify(peer)}, tool=${JSON.stringify(tool)})`);
-    }
-    if (peer.includes(NAME_SEP)) {
-        throw new Error(`protocol table (mcp): peer must not contain the ${NAME_SEP} separator (got ${JSON.stringify(peer)}) — the composed name would parse back as a DIFFERENT peer`);
-    }
-    return `${MCP_PREFIX_NAME}${peer}${NAME_SEP}${tool}`;
-};
-export const MCP_NAMESPACE = {
-    id: "mcp",
-    prefix: MCP_PREFIX_NAME,
-    makeName: makeMcpName,
-    parse: parseMcpName,
-    displayGroupKey: (name) => {
-        const p = parseMcpName(name);
-        return p === undefined ? name : `${MCP_PREFIX_NAME}${p.peer}${NAME_SEP}*`;
-    },
-};
-export const PROTOCOL_TABLE = [MCP_NAMESPACE];
+const A2A_PREFIX_NAME = `a2a${NAME_SEP}`;
+export const MCP_NAMESPACE = makeProtocolNamespace("mcp", MCP_PREFIX_NAME);
+export const A2A_NAMESPACE = makeProtocolNamespace("a2a", A2A_PREFIX_NAME);
+export const PROTOCOL_TABLE = [MCP_NAMESPACE, A2A_NAMESPACE];
 export function protocolOf(name) {
     return PROTOCOL_TABLE.find((ns) => name.startsWith(ns.prefix));
 }

package/dist/core/runner/prepare-task.d.ts

@@ -1,6 +1,7 @@
 import { AgentHarness, type ThinkingLevel } from "../../internal/harness.js";
 import type { Model } from "../../internal/llm.js";
 import { type MaterializedMcp } from "../mcp.js";
+import { type MaterializedA2a } from "../a2a.js";
 import type { HarvestReport, MemorySessionHandle } from "../memory-engine/types.js";
 import { StoredSession } from "../session.js";
 import type { SessionStore } from "../session.js";
@@ -10,11 +11,13 @@ import { type ActiveSkillFrame } from "./active-skill-scope.js";
 import { type CutKillRegistry } from "./cut-kill.js";
 import type { SessionPermissionRules } from "../session-policy-store.js";
 import { CacheBreakDetector, type ToolFingerprintInput } from "../cache-break-detector.js";
+import { type BrainCallGuardrailRef } from "../../brain/timeout.js";
 import { type OutputRef, type BlockedRef, type SkillListingEntry } from "./synthetic-tools.js";
 import type { MemoryEngine } from "../memory-engine/engine.js";
 import { type ToolManifestRow } from "../../prompt-assembly/tool-catalog.js";
 import type { TaskNotificationPayload } from "../task-notification.js";
 import { type CwdRef } from "../../tools/fs/index.js";
+import { type WorkflowSizeGuideline } from "../../orchestration/workflow-size-guideline.js";
 import type { Runner } from "./runtask.js";
 import { type CheckpointGate, type CheckpointState, type CheckpointToken, type ResourceLedger, type ResourceLimitReason } from "../checkpoint-store.js";
 import type { ActiveWorktreeSession, AgentMessage, AgentTool, ExecutionEnv } from "../../internal/harness.js";
@@ -36,6 +39,7 @@ export interface Prepared {
     thinking?: ThinkingLevel;
     compModel?: Model;
     mcp: MaterializedMcp;
+    a2a?: MaterializedA2a;
     blockedRef: BlockedRef;
     outputRef: OutputRef;
     abortController: AbortController;
@@ -133,6 +137,7 @@ export interface Prepared {
     callIssuedAtRef?: {
         current?: number;
     };
+    brainCallGuardrailRef: BrainCallGuardrailRef;
     reviewRequestRef: {
         pending?: {
             reason?: string;
@@ -186,6 +191,10 @@ export interface Prepared {
         path: string;
         contentHash: string | null;
     }>;
+    workflowSizeGuideline?: {
+        legGuideline: WorkflowSizeGuideline;
+        current: () => WorkflowSizeGuideline;
+    };
     detectExternalChanges?: (maxFiles: number) => Promise<{
         changed: Array<{
             path: string;

package/dist/core/runner/prepare-task.js

@@ -9,6 +9,7 @@ import { buildAutoModePrompt, renderAutoModeAction, renderAutoModeWindow } from
 import { resolveModel, resolveTaskModel, roleModelIfSet } from "../roles.js";
 import { primaryActivityArg } from "../arg-summary.js";
 import { materializeMcpTools } from "../mcp.js";
+import { materializeA2aTools } from "../a2a.js";
 import { Type } from "typebox";
 import { brainToRuntime } from "../runtime.js";
 import { StoredSession, isSessionConflict, hasSessionFork } from "../session.js";
@@ -28,9 +29,10 @@ import { cloneObserverInput, formatHookFeedback, runToolGate } from "../hooks.js
 import { reconcileInterruptedSession } from "../session-reconcile.js";
 import { CacheBreakDetector, toolsToFingerprintInputs } from "../cache-break-detector.js";
 import { reservedCollisions, reservedFor } from "../../brain/request-params.js";
+import { resolveBrainCallGuardrailMs, withBrainCallGuardrail } from "../../brain/timeout.js";
 import { defineTool, isDefineToolProduct } from "../tools.js";
 import { RETIRED_TOOL_NAMES } from "../tool-name-aliases.js";
-import { protocolOf } from "../protocol-table.js";
+import { protocolOf, PROTOCOL_TABLE } from "../protocol-table.js";
 import { pathToUri } from "../lsp-protocol.js";
 import { DEFAULT_TOOL_RESULT_THRESHOLD_CHARS, createOffloadPersist, firstPartyOffloadPolicy, InMemoryToolResultStore, RunnerSharedToolResultStore, ScopedToolResultStore, isVolatileOffloadStore, OFFLOAD_TOOL_NAME, createReadToolResultTool, withToolResultOffload, } from "../tool-result-store.js";
 import { OUTPUT_TOOL_NAME, REPORT_FINDINGS_TOOL_NAME, SKILL_CONTENT_MAX_CHARS, SKILL_TOOL_NAME, createOutputTool, createReportBlockedTool, createReportFindingsTool, createSkillTool, normalizeSkills } from "./synthetic-tools.js";
@@ -64,6 +66,7 @@ import { createSchedulerTools } from "../../tools/scheduler-tools.js";
 import { createPresentPlanTool, createEnterPlanModeTool, PRESENT_PLAN_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME } from "../present-plan-tool.js";
 import { isSelfOrchestrationActive, selfOrchestrationFailClosedReason } from "../../orchestration/workflow-script-runner.js";
 import { createRunWorkflowTool, RUN_WORKFLOW_TOOL_NAME } from "../../orchestration/run-workflow-tool.js";
+import { resolveWorkflowSizeGuideline } from "../../orchestration/workflow-size-guideline.js";
 import { createLspTool, gitCheckIgnoreFilter, resolveLspPath } from "../lsp.js";
 import { resolveKey } from "../../tools/fs/safety.js";
 import { BINDING_CHECKPOINT_VERSION, mintCheckpointToken, RESOURCE_CHECKPOINT_VERSION, WALLTIME_CHECKPOINT_VERSION, buildRiskDescriptor, debitLedger, remainingBudgetMicroUsd, } from "../checkpoint-store.js";
@@ -82,6 +85,7 @@ function sanitizedTtlMs(ttlMs) {
 const ungatedWarnedShapes = new WeakMap();
 const advisedPolicyNames = new WeakMap();
 const ADVISED_KEYS_CAP = 64;
+const NAMESPACED_NAME_SHAPES = PROTOCOL_TABLE.map((ns) => `${ns.prefix}<peer>__<tool>`).join(", ");
 export const DEFAULT_IRREVERSIBLE_SCOPE = "irreversible";
 export function checkpointScopeOf(spec) {
     return spec.durableApproval?.scope || spec.principal || DEFAULT_IRREVERSIBLE_SCOPE;
@@ -233,6 +237,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         e.code = "config.empty_objective";
         throw e;
     }
+    const brainCallGuardrailRef = {};
+    const brainCallGuardrailMs = resolveBrainCallGuardrailMs(spec.limits?.brainCallGuardrailMs ?? deps.brainCallGuardrailMs);
     if (spec.agents !== undefined && spec.agents.length > 0) {
         const pool = spec.tools ?? [];
         if (!pool.some((t) => typeof t.withAgents === "function")) {
@@ -261,7 +267,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     let shellGatedMonitor = false;
     for (const t of spec.tools ?? []) {
         if (t.name.includes("__")) {
-            const e = new Error(`Tool name "${t.name}" is invalid: "__" is reserved for the MCP namespace (mcp__<server>__<tool>) and must not appear in a caller tool name.`);
+            const e = new Error(`Tool name "${t.name}" is invalid: "__" is reserved for the engine's protocol tool namespaces (${NAMESPACED_NAME_SHAPES}) and must not appear in a caller tool name.`);
             e.code = "config.tool_name_invalid";
             throw e;
         }
@@ -479,7 +485,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             return maybeOffload(tool, policy);
         return maybeOffload(tool, explicitGlobalThreshold === undefined ? policy : undefined);
     };
-    const mcpOffload = (tool) => {
+    const remoteToolOffload = (tool) => {
         if (explicitGlobalThreshold !== undefined)
             return maybeOffload(tool);
         return maybeOffload(tool, { offloadThresholdChars: tool.mcpMaxResultSizeChars ?? 50_000 });
@@ -492,6 +498,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     }
     let ownedEnv;
     let mcp;
+    let a2a;
     if (internals?.requestedCwd !== undefined && deps.executionEnvFactory === undefined) {
         await settleTeardownLeg(() => forgetOnThrow(), "forgetOnThrow (cwd-unsupported leg)", (err) => deps.onError?.(err, { phase: "config", sessionId }));
         const e = new Error(`Agent cwd "${internals.requestedCwd}" cannot take effect: this deployment has no executionEnvFactory (a static execution environment cannot be re-rooted per agent). Drop the cwd parameter or deploy a factory.`);
@@ -969,8 +976,11 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 `(per-principal entitlement governance, not a misconfiguration — the run_workflow tool is not mounted)`), { phase: "config", sessionId });
         }
         let workflowToolsActive = false;
+        let workflowSizeGuideline;
         if (selfOrchestrationActive && runnerSelf && deps.workflowScriptRunner && deps.workflowGovernanceBaseline) {
             workflowToolsActive = true;
+            const currentSizeGuideline = () => resolveWorkflowSizeGuideline(deps.workflowLimits?.sizeGuideline).size;
+            workflowSizeGuideline = { legGuideline: currentSizeGuideline(), current: currentSizeGuideline };
             toolEffects.set(RUN_WORKFLOW_TOOL_NAME, "write");
             tools.push(await createRunWorkflowTool({
                 runner: runnerSelf,
@@ -1093,7 +1103,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 throw e;
             }
         }
-        tools.push(...mcp.tools.map((t) => mcpOffload(t)));
+        tools.push(...mcp.tools.map((t) => remoteToolOffload(t)));
         const rebuildHarnessToolsRef = {};
         const toolCallGateArmedRef = { armed: false };
         if (spec.mcp?.length) {
@@ -1121,7 +1131,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         const pushable = r.tools.filter((t) => !excludedSet.has(t.name));
                         const excludedNow = r.tools.filter((t) => excludedSet.has(t.name)).map((t) => t.name);
                         try {
-                            foldMcpAxes((r.axes ?? []).filter((a) => !excludedSet.has(a.name)));
+                            foldProtocolAxes((r.axes ?? []).filter((a) => !excludedSet.has(a.name)), "MCP");
                         }
                         catch (foldErr) {
                             lines.push(`${r.server}: failed (${foldErr instanceof Error ? foldErr.message : String(foldErr)})`);
@@ -1135,7 +1145,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                 tools.splice(i, 1);
                             }
                         }
-                        tools.push(...pushable.map((t) => mcpOffload(t)));
+                        tools.push(...pushable.map((t) => remoteToolOffload(t)));
                         changed = true;
                         const detail = [];
                         const shownAdded = r.added.filter((n) => !excludedSet.has(n));
@@ -1165,7 +1175,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             });
             toolEffects.set("RefreshMcpTools", "read");
         }
-        const foldMcpAxes = (axes) => {
+        const foldProtocolAxes = (axes, protocolLabel) => {
             for (const axis of axes) {
                 if (axis.irreversibility === "always") {
                     irreversibilityTier.set(axis.name, "always");
@@ -1173,7 +1183,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
                 if (axis.egress) {
                     if (axis.effect !== undefined && axis.effect !== "write") {
-                        const e = new Error(`MCP tool "${axis.name}" resolves to egress:true with effect:"${axis.effect}" — an egress tool (external write) must have effect:"write". Clear egress (toolAxes egress:false) if it is a pure read, or set effect:"write".`);
+                        const e = new Error(`${protocolLabel} tool "${axis.name}" resolves to egress:true with effect:"${axis.effect}" — an egress tool (external write) must have effect:"write". Clear egress (toolAxes egress:false) if it is a pure read, or set effect:"write".`);
                         e.code = "config.egress_requires_write_effect";
                         throw e;
                     }
@@ -1183,7 +1193,25 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     toolEffects.set(axis.name, axis.effect ?? "write");
             }
         };
-        foldMcpAxes(mcp.toolAxes);
+        foldProtocolAxes(mcp.toolAxes, "MCP");
+        a2a = spec.a2a?.length
+            ? await materializeA2aTools(spec.a2a, spec.principal, abortController.signal)
+            : { tools: [], toolAxes: [], warnings: [], statuses: [], refresh: async () => [], dispose: async () => { } };
+        for (const w of a2a.warnings)
+            deps.onError?.(w, { phase: "a2a", sessionId });
+        {
+            const callerNames = new Set((spec.tools ?? []).flatMap((t) => [t.name, ...(t.aliases ?? [])]));
+            const clash = a2a.tools.find((t) => callerNames.has(t.name));
+            if (clash) {
+                await a2a.dispose();
+                await mcp.dispose();
+                const e = new Error(`Tool name "${clash.name}" is reserved by an injected A2A tool — a caller tool of the same name would silently shadow it.`);
+                e.code = "config.reserved_tool_name";
+                throw e;
+            }
+        }
+        tools.push(...a2a.tools.map((t) => remoteToolOffload(t)));
+        foldProtocolAxes(a2a.toolAxes, "A2A");
         const callCapOn = spec.limits?.callCapByDeadline !== false;
         const callCapRef = spec.limits?.timeoutSec &&
             spec.limits.timeoutSec > 0 &&
@@ -1861,11 +1889,11 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             }
         }
         const userToolNames = (spec.tools ?? []).map((t) => t.name);
-        const mcpToolNames = mcp.tools.map((t) => t.name);
+        const protocolToolNames = [...mcp.tools.map((t) => t.name), ...a2a.tools.map((t) => t.name)];
         const deferred = classifyDeferred({
             specs: spec.tools ?? [],
-            mcpToolNames,
-            fullTools: tools.filter((t) => userToolNames.includes(t.name) || mcpToolNames.includes(t.name)),
+            protocolToolNames,
+            fullTools: tools.filter((t) => userToolNames.includes(t.name) || protocolToolNames.includes(t.name)),
             deferMode: deps.deferMode,
             model,
             deferNames: (toolFaceSnapshot.defer ?? []).filter((n) => tools.some((t) => t.name === n)),
@@ -2173,7 +2201,12 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             systemPrompt,
             ...(assembled.systemBlocks ? { systemBlocks: assembled.systemBlocks } : {}),
             getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
-            runtime: brainToRuntime(deps.brain),
+            runtime: brainToRuntime(brainCallGuardrailMs === undefined
+                ? deps.brain
+                : {
+                    ...deps.brain,
+                    stream: withBrainCallGuardrail((m, c, o) => deps.brain.stream(m, c, o), brainCallGuardrailMs, brainCallGuardrailRef),
+                }),
         });
         harnessRef.current = harness;
         let releaseSignal = () => undefined;
@@ -2211,7 +2244,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                 throw err;
                             }
                             if (n.includes("__") && protocolOf(n) === undefined) {
-                                const err = new Error(`tool policy ${kind}-list entry "${n}" is a pre-prefix MCP tool name and matches nothing in this run's roster — MCP tools are named "mcp__<server>__<tool>" and legacy-name normalization was removed (RB-476-A), so this entry would silently guard nothing. Prefix the entry with "mcp__".`);
+                                const err = new Error(`tool policy ${kind}-list entry "${n}" carries the "__" namespace separator but no protocol prefix, and matches nothing in this run's roster — protocol tools are named ${NAMESPACED_NAME_SHAPES}, and legacy-name normalization was removed (RB-476-A), so this entry would silently guard nothing. Prefix the entry with the owning protocol's marker.`);
                                 err.code = "config.legacy_tool_name";
                                 throw err;
                             }
@@ -3504,12 +3537,16 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             : undefined;
         overheadState.promptChars = systemPrompt.length;
         const preparedHolder = {};
-        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), ownedEnv, suspendRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(callCapRef ? { callCapRef } : {}), ...(cutKills ? { cutKills } : {}), ...(callCapRef ? { callIssuedAtRef } : {}), suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
+        const buildPrepared = () => ({ harness, session, sessionId, taskRootPath, model, thinking, compModel, mcp: mcp, ...(a2a !== undefined && a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), releaseSignal, cacheBreakDetector, cacheFingerprint, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), ownedEnv, suspendRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(callCapRef ? { callCapRef } : {}), ...(cutKills ? { cutKills } : {}), ...(callCapRef ? { callIssuedAtRef } : {}), brainCallGuardrailRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, promptOverheadTokens, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit } } : {}), planModeRef, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, listBackgroundTasks, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         const prepared = buildPrepared();
         preparedHolder.current = prepared;
         return prepared;
     }
     catch (prepareErr) {
+        if (a2a) {
+            const a2aHandle = a2a;
+            await settleTeardownLeg(() => a2aHandle.dispose(), "a2a.dispose (prepare-throw leg)", (e) => deps.onError?.(e, { phase: "config", sessionId }));
+        }
         if (mcp) {
             const mcpHandle = mcp;
             await settleTeardownLeg(() => mcpHandle.dispose(), "mcp.dispose (prepare-throw leg)", (e) => deps.onError?.(e, { phase: "config", sessionId }));