@sema-agent/core 5.2.0 → 5.3.0

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";
@@ -15,6 +16,7 @@ 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 +38,7 @@ export interface Prepared {
     thinking?: ThinkingLevel;
     compModel?: Model;
     mcp: MaterializedMcp;
+    a2a?: MaterializedA2a;
     blockedRef: BlockedRef;
     outputRef: OutputRef;
     abortController: AbortController;
@@ -186,6 +189,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";
@@ -30,7 +31,7 @@ import { CacheBreakDetector, toolsToFingerprintInputs } from "../cache-break-det
 import { reservedCollisions, reservedFor } from "../../brain/request-params.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 +65,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 +84,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;
@@ -261,7 +264,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 +482,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 +495,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 +973,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 +1100,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 +1128,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 +1142,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 +1172,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 +1180,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 +1190,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 +1886,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)),
@@ -2211,7 +2236,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 +3529,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 } : {}), 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 }));

package/dist/core/runner/runtask.js

@@ -40,6 +40,7 @@ import { refuseOutOfContractDecision, toolPolicyNameSets } from "../tool-policy.
 import { defaultTaskRegistry } from "../task-registry.js";
 import { discloseDroppedPending, PendingSessionNotifications, renderTaskNotificationXml, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
+import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-size-guideline.js";
 import { DEFAULT_MAX_TURNS } from "../../config/defaults.js";
 import { structuredFrom, toolOutputFrom } from "./tool-output-projection.js";
 export { DEFAULT_MAX_TURNS };
@@ -51,7 +52,7 @@ function createRunState() {
         budget: { remainingMicroUsd: undefined, maxCostMicroUsd: undefined, overBudget: () => false, streamCancel: false, callOutputChars: 0, lastStreamBudgetCheck: 0, projectedOverBudget: () => false },
         turn: { callStartAt: undefined, firstTokenAt: undefined, turnUsage: undefined, turnUsageMissing: false, turnStopReason: undefined, lastTurnHadToolCalls: false, toolBatch: [] },
         counters: { nudgesSent: 0, nudgeIdx: 0, finalizeInjected: false, walltimeSyncBackstopFired: false, compactionFloor: 0, trimForceBackoff: false, callCutoffs: 0, repetitionCuts: 0, repetitionSpared: 0, repetitionEvents: [], REPETITION_EVENTS_CAP: 0, preemptIgnoredReported: false, wroteThisRun: false, finalVerifyInjections: 0, groundingSignalPreR9: false, groundingSignalPostR9: false, cadenceTurns: 0 },
-        attach: { attachmentsCfg: undefined, agentListingOn: false, skillsListingOn: false, attachState: undefined, dateState: undefined, instrProbe: undefined, instrState: undefined, attachmentsInjected: 0 },
+        attach: { attachmentsCfg: undefined, agentListingOn: false, skillsListingOn: false, attachState: undefined, dateState: undefined, instrProbe: undefined, instrState: undefined, sizeGuidelineState: undefined, attachmentsInjected: 0 },
     };
 }
 const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
@@ -314,7 +315,10 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
         }
         let boundaryAttachmentBytes = 0;
         let attachmentsPayload;
-        if ((rs.attach.dateState !== undefined || rs.attach.instrState !== undefined || rs.attach.attachState !== undefined) &&
+        if ((rs.attach.dateState !== undefined ||
+            rs.attach.instrState !== undefined ||
+            rs.attach.sizeGuidelineState !== undefined ||
+            rs.attach.attachState !== undefined) &&
             !boundarySteered &&
             !rs.counters.finalizeInjected &&
             rs.counters.finalVerifyInjections === 0 &&
@@ -457,6 +461,16 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     rs.attach.dateState.announcedDate = today;
                 }
             }
