@sema-agent/core 5.2.0 → 5.3.0

package/dist/core/runner/turn-attachments.js

@@ -47,12 +47,7 @@ export function reduceToolEnd(state, details) {
                 : [];
         });
         const allDone = shaped.length > 0 && shaped.every((t) => t.status === "completed");
-        state.todo = allDone
-            ? { statusCounts: {}, items: [] }
-            : {
-                statusCounts: countStatuses(shaped),
-                items: shaped.slice(0, PROJECTION_ITEMS_MAX),
-            };
+        state.todo = allDone ? { items: [] } : { items: shaped.slice(0, PROJECTION_ITEMS_MAX) };
     }
     else if (d.type === "task") {
         const map = state.taskItems ?? (state.taskItems = new Map());
@@ -120,12 +115,6 @@ export function rebaseCadenceWindows(state, clock) {
     state.toolSearchLastUseTurn = clock;
     state.lastToolSearchReminderTurn = clock;
 }
-function countStatuses(items) {
-    const counts = {};
-    for (const t of items)
-        counts[t.status] = (counts[t.status] ?? 0) + 1;
-    return counts;
-}
 const EMPTY = Object.freeze([]);
 export function collectDueAttachments(state, inp) {
     let out;

package/dist/core/store-contracts/background-agent-store-contract.d.ts

@@ -0,0 +1,5 @@
+import { type BackgroundAgentStore } from "../background-agent-store.js";
+import { type ContractAssertionRunner } from "./contract-harness.js";
+export declare const BACKGROUND_AGENT_CONTRACT_SCOPE = "tenant-A";
+export declare function backgroundAgentStoreContract(mk: () => BackgroundAgentStore, runAssertion?: ContractAssertionRunner): Promise<void>;
+export declare function backgroundAgentStoreScopesContract(mk: () => BackgroundAgentStore, runAssertion?: ContractAssertionRunner): Promise<void>;

package/dist/core/store-contracts/background-agent-store-contract.js

@@ -0,0 +1,213 @@
+import { strict as assert } from "node:assert";
+import { STALE_RUNNING_REAP_ATTRIBUTION, } from "../background-agent-store.js";
+import { beginContract } from "./contract-harness.js";
+export const BACKGROUND_AGENT_CONTRACT_SCOPE = "tenant-A";
+function record(over = {}) {
+    return {
+        handle: "a0000000000000001",
+        scope: BACKGROUND_AGENT_CONTRACT_SCOPE,
+        owner: "task-1",
+        sessionScoped: false,
+        parentSessionId: "sess-1",
+        writerId: "writer-1",
+        spawnedAt: 1_000,
+        updatedAt: 1_000,
+        status: "running",
+        rev: 0,
+        ...over,
+    };
+}
+async function withStores(mk, fn) {
+    const live = [];
+    const make = () => {
+        const s = mk();
+        live.push(s);
+        return s;
+    };
+    try {
+        await fn(make);
+    }
+    finally {
+        for (const s of live.splice(0))
+            s.close?.();
+    }
+}
+async function held(store, handle, scope = BACKGROUND_AGENT_CONTRACT_SCOPE) {
+    const row = await store.get(handle, scope);
+    assert.notEqual(row, null, `row ${handle} should exist in scope ${scope}`);
+    return row;
+}
+export async function backgroundAgentStoreContract(mk, runAssertion) {
+    const { run: runRaw, settle } = beginContract(runAssertion);
+    const run = (name, fn) => runRaw(name, () => withStores(mk, fn));
+    const S = BACKGROUND_AGENT_CONTRACT_SCOPE;
+    run("put is create-once and scope-partitioned; get round-trips the row and is null cross-scope", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", finalOutput: "result-text" }));
+        await assert.rejects(store.put(record({ handle: "a1" })), (e) => e.code === "agent_record.already_exists", "a second put under the same (handle, scope) must throw the typed already_exists error");
+        await store.put(record({ handle: "a1", scope: "tenant-B" }));
+        const row = await held(store, "a1");
+        assert.equal(row.finalOutput, "result-text");
+        assert.equal(row.owner, "task-1");
+        assert.equal(await store.get("a1", "tenant-C"), null, "an unrelated scope must not see the row");
+        assert.equal(await store.get("a-missing", S), null);
+    });
+    run("put refuses a scopeless row (a row with no tenant partition would be world-readable)", async (make) => {
+        const store = make();
+        await assert.rejects(store.put(record({ scope: "" })), "an empty scope must be refused loudly, not stored");
+    });
+    run("get returns DETACHED copies: mutating a read never reaches the stored row", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", usage: { totalTokens: 5 } }));
+        const first = await held(store, "a1");
+        first.status = "failed";
+        first.usage.totalTokens = 999;
+        const second = await held(store, "a1");
+        assert.equal(second.status, "running");
+        assert.equal(second.usage?.totalTokens, 5);
+    });
+    run("update is a rev-CAS: stale rev loses, wrong scope loses, the winner bumps rev by EXACTLY 1", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1" }));
+        const row = await held(store, "a1");
+        assert.equal(await store.update("a1", "tenant-B", { ...row, status: "completed" }, { rev: row.rev }), false, "wrong scope");
+        assert.equal(await store.update("a1", S, { ...row, status: "completed" }, { rev: row.rev + 5 }), false, "rev ahead");
+        assert.equal(await store.update("a-missing", S, { ...row, status: "completed" }, { rev: row.rev }), false, "missing row");
+        assert.equal(await store.update("a1", S, { ...row, status: "completed" }, { rev: row.rev }), true);
+        const after = await held(store, "a1");
+        assert.equal(after.status, "completed");
+        assert.equal(after.rev, row.rev + 1);
+        assert.equal(await store.update("a1", S, { ...row, status: "failed" }, { rev: row.rev }), false);
+        assert.equal((await held(store, "a1")).status, "completed");
+    });
+    run("update keeps the KEY authoritative: a payload naming another handle/scope cannot repartition the row", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1" }));
+        const row = await held(store, "a1");
+        assert.equal(await store.update("a1", S, { ...row, handle: "a-other", scope: "tenant-B", status: "failed" }, { rev: row.rev }), true);
+        const after = await held(store, "a1");
+        assert.equal(after.handle, "a1", "the key's handle wins over the payload's");
+        assert.equal(after.scope, S, "scope is the partition key and an update must never rewrite it");
+        assert.equal(await store.get("a-other", "tenant-B"), null, "no second row may appear");
+    });
+    run("updateIf keeps the rev guard AND adds the field guards (status / checkpoint token / claim id)", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", status: "parked", parkedCheckpointToken: "cp-1" }));
+        const row = await held(store, "a1");
+        assert.equal(await store.updateIf("a1", S, { ...row, status: "running" }, { rev: row.rev + 3 }), false, "stale rev");
+        assert.equal(await store.updateIf("a1", S, { ...row, status: "running" }, { rev: row.rev, status: "running" }), false, "status mismatch");
+        assert.equal(await store.updateIf("a1", S, { ...row, status: "running" }, { rev: row.rev, status: "parked", parkedCheckpointToken: "cp-OTHER" }), false, "checkpoint token mismatch");
+        assert.equal(await store.updateIf("a1", S, { ...row, status: "running" }, { rev: row.rev, parkedCheckpointToken: null }), false, "null must mean 'this field is absent', and it is present");
+        assert.equal(await store.updateIf("a1", S, { ...row, status: "running" }, { rev: row.rev, parkClaimId: "claim-1" }), false, "claim id expected but absent");
+        const next = { ...row, status: "running", parkClaimId: "claim-1" };
+        assert.equal(await store.updateIf("a1", S, next, { rev: row.rev, status: "parked", parkedCheckpointToken: "cp-1", parkClaimId: null }), true, "matching guards (incl. null-as-absent on the claim id) must win");
+        const after = await held(store, "a1");
+        assert.equal(after.status, "running");
+        assert.equal(after.parkClaimId, "claim-1");
+        assert.equal(after.rev, row.rev + 1);
+    });
+    run("listBySession anchors on (sessionScoped ? owner : parentSessionId) OR rootSessionId, newest-first", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", spawnedAt: 1_000, finalOutput: "SECRET", summary: "s", error: "e", recentSteps: [] }));
+        await store.put(record({ handle: "a2", owner: "sess-1", sessionScoped: true, parentSessionId: undefined, spawnedAt: 2_000 }));
+        await store.put(record({ handle: "a3", parentSessionId: "sess-mid", rootSessionId: "sess-1", spawnedAt: 3_000 }));
+        await store.put(record({ handle: "a4", parentSessionId: "sess-other", spawnedAt: 4_000 }));
+        const rows = await store.listBySession(S, "sess-1");
+        assert.deepEqual(rows.map((r) => r.handle), ["a3", "a2", "a1"], "newest-first by spawnedAt");
+        for (const row of rows) {
+            for (const field of ["finalOutput", "summary", "error", "recentSteps", "editedFiles"]) {
+                assert.equal(Object.hasOwn(row, field), false, `list projections must not carry ${field}`);
+            }
+        }
+        assert.deepEqual((await store.listBySession(S, "sess-1", { limit: 2 })).map((r) => r.handle), ["a3", "a2"], "limit keeps the NEWEST n");
+        assert.deepEqual(await store.listBySession("tenant-B", "sess-1"), [], "another tenant sees nothing");
+        assert.deepEqual((await store.listBySession(S, "sess-mid")).map((r) => r.handle), ["a3"], "the intermediate anchor still lists its direct child");
+    });
+    run("listBySession/listByScope filter one status; listByScope enumerates the whole tenant", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", status: "running", spawnedAt: 1_000 }));
+        await store.put(record({ handle: "a2", status: "completed", spawnedAt: 2_000 }));
+        await store.put(record({ handle: "a3", status: "completed", parentSessionId: "sess-other", spawnedAt: 3_000 }));
+        await store.put(record({ handle: "a4", status: "completed", scope: "tenant-B", spawnedAt: 4_000 }));
+        assert.deepEqual((await store.listByScope(S)).map((r) => r.handle), ["a3", "a2", "a1"], "scope-wide, newest-first");
+        assert.deepEqual((await store.listByScope(S, { status: "completed" })).map((r) => r.handle), ["a3", "a2"]);
+        assert.deepEqual((await store.listByScope(S, { status: "completed", limit: 1 })).map((r) => r.handle), ["a3"]);
+        assert.deepEqual((await store.listBySession(S, "sess-1", { status: "completed" })).map((r) => r.handle), ["a2"]);
+        assert.deepEqual((await store.listByScope("tenant-B")).map((r) => r.handle), ["a4"], "tenants are separate ledgers");
+    });
+    run("delete is row-precise and CONDITIONAL when a rev is supplied (a concurrent revival must win)", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", status: "completed" }));
+        await store.put(record({ handle: "a2", status: "completed" }));
+        const row = await held(store, "a1");
+        assert.equal(await store.delete("a1", S, { rev: row.rev + 1 }), false, "a stale rev must not delete");
+        assert.notEqual(await store.get("a1", S), null);
+        assert.equal(await store.delete("a1", "tenant-B"), false, "cross-scope delete is a miss");
+        assert.equal(await store.delete("a1", S, { rev: row.rev }), true);
+        assert.equal(await store.get("a1", S), null);
+        assert.equal(await store.delete("a1", S), false, "deleting a gone row reports false, not true");
+        assert.equal(await store.delete("a2", S), true, "an unconditional delete still works");
+    });
+    run("reap with NO policy is a no-op (retention is always explicit)", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", status: "completed", settledAt: 1_000 }));
+        assert.equal(await store.reap(S, 100_000), 0);
+        assert.equal(await store.reap(S, 100_000, {}), 0);
+        assert.notEqual(await store.get("a1", S), null);
+    });
+    run("reap deletes terminal rows by age and by keep-bound; running and parked rows survive BOTH", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", status: "completed", spawnedAt: 1_000, settledAt: 1_000 }));
+        await store.put(record({ handle: "a2", status: "running", spawnedAt: 1_000, updatedAt: 1_000 }));
+        await store.put(record({ handle: "a3", status: "parked", spawnedAt: 1_000, updatedAt: 1_000, parkedCheckpointToken: "cp-1" }));
+        assert.equal(await store.reap(S, 100_000, { maxAgeMs: 10 }), 1, "only the terminal row ages out");
+        assert.equal(await store.get("a1", S), null);
+        assert.equal((await held(store, "a2")).status, "running");
+        assert.equal((await held(store, "a3")).status, "parked");
+        for (const i of [1, 2, 3])
+            await store.put(record({ handle: `b${i}`, status: "completed", spawnedAt: 1_000 + i, settledAt: 2_000 + i }));
+        assert.equal(await store.reap(S, 100_000, { keep: 2 }), 1);
+        assert.deepEqual((await store.listByScope(S, { status: "completed" })).map((r) => r.handle), ["b3", "b2"]);
+        assert.notEqual(await store.get("a2", S), null);
+        assert.notEqual(await store.get("a3", S), null);
+    });
+    run("reap's stale-running arm flips to a terminal `failed` WITH the shared attribution, and never overwrites real failure text", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", status: "running", updatedAt: 1_000 }));
+        await store.put(record({ handle: "a2", status: "running", updatedAt: 1_000, error: "the child reported a real failure" }));
+        assert.equal(await store.reap(S, 100_000, { staleRunningMaxAgeMs: 50_000 }), 2);
+        const flipped = await held(store, "a1");
+        assert.equal(flipped.status, "failed", "an interrupted host's row settles as a terminal, not a perpetual running");
+        assert.equal(flipped.stoppedBy, "system");
+        assert.equal(flipped.settledAt, 100_000);
+        assert.equal(flipped.updatedAt, 100_000);
+        assert.equal(flipped.error, STALE_RUNNING_REAP_ATTRIBUTION);
+        assert.equal(flipped.summary, STALE_RUNNING_REAP_ATTRIBUTION);
+        assert.equal((await held(store, "a2")).error, "the child reported a real failure");
+        await store.put(record({ handle: "a3", status: "running", updatedAt: 99_000 }));
+        assert.equal(await store.reap(S, 100_000, { staleRunningMaxAgeMs: 50_000 }), 0);
+        assert.equal((await held(store, "a3")).status, "running");
+    });
+    run("reap counts each ROW once even when the same sweep flips it AND removes it", async (make) => {
+        const store = make();
+        await store.put(record({ handle: "a1", status: "running", spawnedAt: 1_000, updatedAt: 1_000 }));
+        assert.equal(await store.reap(S, 100_000, { staleRunningMaxAgeMs: 50_000, keep: 0 }), 1, "one row changed, so the count is 1");
+        assert.equal(await store.get("a1", S), null, "and it really is gone (flipped, then trimmed)");
+    });
+    await settle();
+}
+export async function backgroundAgentStoreScopesContract(mk, runAssertion) {
+    const { run: runRaw, settle } = beginContract(runAssertion);
+    const run = (name, fn) => runRaw(name, () => withStores(mk, fn));
+    run("listScopes enumerates the scopes that currently HOLD rows, deduplicated and sorted", async (make) => {
+        const store = make();
+        assert.equal(typeof store.listScopes, "function", "this layer is only for backends that implement listScopes");
+        await store.put(record({ handle: "a1", scope: "tenant-B" }));
+        await store.put(record({ handle: "a2", scope: "tenant-A" }));
+        await store.put(record({ handle: "a3", scope: "tenant-A" }));
+        assert.deepEqual(await store.listScopes(), ["tenant-A", "tenant-B"], "deduplicated and sorted — a retention loop drives itself off this");
+        await store.delete("a1", "tenant-B");
+        assert.deepEqual(await store.listScopes(), ["tenant-A"]);
+    });
+    await settle();
+}