+            if (rs.attach.sizeGuidelineState !== undefined && rs.turn.lastTurnHadToolCalls) {
+                const guideline = rs.attach.sizeGuidelineState.current();
+                if (guideline !== rs.attach.sizeGuidelineState.announcedGuideline) {
+                    due.splice(due.length > 0 && due[0].source === "date_change" ? 1 : 0, 0, {
+                        source: "workflow_size_guideline_change",
+                        body: workflowSizeGuidelineChangeNotice(guideline),
+                    });
+                    rs.attach.sizeGuidelineState.announcedGuideline = guideline;
+                }
+            }
             if (rs.attach.instrState !== undefined && rs.attach.instrProbe !== undefined && rs.turn.lastTurnHadToolCalls) {
                 let probed = null;
                 try {
@@ -1770,6 +1784,10 @@ export class Runner {
             rs.attach.instrProbe !== undefined && prepared.instructionSources !== undefined && prepared.instructionSources.length > 0
                 ? { lastAnnouncedHash: new Map(prepared.instructionSources.map((s) => [s.path, s.contentHash])) }
                 : undefined;
+        rs.attach.sizeGuidelineState =
+            prepared.workflowSizeGuideline !== undefined
+                ? { announcedGuideline: prepared.workflowSizeGuideline.legGuideline, current: prepared.workflowSizeGuideline.current }
+                : undefined;
         rs.counters.cadenceTurns = 0;
         rs.turn.lastTurnHadToolCalls = false;
         if (rs.attach.attachState !== undefined && rs.attach.attachmentsCfg?.backgroundTasks === true) {
@@ -2620,6 +2638,7 @@ export class Runner {
         catch (err) {
             if (errorCodeOf(err) === "resume.tool_unavailable") {
                 await settleTeardownLeg(() => prepared.mcp.dispose(), "mcp.dispose (tool_unavailable leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
+                await settleTeardownLeg(() => prepared.a2a?.dispose(), "a2a.dispose (tool_unavailable leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
                 await settleTeardownLeg(() => (prepared.ownedEnv && hasDestroy(prepared.ownedEnv) ? prepared.ownedEnv.destroy() : undefined), "ownedEnv.destroy (tool_unavailable leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
                 throw err;
             }
@@ -3198,12 +3217,12 @@ export class Runner {
         if (outcome.gate === "policy_ask") {
             const boundTo = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.toolCallId : undefined;
             if (outcome.boundCallId !== boundTo) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume boundCallId "${outcome.boundCallId}" does not match the checkpoint's pending tool call "${boundTo ?? "(none)"}" — the decision-action binding (design/80 D-1) failed; refusing to apply a decision bound to a different action`);
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume boundCallId "${outcome.boundCallId}" does not match the checkpoint's pending tool call "${boundTo ?? "(none)"}" — the decision-action binding (design/80 D-1) failed; refusing to apply a decision bound to a different action`, { field: "boundCallId" });
             }
             const boundHash = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.boundInputHash : undefined;
             if (boundHash !== undefined) {
                 if (outcome.boundInputHash !== boundHash) {
-                    throw new CheckpointError("checkpoint.invalid_outcome", "resume boundInputHash does not match the checkpoint's pending tool call input — the decision-action input binding (design/80 D-1 §2) failed; refusing to apply an approval bound to a different input (TOCTOU re-mint guard)");
+                    throw new CheckpointError("checkpoint.invalid_outcome", "resume boundInputHash does not match the checkpoint's pending tool call input — the decision-action input binding (design/80 D-1 §2) failed; refusing to apply an approval bound to a different input (TOCTOU re-mint guard)", { field: "boundInputHash" });
                 }
             }
             else if (checkpointVersionOf(cp) >= BINDING_CHECKPOINT_VERSION) {
@@ -3520,6 +3539,14 @@ export class Runner {
         catch (err) {
             this.deps.onError?.(err, { phase: "mcp", sessionId: prepared.sessionId });
         }
+        if (prepared.a2a !== undefined) {
+            try {
+                await prepared.a2a.dispose();
+            }
+            catch (err) {
+                this.deps.onError?.(err, { phase: "a2a", sessionId: prepared.sessionId });
+            }
+        }
         return comp;
     }
     async teardownOwnedEnv(prepared) {

package/dist/core/runner/tool-disclosure.d.ts

@@ -14,7 +14,7 @@ export declare function deferHint(description: string, max?: number): string;
 export declare function safeName(name: string): string;
 export declare function classifyDeferred(opts: {
     specs: ReadonlyArray<ToolSpec>;
-    mcpToolNames: ReadonlyArray<string>;
+    protocolToolNames: ReadonlyArray<string>;
     fullTools: ReadonlyArray<ToolFingerprintInput>;
     deferMode?: "auto";
     model: Model;

package/dist/core/runner/tool-disclosure.js

@@ -35,7 +35,7 @@ export function classifyDeferred(opts) {
         if (s.defer === true && !pinned.has(s.name))
             deferred.add(s.name);
     }
-    for (const name of opts.mcpToolNames)
+    for (const name of opts.protocolToolNames)
         if (!pinned.has(name))
             deferred.add(name);
     for (const name of opts.deferNames ?? [])

package/dist/core/runner/turn-attachments.d.ts

@@ -15,7 +15,7 @@ export declare const TOOL_SEARCH_REMINDER_CONFIG: {
 export declare const CHANGED_FILES_MAX = 20;
 export declare const CHANGED_FILES_MTIME_EPS_MS = 2000;
 export declare const ATTACHMENT_BYTE_CAP: number;
-export type AttachmentSource = "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools";
+export type AttachmentSource = "todo_reminder" | "task_reminder" | "tool_search_usage_reminder" | "changed_files" | "plan_mode" | "date_change" | "instructions_change" | "workflow_size_guideline_change" | "budget_usd" | "background_tasks" | "tools_delta" | "agent_listing" | "skills_listing" | "mcp_instructions" | "mcp_dropped_tools";
 export interface AgentListingEntry {
     name: string;
     description: string;
@@ -31,7 +31,6 @@ export interface TurnAttachment {
     body: string;
 }
 export interface ListProjection {
-    statusCounts: Record<string, number>;
     items: Array<{
         content: string;
         status: string;