package/dist/core/task-registry-agent.d.ts

@@ -1,5 +1,5 @@
 import { type BackgroundAgentRecord, type BackgroundAgentStore } from "./background-agent-store.js";
-import { type StopSource, type TaskAccess, type UnifiedTaskResult, type BackgroundAgentTaskHandle, type DurableAgentCore, type ParkedClaimTicket, type RegisterBackgroundAgentInput } from "./task-registry-shared.js";
+import { type StopSource, type TaskAccess, type TaskRetrievalStatus, type UnifiedTaskOutput, type UnifiedTaskResult, type BackgroundAgentTaskHandle, type DurableAgentCore, type ParkedClaimTicket, type RegisterBackgroundAgentInput } from "./task-registry-shared.js";
 import { type ToolResultStore } from "./tool-result-store.js";
 export declare function ensureDurableHeartbeatLane(core: DurableAgentCore): void;
 export declare function durableAgentWriteLane(handle: BackgroundAgentTaskHandle, patch: Partial<BackgroundAgentRecord>, clear?: readonly (keyof BackgroundAgentRecord)[]): void;
@@ -126,6 +126,19 @@ export declare function notFoundRunningAgentsTail(footer: {
     named: string[];
     background: string[];
 }): string;
+export interface AgentPollDetailsInput {
+    taskId: string;
+    status: UnifiedTaskOutput["status"];
+    retrievalStatus: TaskRetrievalStatus;
+    seq?: number;
+    stoppedBy?: StopSource;
+    error?: string;
+    errorCode?: string;
+    errorRetryable?: boolean;
+    resultIsPartial?: boolean;
+    completionId?: string;
+}
+export declare function buildAgentPollDetails(input: AgentPollDetailsInput): UnifiedTaskOutput;
 export declare function serveDurableAgentRowLane(row: BackgroundAgentRecord): UnifiedTaskResult;
 export declare function spillClippedAgentResult(handle: BackgroundAgentTaskHandle, full: string, clipped: string, store: ToolResultStore | undefined, sessionId: string | undefined): Promise<string>;
 export declare function pollBackgroundAgentLane(handle: BackgroundAgentTaskHandle, deadline?: number, signal?: AbortSignal, oneShot?: boolean, store?: ToolResultStore, sessionId?: string): Promise<UnifiedTaskResult>;

package/dist/core/task-registry-agent.js

@@ -1008,7 +1008,7 @@ export function notFoundRunningAgentsTail(footer) {
     return ((footer.named.length > 0 ? `. Running named agents: ${footer.named.join(", ")}` : "") +
         (footer.background.length > 0 ? `. Running background agents: ${footer.background.join(", ")}` : ""));
 }
-function buildAgentPollDetails(input) {
+export function buildAgentPollDetails(input) {
     const failed = input.status === "failed";
     return {
         task_id: input.taskId,

package/dist/core/types.d.ts

@@ -197,6 +197,19 @@ export interface McpServerSpec {
         irreversibility?: "always" | "never";
     }>;
 }
+export interface A2aServerSpec {
+    name: string;
+    url: string;
+    cardUrl?: string;
+    headers?: Record<string, string>;
+    principalHeader?: string;
+    allowSkills?: string[];
+    toolAxes?: Record<string, {
+        effect?: ToolEffect;
+        egress?: boolean;
+        irreversibility?: "always" | "never";
+    }>;
+}
 export interface McpElicitRequest {
     server: string;
     message: string;
@@ -296,6 +309,7 @@ export interface TaskSpec {
     enableFork?: boolean;
     shellGate?: "off" | "always" | "classify";
     mcp?: McpServerSpec[];
+    a2a?: A2aServerSpec[];
     skills?: SkillSpec[];
     backgroundScope?: "task" | "session";
     envFacts?: {
@@ -562,7 +576,7 @@ export type TaskEvent = ({
     reason?: string;
 } & TaskEventIdentity) | ({
     type: "steering_injected";
-    source: "deadline_nudge" | "finalize" | "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";
+    source: "deadline_nudge" | "finalize" | "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";
     preview: string;
 } & TaskEventIdentity) | ({
     type: "diagnostics";
@@ -772,7 +786,7 @@ export interface RunnerDeps {
     hooks?: import("./hooks.js").Hooks;
     allowImageUrl?: (url: string) => boolean;
     onError?: (err: unknown, context: {
-        phase: "compaction" | "prompt-cache" | "prompt-constitution" | "degraded" | "config" | "memory" | "mcp" | "interrupt-reconcile" | "suggestions" | "rewind" | "hook";
+        phase: "compaction" | "prompt-cache" | "prompt-constitution" | "degraded" | "config" | "memory" | "mcp" | "a2a" | "interrupt-reconcile" | "suggestions" | "rewind" | "hook";
         sessionId: string;
         classification?: string;
     }) => void;

package/dist/index.d.ts

@@ -40,7 +40,8 @@ export { decideAutoPromote, deriveTripwire, FROZEN_DENYLIST_FLOOR, type AutoProm
 export { runCascade, type CascadeRung, type CascadeConfig, type CascadeAttempt, type CascadeRunResult, type GateVerdict, } from "./agents/cascade.js";
 export { pgQuery, mysqlQuery, sqliteQuery } from "./tools/sql-adapters.js";
 export { materializeMcpTools, MCP_PREFIX, type MaterializedMcp, type McpServerStatus, type McpRefreshResult } from "./core/mcp.js";
-export { PROTOCOL_TABLE, MCP_NAMESPACE, protocolOf, type ProtocolNamespace, type ProtocolId } from "./core/protocol-table.js";
+export { materializeA2aTools, A2aRpcError, type MaterializedA2a, type A2aPeerStatus, type A2aRefreshResult, type A2aToolAxis } from "./core/a2a.js";
+export { PROTOCOL_TABLE, MCP_NAMESPACE, A2A_NAMESPACE, protocolOf, type ProtocolNamespace, type ProtocolId } from "./core/protocol-table.js";
 export { InMemorySessionPolicyStore, SessionPolicyError, loosenReasons, normalizeRules, stripRev, type SessionPolicyStore, type SessionPermissionRules, type StoredSessionRules, type SessionRulesRecord, type PutRulesOptions, } from "./core/session-policy-store.js";
 export { SAFETY_MERGE_CONFORMANCE_CORPUS, type SafetyMergeVector } from "./core/safety-merge-corpus.js";
 export { SAFETY_AXIS_VOCABULARY } from "./core/safety-axis-vocab.js";
@@ -163,8 +164,12 @@ export { sessionRepoContract } from "./core/store-contracts/session-repo-contrac
 export { toolResultStoreContract } from "./core/store-contracts/tool-result-store-contract.js";
 export { fileSnapshotStoreContract } from "./core/store-contracts/file-snapshot-store-contract.js";
 export { MAILBOX_CONTRACT_SCOPE, mailboxStoreContract, mailboxAckOwnershipContract, mailboxBundledOnlyContract, } from "./core/store-contracts/mailbox-store-contract.js";
-export { type BackgroundAgentStore, type BackgroundAgentRecord, type BackgroundAgentRowSummary, type BackgroundAgentUsage, canAccessAgentRecord, BackgroundAgentStoreError, InMemoryBackgroundAgentStore, reconcileParkedAgents, } from "./core/background-agent-store.js";
+export { BACKGROUND_AGENT_CONTRACT_SCOPE, backgroundAgentStoreContract, backgroundAgentStoreScopesContract, } from "./core/store-contracts/background-agent-store-contract.js";
+export { type BackgroundAgentStore, type BackgroundAgentRecord, type BackgroundAgentRowSummary, type BackgroundAgentUsage, canAccessAgentRecord, BackgroundAgentStoreError, InMemoryBackgroundAgentStore, reconcileParkedAgents, queryBackgroundAgents, type BackgroundAgentQuery, } from "./core/background-agent-store.js";
+export { serveDurableAgentRowLane, buildAgentPollDetails, type AgentPollDetailsInput, } from "./core/task-registry-agent.js";
+export type { UnifiedTaskResult } from "./core/task-registry-shared.js";
 export { FileBackgroundAgentStore, type FileBackgroundAgentStoreOptions } from "./stores/file/background-agent-store.js";
+export { A2A_TASK_STATES, type A2ATaskState, type A2ATaskStateReversal, type A2ATaskStateReversalFaithful, type A2ATaskStateReversalLossy, toA2ATaskState, fromA2ATaskState, } from "./core/a2a-task-state.js";
 export { type WorkflowJournalStore, type WorkflowJournalEntry, InMemoryWorkflowJournalStore, callKeyOrdinal, JOURNAL_OVERSIZE_ERROR_CODE, } from "./core/workflow-journal-store.js";
 export { untrustedEgressForHuman, redactHostLeaks, redactSecrets, boundedRedactedSummary } from "./core/untrusted-egress.js";
 export type { RedactionFinding, RedactionReport, RedactionConfidence } from "./core/untrusted-egress.js";
@@ -193,7 +198,7 @@ export { retryBackoffMs, parseRetryAfter } from "./brain/retry.js";
 export { type BrainTimeoutConfig } from "./brain/timeout.js";
 export { createAssistantMessageEventStream } from "./internal/llm.js";
 export type { AssistantMessage, AssistantMessageEvent, CompleteSimpleFn, Context, DocumentContent, ImageContent, Message, StopReason, StreamFn, TextContent, ThinkingContent, ToolCall, ToolResultMessage, Usage, UserMessage, } from "./internal/llm.js";
-export type { AgentDefinition, BeforeWriteHook, BeforeWriteRequest, BeforeWriteResult, HandsBandOptions, Brain, BrainStatus, BrainStatusPhase, ImageInput, McpElicitRequest, McpElicitResponse, McpServerSpec, OnElicit, Model, ModelRef, ProjectMemoryLoad, RunnerDeps, RuntimeCaps, BackgroundChildEvent, SkillManifest, SkillSpec, TaskEvent, TaskEventIdentity, ToolActivity, TaskResult, RemoteEnvFailureNote, TaskSpec, TaskStatus, TaskStream, CompactOutcome, ThinkingLevel, ToolExecuteContext, ToolReturn, ToolSpec, ToolEffect, WorkflowGovernanceBaseline, } from "./core/types.js";
+export type { AgentDefinition, BeforeWriteHook, BeforeWriteRequest, BeforeWriteResult, HandsBandOptions, Brain, BrainStatus, BrainStatusPhase, ImageInput, McpElicitRequest, McpElicitResponse, McpServerSpec, A2aServerSpec, OnElicit, Model, ModelRef, ProjectMemoryLoad, RunnerDeps, RuntimeCaps, BackgroundChildEvent, SkillManifest, SkillSpec, TaskEvent, TaskEventIdentity, ToolActivity, TaskResult, RemoteEnvFailureNote, TaskSpec, TaskStatus, TaskStream, CompactOutcome, ThinkingLevel, ToolExecuteContext, ToolReturn, ToolSpec, ToolEffect, WorkflowGovernanceBaseline, } from "./core/types.js";
 export { Type } from "typebox";
 export type { TSchema, Static } from "typebox";
 export { explainPromptAssembly, describeDefaultPack, type DefaultPackDescription, type ExplainInput } from "./prompt-assembly/explain.js";

package/dist/index.js

@@ -37,7 +37,8 @@ export { decideAutoPromote, deriveTripwire, FROZEN_DENYLIST_FLOOR, } from "./cor
 export { runCascade, } from "./agents/cascade.js";
 export { pgQuery, mysqlQuery, sqliteQuery } from "./tools/sql-adapters.js";
 export { materializeMcpTools, MCP_PREFIX } from "./core/mcp.js";
-export { PROTOCOL_TABLE, MCP_NAMESPACE, protocolOf } from "./core/protocol-table.js";
+export { materializeA2aTools, A2aRpcError } from "./core/a2a.js";
+export { PROTOCOL_TABLE, MCP_NAMESPACE, A2A_NAMESPACE, protocolOf } from "./core/protocol-table.js";
 export { InMemorySessionPolicyStore, SessionPolicyError, loosenReasons, normalizeRules, stripRev, } from "./core/session-policy-store.js";
 export { SAFETY_MERGE_CONFORMANCE_CORPUS } from "./core/safety-merge-corpus.js";
 export { SAFETY_AXIS_VOCABULARY } from "./core/safety-axis-vocab.js";
@@ -149,8 +150,11 @@ export { sessionRepoContract } from "./core/store-contracts/session-repo-contrac
 export { toolResultStoreContract } from "./core/store-contracts/tool-result-store-contract.js";
 export { fileSnapshotStoreContract } from "./core/store-contracts/file-snapshot-store-contract.js";
 export { MAILBOX_CONTRACT_SCOPE, mailboxStoreContract, mailboxAckOwnershipContract, mailboxBundledOnlyContract, } from "./core/store-contracts/mailbox-store-contract.js";
-export { canAccessAgentRecord, BackgroundAgentStoreError, InMemoryBackgroundAgentStore, reconcileParkedAgents, } from "./core/background-agent-store.js";
+export { BACKGROUND_AGENT_CONTRACT_SCOPE, backgroundAgentStoreContract, backgroundAgentStoreScopesContract, } from "./core/store-contracts/background-agent-store-contract.js";
+export { canAccessAgentRecord, BackgroundAgentStoreError, InMemoryBackgroundAgentStore, reconcileParkedAgents, queryBackgroundAgents, } from "./core/background-agent-store.js";
+export { serveDurableAgentRowLane, buildAgentPollDetails, } from "./core/task-registry-agent.js";
 export { FileBackgroundAgentStore } from "./stores/file/background-agent-store.js";
+export { A2A_TASK_STATES, toA2ATaskState, fromA2ATaskState, } from "./core/a2a-task-state.js";
 export { InMemoryWorkflowJournalStore, callKeyOrdinal, JOURNAL_OVERSIZE_ERROR_CODE, } from "./core/workflow-journal-store.js";
 export { untrustedEgressForHuman, redactHostLeaks, redactSecrets, boundedRedactedSummary } from "./core/untrusted-egress.js";
 export { MemoryRosterStore, FileRosterStore } from "./agents/roster-store.js";

package/dist/prompt-assembly/event-registry.js

@@ -5,6 +5,7 @@ export const EVENT_PROMPT_REGISTRY = new Map([
     { kind: "plan_mode", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "off", rendererRef: "turn-attachments.ts#PLAN_MODE_FULL_BODY" },
     { kind: "date_change", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "always", rendererRef: "turn-attachments.ts#renderDateChange" },
     { kind: "instructions_change", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", maxBytes: 512, defaultPolicy: "always", rendererRef: "turn-attachments.ts#collectInstructionsChange" },
+    { kind: "workflow_size_guideline_change", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "always", rendererRef: "runtask.ts#workflowSizeGuidelineChangeNotice" },
     { kind: "budget_usd", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "off", rendererRef: "turn-attachments.ts#renderBudgetUsd" },
     { kind: "background_tasks", carrier: "message.user-prefix", trust: "operator", dedupe: "replace-by-key", defaultPolicy: "off", rendererRef: "turn-attachments.ts#renderBackgroundTasks" },
     { kind: "tools_delta", carrier: "message.user-prefix", trust: "external", dedupe: "replace-by-key", defaultPolicy: "off", rendererRef: "turn-attachments.ts#renderToolsDelta" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",