@botiverse/raft-sdk 0.2.0 → 1.0.0-alpha.0

package/dist/cjs/index.cjs

@@ -4440,6 +4440,184 @@ function createAgentApiMessageClient(options) {
 	} };
 }
 //#endregion
+//#region ../shared/src/agentApiRouteMeta.ts
+const read = {
+	sideEffect: "read",
+	idempotency: "natural",
+	destructive: false,
+	audience: "both"
+};
+const naturalWrite = {
+	sideEffect: "write",
+	idempotency: "natural",
+	destructive: false,
+	audience: "both"
+};
+const keyedWrite = {
+	sideEffect: "write",
+	idempotency: "key",
+	destructive: false,
+	audience: "both"
+};
+const write = {
+	sideEffect: "write",
+	idempotency: "none",
+	destructive: false,
+	audience: "both"
+};
+const naturalDestructive = {
+	sideEffect: "write",
+	idempotency: "natural",
+	destructive: true,
+	audience: "both"
+};
+const destructive = {
+	sideEffect: "write",
+	idempotency: "none",
+	destructive: true,
+	audience: "both"
+};
+const managedNaturalWrite = {
+	sideEffect: "write",
+	idempotency: "natural",
+	destructive: false,
+	audience: "managed"
+};
+const managedWrite = {
+	sideEffect: "write",
+	idempotency: "none",
+	destructive: false,
+	audience: "managed"
+};
+const managedNaturalDestructive = {
+	sideEffect: "write",
+	idempotency: "natural",
+	destructive: true,
+	audience: "managed"
+};
+const AGENT_API_ROUTE_META = {
+	feedbackLocatorIngest: naturalWrite,
+	feedbackLocatorList: read,
+	events: {
+		sideEffect: "destructive_read",
+		idempotency: "none",
+		destructive: true,
+		audience: "both"
+	},
+	historyRead: read,
+	knowledgeGet: read,
+	knowledgeSearch: read,
+	managedMcpTools: read,
+	managedMcpCall: destructive,
+	messageSend: keyedWrite,
+	messageSendV2: keyedWrite,
+	messageResolve: read,
+	messageSearch: read,
+	messageReactionAdd: naturalWrite,
+	messageReactionRemove: naturalDestructive,
+	channelJoin: naturalWrite,
+	channelLeave: naturalDestructive,
+	channelMute: naturalWrite,
+	channelUnmute: naturalWrite,
+	channelArchive: naturalDestructive,
+	channelUnarchive: naturalWrite,
+	channelMembers: read,
+	resolveChannel: read,
+	threadUnfollow: naturalDestructive,
+	threadList: read,
+	inboxList: read,
+	agentContext: read,
+	serverInfo: read,
+	serverUpdate: naturalDestructive,
+	mentionActionsPending: read,
+	senderMentionDeliveries: read,
+	mentionActionsExecute: write,
+	taskClaim: write,
+	taskList: read,
+	taskCreate: write,
+	taskUnclaim: destructive,
+	taskAssign: naturalDestructive,
+	taskUpdateStatus: naturalDestructive,
+	taskResourceReceipt: write,
+	taskDelete: destructive,
+	taskConvert: write,
+	taskAmend: destructive,
+	taskHistory: read,
+	migrationBegin: {
+		sideEffect: "write",
+		idempotency: "none",
+		destructive: true,
+		audience: "managed"
+	},
+	migrationStatus: read,
+	migrationReady: managedNaturalWrite,
+	migrationArrived: managedNaturalWrite,
+	reminderList: read,
+	reminderCreate: managedWrite,
+	reminderCancel: naturalDestructive,
+	reminderSnooze: managedNaturalDestructive,
+	reminderUpdate: managedNaturalDestructive,
+	appSourceAck: naturalWrite,
+	reminderLog: read,
+	appConfigGet: read,
+	appConfigPatch: destructive,
+	profileShow: read,
+	profileUpdate: naturalDestructive,
+	profileAvatarUpdate: naturalDestructive,
+	integrationList: read,
+	integrationMarketplaceSearch: read,
+	integrationLogin: naturalWrite,
+	integrationAppPrepare: write,
+	integrationAppRotateSecret: destructive,
+	integrationAppTransferOwner: naturalDestructive,
+	integrationAppUpdate: naturalDestructive,
+	integrationAppManage: destructive,
+	integrationAppLogoUpdate: naturalDestructive,
+	integrationAppList: read,
+	integrationAppStatus: read,
+	actionPrepare: write,
+	attachmentUpload: write,
+	attachmentUploadCapabilities: read,
+	attachmentUploadSessionCreate: write,
+	attachmentUploadSessionComplete: naturalWrite,
+	attachmentUploadSessionCancel: naturalDestructive,
+	attachmentUploadSessionStatus: read,
+	attachmentDownload: read,
+	attachmentCommentsList: read,
+	pushWebhookStatus: {
+		sideEffect: "read",
+		idempotency: "natural",
+		destructive: false,
+		audience: "external"
+	},
+	pushWebhookRegister: {
+		sideEffect: "write",
+		idempotency: "natural",
+		destructive: true,
+		audience: "external"
+	},
+	pushWebhookDelete: {
+		sideEffect: "write",
+		idempotency: "natural",
+		destructive: true,
+		audience: "external"
+	},
+	mentionsList: read
+};
+function toAgentApiToolAnnotations(meta) {
+	return {
+		readOnlyHint: meta.sideEffect === "read",
+		destructiveHint: meta.destructive,
+		idempotentHint: meta.idempotency !== "none"
+	};
+}
+function getAgentApiRetryPolicy(meta) {
+	if (meta.sideEffect === "read") return "retry";
+	if (meta.sideEffect === "write" && meta.idempotency === "key") return "retry_when_keyed";
+	if (meta.sideEffect === "write" && meta.idempotency === "natural") return "retry";
+	return "single_attempt";
+}
+//#endregion
 //#region ../shared/src/actionCards.ts
 const uuidSchema = uuid();
 /**
@@ -4819,7 +4997,8 @@ const taskStatusSchema = _enum([
 ]);
 const agentApiEventsQuerySchema = passthroughObject({
 	since: optionalStringSchema,
-	limit: optionalStringSchema
+	limit: optionalStringSchema,
+	ack: _enum(["cursor", "immediate"]).optional()
 });
 const agentApiHistoryQuerySchema = passthroughObject({
 	channel: string().trim().min(1),
@@ -5623,15 +5802,18 @@ const agentApiEventsResponseSchema = passthroughObject({
 	pending_notice_ids: array(string()).optional(),
 	wake_reason: string().nullable().optional(),
 	has_more: boolean(),
-	inbox_hint: agentApiEventsInboxHintSchema.nullable().optional()
+	inbox_hint: agentApiEventsInboxHintSchema.nullable().optional(),
+	ack_mode: _enum(["cursor", "immediate"]).optional()
+});
+const agentApiHistoryConsumptionScopeSchema = object({
+	agent_id: string().uuid(),
+	channel_id: string().uuid(),
+	channel_type: _enum(["dm", "thread"]),
+	target: string().min(1)
 });
 const agentApiHistoryResponseSchema = passthroughObject({
-	consumption_scope: object({
-		agent_id: string().uuid(),
-		channel_id: string().uuid(),
-		channel_type: _enum(["dm", "thread"]),
-		target: string().min(1)
-	}).optional(),
+	target: string().min(1).optional(),
+	consumption_scope: agentApiHistoryConsumptionScopeSchema.optional(),
 	messages: array(agentApiMessageEnvelopeSchema),
 	has_more: boolean(),
 	has_older: boolean(),
@@ -6002,6 +6184,45 @@ const agentApiMigrationArrivedBodySchema = passthroughObject({
 });
 const agentApiMigrationResponseSchema = passthroughObject({ migration: agentApiMigrationSummarySchema });
 const agentApiMigrationStatusResponseSchema = passthroughObject({ migration: agentApiMigrationSummarySchema.nullable() });
+const agentApiPushWebhookRegisterBodySchema = object({
+	/** Public HTTPS endpoint that receives `raft-agent-inbox-notice.v1` POSTs. */
+	url: string().trim().min(1),
+	/** Receiver-owned HMAC-SHA256 secret; stored encrypted, never returned. */
+	secret: string().min(1).max(512)
+}).strict();
+const agentApiPushWebhookStatusResponseSchema = passthroughObject({
+	registered: boolean(),
+	url: nullableStringSchema,
+	enabled: boolean(),
+	disabledReason: _enum([
+		"endpoint_rejected",
+		"credential_revoked",
+		"agent_inactive"
+	]).nullable(),
+	disabledAt: nullableStringSchema,
+	lastAttemptAt: nullableStringSchema,
+	lastDeliveryAt: nullableStringSchema,
+	lastError: nullableStringSchema,
+	consecutiveFailures: number$1().int().nonnegative(),
+	nextAttemptAt: nullableStringSchema
+});
+const agentApiMentionsListQuerySchema = passthroughObject({
+	limit: optionalStringSchema,
+	before_seq: optionalStringSchema
+});
+const agentApiMentionsListResponseSchema = passthroughObject({
+	mentions: array(passthroughObject({
+		id: string(),
+		messageId: string(),
+		messageSeq: number$1(),
+		channelId: string(),
+		handleAtSendTime: nullableStringSchema.optional(),
+		source: string(),
+		confidence: unknown().optional(),
+		createdAt: string()
+	})),
+	has_more: boolean()
+});
 function route(input) {
 	return {
 		...input,
@@ -7043,6 +7264,58 @@ const agentApiContract = {
 			query: agentApiAttachmentCommentsQuerySchema
 		},
 		response: { body: agentApiAttachmentCommentsResponseSchema }
+	}),
+	pushWebhookStatus: route({
+		key: "pushWebhookStatus",
+		method: "GET",
+		path: "/push-webhook",
+		client: {
+			resource: "pushWebhook",
+			method: "status"
+		},
+		capability: "read",
+		description: "Read the bound External Agent's inbox push registration and delivery status.",
+		request: {},
+		response: { body: agentApiPushWebhookStatusResponseSchema }
+	}),
+	pushWebhookRegister: route({
+		key: "pushWebhookRegister",
+		method: "PUT",
+		path: "/push-webhook",
+		client: {
+			resource: "pushWebhook",
+			method: "register"
+		},
+		capability: "read",
+		description: "Register or replace the bound External Agent's inbox push webhook (raft-agent-inbox-notice.v1); a new registration replaces the secret and re-enables delivery.",
+		request: { body: agentApiPushWebhookRegisterBodySchema },
+		response: { body: agentApiPushWebhookStatusResponseSchema }
+	}),
+	pushWebhookDelete: route({
+		key: "pushWebhookDelete",
+		method: "DELETE",
+		path: "/push-webhook",
+		client: {
+			resource: "pushWebhook",
+			method: "unregister"
+		},
+		capability: "read",
+		description: "Remove the bound External Agent's inbox push registration.",
+		request: {},
+		response: { kind: "empty" }
+	}),
+	mentionsList: route({
+		key: "mentionsList",
+		method: "GET",
+		path: "/mentions",
+		client: {
+			resource: "mentions",
+			method: "list"
+		},
+		capability: "mentions",
+		description: "List notifiable @mentions of the bound agent, newest first.",
+		request: { query: agentApiMentionsListQuerySchema },
+		response: { body: agentApiMentionsListResponseSchema }
 	})
 };
 function getAgentApiResponseKind(response) {
@@ -7050,10 +7323,15 @@ function getAgentApiResponseKind(response) {
 }
 function parseAgentApiResponse(key, value) {
 	const response = agentApiContract[key].response;
-	if (getAgentApiResponseKind(response) === "binary") {
+	const kind = getAgentApiResponseKind(response);
+	if (kind === "binary") {
 		if (!(value instanceof Uint8Array)) throw new TypeError(`Agent API ${key} response did not contain binary bytes`);
 		return value;
 	}
+	if (kind === "empty") {
+		if (value !== null && value !== void 0) throw new TypeError(`Agent API ${key} response must be empty`);
+		return null;
+	}
 	if (!("body" in response)) throw new TypeError(`Agent API ${key} response contract is missing a JSON body schema`);
 	return response.body.parse(value);
 }
@@ -7174,6 +7452,18 @@ async function requestAgentApiRawRoute(transport, routeKey, options = {}) {
 			data: response.data
 		};
 	}
+	if (getAgentApiResponseKind(route.response) === "empty") {
+		if (response.data !== null) return failure$3(routeKey, "response_contract_mismatch", `Agent API ${route.key} response must be empty`, {
+			status: response.status,
+			response: response.data
+		});
+		return {
+			ok: true,
+			routeKey,
+			status: response.status,
+			data: null
+		};
+	}
 	if (response.data === null) return failure$3(routeKey, "empty_response", `Agent API ${route.key} returned an empty response body`, { status: response.status });
 	try {
 		return {
@@ -7429,7 +7719,8 @@ async function joinRaftChannelByTarget(client, request) {
 const sequence = number$1().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
 const requestSchema = object({
 	since: union([sequence, literal("latest")]).optional(),
-	limit: number$1().int().min(1).max(200).optional()
+	limit: number$1().int().min(1).max(200).optional(),
+	ack: literal("cursor").optional()
 }).strict();
 const metadataSchema = object({
 	seq: sequence.optional(),
@@ -7463,12 +7754,13 @@ function projectMessage(message) {
 		externalMessage: message.external_message
 	};
 }
-function failure$2(code, status) {
+function failure$2(code, status, cursorAck = false) {
+	const ackNote = cursorAck ? "The batch was not acknowledged; receiving again with the same since returns it again" : "Delivery acknowledgement may already have occurred";
 	const messages = {
-		INVALID_REQUEST: "Receive requires a nonnegative safe integer or latest cursor and an integer limit from 1 to 200.",
-		TRANSPORT_ERROR: "Event receive transport failed. Delivery acknowledgement may already have occurred; no retry was attempted.",
-		HTTP_ERROR: "Event receive returned an HTTP error. Delivery acknowledgement may already have occurred; no retry was attempted.",
-		INVALID_RESPONSE: "Event receive response did not match the SDK contract. Delivery acknowledgement may already have occurred; no retry was attempted."
+		INVALID_REQUEST: "Receive requires a nonnegative safe integer or latest cursor, an integer limit from 1 to 200, and ack omitted or \"cursor\".",
+		TRANSPORT_ERROR: `Event receive transport failed. ${ackNote}; no retry was attempted.`,
+		HTTP_ERROR: `Event receive returned an HTTP error. ${ackNote}; no retry was attempted.`,
+		INVALID_RESPONSE: `Event receive response did not match the SDK contract. ${ackNote}; no retry was attempted.`
 	};
 	return {
 		ok: false,
@@ -7483,11 +7775,13 @@ function failure$2(code, status) {
 async function receiveRaftEvents(client, request = {}) {
 	const parsed = requestSchema.safeParse(request);
 	if (!parsed.success) return failure$2("INVALID_REQUEST");
+	const cursorAck = parsed.data.ack === "cursor";
 	const result = await client.events.get({
 		...parsed.data.since === void 0 ? {} : { since: String(parsed.data.since) },
-		...parsed.data.limit === void 0 ? {} : { limit: String(parsed.data.limit) }
+		...parsed.data.limit === void 0 ? {} : { limit: String(parsed.data.limit) },
+		...cursorAck ? { ack: "cursor" } : {}
 	});
-	if (!result.ok) return failure$2(result.error.kind === "transport" ? "TRANSPORT_ERROR" : result.error.kind === "http" ? "HTTP_ERROR" : "INVALID_RESPONSE", result.status);
+	if (!result.ok) return failure$2(result.error.kind === "transport" ? "TRANSPORT_ERROR" : result.error.kind === "http" ? "HTTP_ERROR" : "INVALID_RESPONSE", result.status, cursorAck);
 	try {
 		return {
 			ok: true,
@@ -7497,206 +7791,2328 @@ async function receiveRaftEvents(client, request = {}) {
 				lastSeenSeq: sequence.nullable().parse(result.data.last_seen_seq),
 				lastSeenMessageId: result.data.last_seen_msgId,
 				hasMore: result.data.has_more,
-				replyTarget: result.data.reply_target
+				replyTarget: result.data.reply_target,
+				ackMode: result.data.ack_mode ?? null
 			}
 		};
 	} catch {
-		return failure$2("INVALID_RESPONSE", result.status);
+		return failure$2("INVALID_RESPONSE", result.status, cursorAck);
 	}
 }
 //#endregion
-//#region src/context.ts
-const projection = object({
-	agent: object({
-		id: string(),
-		name: string(),
-		displayName: string().nullable(),
-		description: string().nullable(),
-		runtime: string(),
-		external: boolean()
-	}),
-	server: object({
-		id: string(),
-		slug: string(),
-		name: string()
-	}),
-	credential: object({ capabilities: array(string()) }),
-	prompt: object({ text: string() }).nullable()
-});
-function failure$1(code, status) {
-	const messages = {
-		TRANSPORT_ERROR: "Agent context transport failed.",
-		HTTP_ERROR: "Agent context returned an HTTP error.",
-		INVALID_RESPONSE: "Agent context response did not match the SDK contract."
-	};
-	return {
-		ok: false,
-		...status === void 0 ? {} : { status },
-		error: {
-			code,
-			message: messages[code]
+//#region ../shared/src/generated/agentApiRoutes.ts
+const AGENT_API_ROUTE_MANIFEST = [
+	{
+		"key": "feedbackLocatorIngest",
+		"method": "POST",
+		"path": "/feedback-locators",
+		"fullPath": "/internal/agent-api/feedback-locators",
+		"client": {
+			"resource": "feedbackLocators",
+			"method": "create"
+		},
+		"capability": "send",
+		"description": "Validate and atomically index one locator-only feedback artifact.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
 		}
-	};
-}
-/** Internal adapter for `client.agent.context()`. Read-only; safe to retry. */
-async function getRaftContext(client) {
-	const result = await client.agent.context();
-	if (!result.ok) return failure$1(result.error.kind === "transport" ? "TRANSPORT_ERROR" : result.error.kind === "http" ? "HTTP_ERROR" : "INVALID_RESPONSE", result.status);
-	const parsed = projection.safeParse(result.data);
-	if (!parsed.success) return failure$1("INVALID_RESPONSE", result.status);
-	const { agent, server, credential, prompt } = parsed.data;
-	return {
-		ok: true,
-		status: result.status,
-		data: {
-			agent: { ...agent },
-			server: { ...server },
-			capabilities: [...credential.capabilities],
-			guide: prompt?.text ?? null
+	},
+	{
+		"key": "feedbackLocatorList",
+		"method": "GET",
+		"path": "/feedback-locators",
+		"fullPath": "/internal/agent-api/feedback-locators",
+		"client": {
+			"resource": "feedbackLocators",
+			"method": "list"
+		},
+		"capability": "read",
+		"description": "Query the locator-only feedback index without returning session or feedback content.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
 		}
-	};
-}
-//#endregion
-//#region src/manage.ts
-const AVATAR_MIME_TYPES = /* @__PURE__ */ new Set([
-	"image/jpeg",
-	"image/png",
-	"image/gif",
-	"image/webp"
-]);
-const AVATAR_MAX_BYTES = 5242880;
-const SERVER_ERROR_CODE = /^[A-Za-z0-9_.:-]{1,64}$/;
-const MESSAGES = {
-	INVALID_REQUEST: "The request did not match the Agent API contract; nothing was sent.",
-	TRANSPORT_ERROR: "The request did not reach the Raft Server.",
-	HTTP_ERROR: "The Raft Server rejected the request.",
-	INVALID_RESPONSE: "The Raft Server response did not match the Agent API contract."
-};
-function failure(code, status, errorCode) {
-	const safeErrorCode = typeof errorCode === "string" && SERVER_ERROR_CODE.test(errorCode) ? errorCode : void 0;
-	return {
-		ok: false,
-		...status === void 0 ? {} : { status },
-		error: {
-			code,
-			message: MESSAGES[code],
-			...safeErrorCode ? { errorCode: safeErrorCode } : {}
+	},
+	{
+		"key": "events",
+		"method": "GET",
+		"path": "/events",
+		"fullPath": "/internal/agent-api/events",
+		"client": {
+			"resource": "events",
+			"method": "get"
+		},
+		"capability": "read",
+		"description": "Drain pending events for the bound agent credential.",
+		"sideEffect": "destructive_read",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
 		}
-	};
-}
-/** Map a shared-client result to the SDK's body-free result. */
-function toRaftApiResult(result) {
-	if (result.ok) return {
-		ok: true,
-		status: result.status,
-		data: result.data
-	};
-	const { error } = result;
-	if (error.kind === "transport") return failure("TRANSPORT_ERROR");
-	if (error.kind === "http") return failure("HTTP_ERROR", error.status, error.errorCode);
-	return failure(error.reason === "request_contract_mismatch" || error.reason === "missing_path_param" || error.reason === "missing_route" ? "INVALID_REQUEST" : "INVALID_RESPONSE", result.status);
-}
-const AVATAR_PATH = "/internal/agent-api/profile/avatar";
-/** One multipart POST; never retried, because the upload is a write. */
-async function uploadRaftAvatar(transport, upload) {
-	if (!upload || !AVATAR_MIME_TYPES.has(upload.mimeType) || typeof upload.filename !== "string" || !upload.filename.trim()) return failure("INVALID_REQUEST");
-	const blob = upload.data instanceof Blob ? upload.data : upload.data instanceof Uint8Array ? new Blob([Uint8Array.from(upload.data)], { type: upload.mimeType }) : null;
-	if (!blob || blob.size === 0 || blob.size > AVATAR_MAX_BYTES) return failure("INVALID_REQUEST");
-	const form = new FormData();
-	form.append("avatar", blob, upload.filename);
-	await transport.beforeRequest?.({
-		method: "POST",
-		path: AVATAR_PATH
-	});
-	const headers = new Headers(transport.headers);
-	headers.delete("content-type");
-	headers.set("accept", "application/json");
-	headers.set("authorization", transport.authorization);
-	let response;
-	try {
-		response = await transport.fetch(`${transport.serverUrl}${AVATAR_PATH}`, {
-			method: "POST",
-			headers,
-			body: form
-		});
-	} catch {
-		return failure("TRANSPORT_ERROR");
-	}
-	let body = null;
-	try {
-		body = await response.json();
-	} catch {
-		body = null;
-	}
-	if (!response.ok) {
-		const errorCode = body && typeof body === "object" ? body.errorCode : void 0;
-		return failure("HTTP_ERROR", response.status, typeof errorCode === "string" ? errorCode : null);
-	}
-	try {
-		return {
-			ok: true,
-			status: response.status,
-			data: parseAgentApiResponse("profileAvatarUpdate", body)
-		};
-	} catch {
-		return failure("INVALID_RESPONSE", response.status);
-	}
-}
-/** `readApi` may retry; `writeApi` must make exactly one attempt. */
-function createRaftManageClient(readApi, writeApi, avatar) {
-	return {
-		profile: {
-			show: async (request = {}) => toRaftApiResult(await readApi.profile.show(request.target === void 0 ? {} : { target: request.target })),
-			update: async (request) => toRaftApiResult(await writeApi.profile.update(request)),
-			updateAvatar: (upload) => uploadRaftAvatar(avatar, upload)
+	},
+	{
+		"key": "historyRead",
+		"method": "GET",
+		"path": "/history",
+		"fullPath": "/internal/agent-api/history",
+		"client": {
+			"resource": "history",
+			"method": "read"
 		},
-		server: { update: async (request) => toRaftApiResult(await writeApi.server.update(request)) },
-		actions: { prepare: async (request) => toRaftApiResult(await writeApi.actions.prepare(request)) },
-		apps: {
-			getConfig: async (appId) => toRaftApiResult(await readApi.apps.getConfig({ appId })),
-			patchConfig: async (appId, patch) => toRaftApiResult(await writeApi.apps.patchConfig({ appId }, patch))
+		"capability": "read",
+		"description": "Read visible history for a channel, DM, or thread target.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
 		}
-	};
-}
-//#endregion
-//#region src/client.ts
-var RaftSdkConfigurationError = class extends Error {
-	code;
-	name = "RaftSdkConfigurationError";
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-	}
-};
-function requireServerUrl(value) {
-	const serverUrl = value.trim();
-	if (!serverUrl) throw new RaftSdkConfigurationError("MISSING_SERVER_URL", "Raft Server URL is required");
-	let parsed;
-	try {
-		parsed = new URL(serverUrl);
-	} catch {
-		throw new RaftSdkConfigurationError("INVALID_SERVER_URL", "Raft Server URL must be an absolute HTTP(S) URL");
-	}
-	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw new RaftSdkConfigurationError("INVALID_SERVER_URL", "Raft Server URL must use HTTP or HTTPS");
-	if (parsed.username || parsed.password) throw new RaftSdkConfigurationError("INVALID_SERVER_URL", "Raft Server URL must not contain credentials");
-	return serverUrl.replace(/\/+$/, "");
-}
-function requireAgentCredential(value) {
-	const credential = value.trim();
-	if (!credential) throw new RaftSdkConfigurationError("MISSING_AGENT_CREDENTIAL", "Raft Agent credential is required");
-	if (!credential.startsWith("sk_agent_") || credential.length === 9) throw new RaftSdkConfigurationError("INVALID_AGENT_CREDENTIAL", "Raft Agent credential must be a long-lived External Agent credential");
-	return credential;
-}
-/**
-* Create a typed client for the credential-derived `/internal/agent-api/*`
-* surface. The SDK does not read CLI profiles, environment variables, or the
-* host user's home directory: the caller chooses and supplies the credential.
-*/
-function createRaftClient(options) {
-	const serverUrl = requireServerUrl(options.serverUrl);
-	const auth = { authorization: `Bearer ${requireAgentCredential(options.credential)}` };
-	const messageClient = createAgentApiMessageClient({
-		baseUrl: serverUrl,
+	},
+	{
+		"key": "knowledgeGet",
+		"method": "GET",
+		"path": "/knowledge",
+		"fullPath": "/internal/agent-api/knowledge",
+		"client": {
+			"resource": "knowledge",
+			"method": "get"
+		},
+		"capability": "knowledge",
+		"description": "Fetch a Slock Manual for Agents topic from the current server.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "knowledgeSearch",
+		"method": "GET",
+		"path": "/knowledge/search",
+		"fullPath": "/internal/agent-api/knowledge/search",
+		"client": {
+			"resource": "knowledge",
+			"method": "search"
+		},
+		"capability": "knowledge",
+		"description": "Search Slock Manual for Agents topics from the current server.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "managedMcpTools",
+		"method": "GET",
+		"path": "/mcp/tools",
+		"fullPath": "/internal/agent-api/mcp/tools",
+		"client": {
+			"resource": "mcp",
+			"method": "tools"
+		},
+		"capability": "mcp",
+		"description": "Fetch the current Server-authorized managed MCP tool catalog for this Agent.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "managedMcpCall",
+		"method": "POST",
+		"path": "/mcp/call",
+		"fullPath": "/internal/agent-api/mcp/call",
+		"client": {
+			"resource": "mcp",
+			"method": "call"
+		},
+		"capability": "mcp",
+		"description": "Call an allowlisted managed MCP tool through the Server gateway.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "messageSend",
+		"method": "POST",
+		"path": "/send",
+		"fullPath": "/internal/agent-api/send",
+		"client": {
+			"resource": "messages",
+			"method": "send"
+		},
+		"capability": "send",
+		"description": "Send a message as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "key",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "messageSendV2",
+		"method": "POST",
+		"path": "/v2/send",
+		"fullPath": "/internal/agent-api/v2/send",
+		"client": {
+			"resource": "messages",
+			"method": "sendV2"
+		},
+		"capability": "send",
+		"description": "Send a message through the versioned typed-mention contract.",
+		"sideEffect": "write",
+		"idempotency": "key",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "messageResolve",
+		"method": "GET",
+		"path": "/messages/:msgId/resolve",
+		"fullPath": "/internal/agent-api/messages/:msgId/resolve",
+		"client": {
+			"resource": "messages",
+			"method": "resolve"
+		},
+		"capability": "read",
+		"description": "Resolve a message id exactly and return the canonical visible message.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "messageSearch",
+		"method": "GET",
+		"path": "/search",
+		"fullPath": "/internal/agent-api/search",
+		"client": {
+			"resource": "messages",
+			"method": "search"
+		},
+		"capability": "read",
+		"description": "Search messages visible to the bound agent credential.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "messageReactionAdd",
+		"method": "POST",
+		"path": "/messages/:msgId/reactions",
+		"fullPath": "/internal/agent-api/messages/:msgId/reactions",
+		"client": {
+			"resource": "messages",
+			"method": "addReaction"
+		},
+		"capability": "reactions",
+		"description": "Add a reaction to a visible message as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "messageReactionRemove",
+		"method": "DELETE",
+		"path": "/messages/:msgId/reactions",
+		"fullPath": "/internal/agent-api/messages/:msgId/reactions",
+		"client": {
+			"resource": "messages",
+			"method": "removeReaction"
+		},
+		"capability": "reactions",
+		"description": "Remove a reaction from a visible message as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "channelJoin",
+		"method": "POST",
+		"path": "/channels/:channelId/join",
+		"fullPath": "/internal/agent-api/channels/:channelId/join",
+		"client": {
+			"resource": "channels",
+			"method": "join"
+		},
+		"capability": "channels",
+		"description": "Join a visible public channel as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "channelLeave",
+		"method": "POST",
+		"path": "/channels/:channelId/leave",
+		"fullPath": "/internal/agent-api/channels/:channelId/leave",
+		"client": {
+			"resource": "channels",
+			"method": "leave"
+		},
+		"capability": "channels",
+		"description": "Leave a joined regular channel as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "channelMute",
+		"method": "POST",
+		"path": "/channels/:channelId/mute",
+		"fullPath": "/internal/agent-api/channels/:channelId/mute",
+		"client": {
+			"resource": "channels",
+			"method": "mute"
+		},
+		"capability": "channels",
+		"description": "Mute ordinary activity delivery for a visible regular channel as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "channelUnmute",
+		"method": "POST",
+		"path": "/channels/:channelId/unmute",
+		"fullPath": "/internal/agent-api/channels/:channelId/unmute",
+		"client": {
+			"resource": "channels",
+			"method": "unmute"
+		},
+		"capability": "channels",
+		"description": "Unmute ordinary activity delivery for a visible regular channel as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "channelArchive",
+		"method": "POST",
+		"path": "/channels/archive",
+		"fullPath": "/internal/agent-api/channels/archive",
+		"client": {
+			"resource": "channels",
+			"method": "archive"
+		},
+		"capability": "channels",
+		"description": "Archive a regular channel when the bound agent has server channel-management authority.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "channelUnarchive",
+		"method": "POST",
+		"path": "/channels/unarchive",
+		"fullPath": "/internal/agent-api/channels/unarchive",
+		"client": {
+			"resource": "channels",
+			"method": "unarchive"
+		},
+		"capability": "channels",
+		"description": "Unarchive a regular channel when the bound agent has server channel-management authority.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "channelMembers",
+		"method": "GET",
+		"path": "/channel-members",
+		"fullPath": "/internal/agent-api/channel-members",
+		"client": {
+			"resource": "channels",
+			"method": "members"
+		},
+		"capability": "channels",
+		"description": "List agents and humans in a visible channel, DM, or thread.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "resolveChannel",
+		"method": "POST",
+		"path": "/resolve-channel",
+		"fullPath": "/internal/agent-api/resolve-channel",
+		"client": {
+			"resource": "channels",
+			"method": "resolve"
+		},
+		"capability": "send",
+		"description": "Resolve a writable channel, DM, or thread target for the bound agent credential.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "threadUnfollow",
+		"method": "POST",
+		"path": "/threads/unfollow",
+		"fullPath": "/internal/agent-api/threads/unfollow",
+		"client": {
+			"resource": "threads",
+			"method": "unfollow"
+		},
+		"capability": "channels",
+		"description": "Stop ordinary delivery for a followed thread as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "threadList",
+		"method": "GET",
+		"path": "/threads",
+		"fullPath": "/internal/agent-api/threads",
+		"client": {
+			"resource": "threads",
+			"method": "list"
+		},
+		"capability": "channels",
+		"description": "List active threads the bound agent is following.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "inboxList",
+		"method": "GET",
+		"path": "/inbox/conversations",
+		"fullPath": "/internal/agent-api/inbox/conversations",
+		"client": {
+			"resource": "inbox",
+			"method": "list"
+		},
+		"capability": "read",
+		"description": "List the bound agent's durable unread conversations, newest activity first.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "agentContext",
+		"method": "GET",
+		"path": "/context",
+		"fullPath": "/internal/agent-api/context",
+		"client": {
+			"resource": "agent",
+			"method": "context"
+		},
+		"capability": "read",
+		"description": "Identity bootstrap: the bound agent's identity, server, credential capabilities, and (external agents) the rendered operating guide.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "serverInfo",
+		"method": "GET",
+		"path": "/server",
+		"fullPath": "/internal/agent-api/server",
+		"client": {
+			"resource": "server",
+			"method": "info"
+		},
+		"capability": "read",
+		"description": "List channels, agents, humans, and runtime context visible to the bound agent.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "serverUpdate",
+		"method": "PATCH",
+		"path": "/server",
+		"fullPath": "/internal/agent-api/server",
+		"client": {
+			"resource": "server",
+			"method": "update"
+		},
+		"capability": "server",
+		"description": "Update the bound agent's server profile name or member-visibility setting.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "mentionActionsPending",
+		"method": "GET",
+		"path": "/mention-actions/pending",
+		"fullPath": "/internal/agent-api/mention-actions/pending",
+		"client": {
+			"resource": "mentions",
+			"method": "pendingActions"
+		},
+		"capability": "mentions",
+		"description": "List sender-side pending mention actions for unresolved outsider mentions.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "senderMentionDeliveries",
+		"method": "GET",
+		"path": "/messages/:messageId/mention-deliveries",
+		"fullPath": "/internal/agent-api/messages/:messageId/mention-deliveries",
+		"client": {
+			"resource": "mentions",
+			"method": "senderDeliveries"
+		},
+		"capability": "mentions",
+		"description": "Per-target delivery outcome for a message the bound agent sent.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "mentionActionsExecute",
+		"method": "POST",
+		"path": "/mention-actions/execute",
+		"fullPath": "/internal/agent-api/mention-actions/execute",
+		"client": {
+			"resource": "mentions",
+			"method": "executeAction"
+		},
+		"capability": "mentions",
+		"description": "Execute sender-side mention resolution actions.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskClaim",
+		"method": "POST",
+		"path": "/tasks/claim",
+		"fullPath": "/internal/agent-api/tasks/claim",
+		"client": {
+			"resource": "tasks",
+			"method": "claim"
+		},
+		"capability": "tasks",
+		"description": "Claim one or more tasks by task number or message id.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskList",
+		"method": "GET",
+		"path": "/tasks",
+		"fullPath": "/internal/agent-api/tasks",
+		"client": {
+			"resource": "tasks",
+			"method": "list"
+		},
+		"capability": "tasks",
+		"description": "List tasks in a channel.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskCreate",
+		"method": "POST",
+		"path": "/tasks",
+		"fullPath": "/internal/agent-api/tasks",
+		"client": {
+			"resource": "tasks",
+			"method": "create"
+		},
+		"capability": "tasks",
+		"description": "Create one or more tasks in a channel.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskUnclaim",
+		"method": "POST",
+		"path": "/tasks/unclaim",
+		"fullPath": "/internal/agent-api/tasks/unclaim",
+		"client": {
+			"resource": "tasks",
+			"method": "unclaim"
+		},
+		"capability": "tasks",
+		"description": "Release a previously claimed task.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskAssign",
+		"method": "POST",
+		"path": "/tasks/assign",
+		"fullPath": "/internal/agent-api/tasks/assign",
+		"client": {
+			"resource": "tasks",
+			"method": "assign"
+		},
+		"capability": "tasks",
+		"description": "Set or clear a task's assignee (pass null to unassign).",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskUpdateStatus",
+		"method": "POST",
+		"path": "/tasks/update-status",
+		"fullPath": "/internal/agent-api/tasks/update-status",
+		"client": {
+			"resource": "tasks",
+			"method": "updateStatus"
+		},
+		"capability": "tasks",
+		"description": "Update a task status.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskResourceReceipt",
+		"method": "POST",
+		"path": "/tasks/resource-receipt",
+		"fullPath": "/internal/agent-api/tasks/resource-receipt",
+		"client": {
+			"resource": "tasks",
+			"method": "recordResourceReceipt"
+		},
+		"capability": "tasks",
+		"description": "Record the structured receipt and expiry follow-up for a resource-creating task.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskDelete",
+		"method": "POST",
+		"path": "/tasks/delete",
+		"fullPath": "/internal/agent-api/tasks/delete",
+		"client": {
+			"resource": "tasks",
+			"method": "delete"
+		},
+		"capability": "tasks",
+		"description": "Delete a task (creator or server admin).",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskConvert",
+		"method": "POST",
+		"path": "/tasks/convert",
+		"fullPath": "/internal/agent-api/tasks/convert",
+		"client": {
+			"resource": "tasks",
+			"method": "convert"
+		},
+		"capability": "tasks",
+		"description": "Convert a message into a task without claiming it.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskAmend",
+		"method": "POST",
+		"path": "/tasks/amend",
+		"fullPath": "/internal/agent-api/tasks/amend",
+		"client": {
+			"resource": "tasks",
+			"method": "amend"
+		},
+		"capability": "tasks",
+		"description": "Amend a task card with an append-only audit event.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "taskHistory",
+		"method": "GET",
+		"path": "/tasks/history",
+		"fullPath": "/internal/agent-api/tasks/history",
+		"client": {
+			"resource": "tasks",
+			"method": "history"
+		},
+		"capability": "tasks",
+		"description": "Read a task's append-only lifecycle and amendment history.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "migrationBegin",
+		"method": "POST",
+		"path": "/migrations",
+		"fullPath": "/internal/agent-api/migrations",
+		"client": {
+			"resource": "migrations",
+			"method": "begin"
+		},
+		"capability": "server",
+		"description": "Begin a migration for the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "managed",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "migrationStatus",
+		"method": "GET",
+		"path": "/migrations/current",
+		"fullPath": "/internal/agent-api/migrations/current",
+		"client": {
+			"resource": "migrations",
+			"method": "status"
+		},
+		"capability": "read",
+		"description": "Read the active migration for the bound agent credential, if any.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "migrationReady",
+		"method": "POST",
+		"path": "/migrations/ready",
+		"fullPath": "/internal/agent-api/migrations/ready",
+		"client": {
+			"resource": "migrations",
+			"method": "ready"
+		},
+		"capability": "read",
+		"description": "Mark the bound agent's active migration prep phase ready.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "managed",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "migrationArrived",
+		"method": "POST",
+		"path": "/migrations/arrived",
+		"fullPath": "/internal/agent-api/migrations/arrived",
+		"client": {
+			"resource": "migrations",
+			"method": "arrived"
+		},
+		"capability": "read",
+		"description": "Mark the bound agent's active migration arrival phase complete.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "managed",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "reminderList",
+		"method": "GET",
+		"path": "/reminders",
+		"fullPath": "/internal/agent-api/reminders",
+		"client": {
+			"resource": "reminders",
+			"method": "list"
+		},
+		"capability": "read",
+		"description": "List reminders owned by the bound agent credential.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "reminderCreate",
+		"method": "POST",
+		"path": "/reminders",
+		"fullPath": "/internal/agent-api/reminders",
+		"client": {
+			"resource": "reminders",
+			"method": "create"
+		},
+		"capability": "tasks",
+		"description": "Create a reminder owned by the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "managed",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "reminderCancel",
+		"method": "DELETE",
+		"path": "/reminders/:reminderId",
+		"fullPath": "/internal/agent-api/reminders/:reminderId",
+		"client": {
+			"resource": "reminders",
+			"method": "cancel"
+		},
+		"capability": "tasks",
+		"description": "Cancel a scheduled or fired reminder owned by the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "reminderSnooze",
+		"method": "POST",
+		"path": "/reminders/:reminderId/snooze",
+		"fullPath": "/internal/agent-api/reminders/:reminderId/snooze",
+		"client": {
+			"resource": "reminders",
+			"method": "snooze"
+		},
+		"capability": "tasks",
+		"description": "Snooze a scheduled or fired reminder owned by the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "managed",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "reminderUpdate",
+		"method": "PATCH",
+		"path": "/reminders/:reminderId",
+		"fullPath": "/internal/agent-api/reminders/:reminderId",
+		"client": {
+			"resource": "reminders",
+			"method": "update"
+		},
+		"capability": "tasks",
+		"description": "Update a scheduled reminder owned by the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "managed",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "appSourceAck",
+		"method": "POST",
+		"path": "/app-sources/ack",
+		"fullPath": "/internal/agent-api/app-sources/ack",
+		"client": {
+			"resource": "appSources",
+			"method": "ack"
+		},
+		"capability": "tasks",
+		"description": "Authorize and acknowledge one exact app-source Inbox item revision.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "reminderLog",
+		"method": "GET",
+		"path": "/reminders/:reminderId/log",
+		"fullPath": "/internal/agent-api/reminders/:reminderId/log",
+		"client": {
+			"resource": "reminders",
+			"method": "log"
+		},
+		"capability": "read",
+		"description": "Read lifecycle events for a reminder owned by the bound agent credential.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "appConfigGet",
+		"method": "GET",
+		"path": "/apps/:appId/config",
+		"fullPath": "/internal/agent-api/apps/:appId/config",
+		"client": {
+			"resource": "apps",
+			"method": "getConfig"
+		},
+		"capability": "read",
+		"description": "Read effective durable configuration for a built-in RAP App owned by the bound agent.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "appConfigPatch",
+		"method": "PATCH",
+		"path": "/apps/:appId/config",
+		"fullPath": "/internal/agent-api/apps/:appId/config",
+		"client": {
+			"resource": "apps",
+			"method": "patchConfig"
+		},
+		"capability": "tasks",
+		"description": "Atomically update durable configuration for a built-in RAP App owned by the bound agent.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "profileShow",
+		"method": "GET",
+		"path": "/profile",
+		"fullPath": "/internal/agent-api/profile",
+		"client": {
+			"resource": "profile",
+			"method": "show"
+		},
+		"capability": "read",
+		"description": "Show the bound agent profile, or another visible profile when target is provided.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "profileUpdate",
+		"method": "POST",
+		"path": "/profile",
+		"fullPath": "/internal/agent-api/profile",
+		"client": {
+			"resource": "profile",
+			"method": "update"
+		},
+		"capability": "send",
+		"description": "Update the bound agent profile metadata.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "profileAvatarUpdate",
+		"method": "POST",
+		"path": "/profile/avatar",
+		"fullPath": "/internal/agent-api/profile/avatar",
+		"client": {
+			"resource": "profile",
+			"method": "updateAvatar"
+		},
+		"capability": "send",
+		"description": "Update the bound agent profile avatar using multipart form data.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationList",
+		"method": "GET",
+		"path": "/integrations",
+		"fullPath": "/internal/agent-api/integrations",
+		"client": {
+			"resource": "integrations",
+			"method": "list"
+		},
+		"capability": "read",
+		"description": "List available integration services and active agent logins.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationMarketplaceSearch",
+		"method": "GET",
+		"path": "/integrations/marketplace",
+		"fullPath": "/internal/agent-api/integrations/marketplace",
+		"client": {
+			"resource": "integrations",
+			"method": "marketplace"
+		},
+		"capability": "read",
+		"description": "Search or list public Marketplace apps without changing the installed integration inventory.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationLogin",
+		"method": "POST",
+		"path": "/integrations/login",
+		"fullPath": "/internal/agent-api/integrations/login",
+		"client": {
+			"resource": "integrations",
+			"method": "login"
+		},
+		"capability": "read",
+		"description": "Provision or reuse this agent's login for a registered integration service.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationAppPrepare",
+		"method": "POST",
+		"path": "/integrations/app/prepare",
+		"fullPath": "/internal/agent-api/integrations/app/prepare",
+		"client": {
+			"resource": "integrations",
+			"method": "prepareApp"
+		},
+		"capability": "read",
+		"description": "Prepare a third-party integration registration/update action card.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationAppRotateSecret",
+		"method": "POST",
+		"path": "/integrations/app/rotate-secret",
+		"fullPath": "/internal/agent-api/integrations/app/rotate-secret",
+		"client": {
+			"resource": "integrations",
+			"method": "rotateAppSecret"
+		},
+		"capability": "read",
+		"description": "Regenerate the one-time client secret for a source-owned integration app as its owner, delegated rotate maintainer, or a current server admin; invalidates the previous secret.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationAppTransferOwner",
+		"method": "POST",
+		"path": "/integrations/app/transfer-owner",
+		"fullPath": "/internal/agent-api/integrations/app/transfer-owner",
+		"client": {
+			"resource": "integrations",
+			"method": "transferAppOwner"
+		},
+		"capability": "read",
+		"description": "Transfer a source-owned integration app to another same-server agent as its owner or a current server admin.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationAppUpdate",
+		"method": "POST",
+		"path": "/integrations/app/update",
+		"fullPath": "/internal/agent-api/integrations/app/update",
+		"client": {
+			"resource": "integrations",
+			"method": "updateApp"
+		},
+		"capability": "read",
+		"description": "Update a source-owned integration app. The current app owner or a current server admin may update it.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationAppManage",
+		"method": "POST",
+		"path": "/integrations/app/manage",
+		"fullPath": "/internal/agent-api/integrations/app/manage",
+		"client": {
+			"resource": "integrations",
+			"method": "manageApp"
+		},
+		"capability": "read",
+		"description": "Manage source-owned app distribution, logo reset, Marketplace requests, or deletion as the app owner or a current server admin.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationAppLogoUpdate",
+		"method": "POST",
+		"path": "/integrations/app/logo",
+		"fullPath": "/internal/agent-api/integrations/app/logo",
+		"client": {
+			"resource": "integrations",
+			"method": "updateAppLogo"
+		},
+		"capability": "read",
+		"description": "Upload a source-owned app logo as the app owner or a current server admin using multipart form data.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationAppList",
+		"method": "GET",
+		"path": "/integrations/app",
+		"fullPath": "/internal/agent-api/integrations/app",
+		"client": {
+			"resource": "integrations",
+			"method": "listApps"
+		},
+		"capability": "read",
+		"description": "List pending app registration cards requested by this agent and manageable source-owned apps; current server admins see every source-owned app in the server.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "integrationAppStatus",
+		"method": "GET",
+		"path": "/integrations/app/status",
+		"fullPath": "/internal/agent-api/integrations/app/status",
+		"client": {
+			"resource": "integrations",
+			"method": "getAppStatus"
+		},
+		"capability": "read",
+		"description": "Get one requester-visible registration card or manageable source-owned app without disclosing unauthorized app existence.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "actionPrepare",
+		"method": "POST",
+		"path": "/prepare-action",
+		"fullPath": "/internal/agent-api/prepare-action",
+		"client": {
+			"resource": "actions",
+			"method": "prepare"
+		},
+		"capability": "tasks",
+		"description": "Prepare an action card for a human to commit.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "attachmentUpload",
+		"method": "POST",
+		"path": "/upload",
+		"fullPath": "/internal/agent-api/upload",
+		"client": {
+			"resource": "attachments",
+			"method": "upload"
+		},
+		"capability": "send",
+		"description": "Upload a multipart attachment as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "attachmentUploadCapabilities",
+		"method": "GET",
+		"path": "/attachment-upload-capabilities",
+		"fullPath": "/internal/agent-api/attachment-upload-capabilities",
+		"client": {
+			"resource": "attachments",
+			"method": "uploadCapabilities"
+		},
+		"capability": "send",
+		"description": "Read the server-authoritative direct-upload threshold and plan file limit.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "attachmentUploadSessionCreate",
+		"method": "POST",
+		"path": "/attachment-upload-sessions",
+		"fullPath": "/internal/agent-api/attachment-upload-sessions",
+		"client": {
+			"resource": "attachments",
+			"method": "createUploadSession"
+		},
+		"capability": "send",
+		"description": "Create a direct attachment upload session as the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "none",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "attachmentUploadSessionComplete",
+		"method": "POST",
+		"path": "/attachment-upload-sessions/:uploadId/complete",
+		"fullPath": "/internal/agent-api/attachment-upload-sessions/:uploadId/complete",
+		"client": {
+			"resource": "attachments",
+			"method": "completeUploadSession"
+		},
+		"capability": "send",
+		"description": "Verify and complete a direct attachment upload owned by the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "attachmentUploadSessionCancel",
+		"method": "DELETE",
+		"path": "/attachment-upload-sessions/:uploadId",
+		"fullPath": "/internal/agent-api/attachment-upload-sessions/:uploadId",
+		"client": {
+			"resource": "attachments",
+			"method": "cancelUploadSession"
+		},
+		"capability": "send",
+		"description": "Cancel a direct attachment upload owned by the bound agent credential.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "attachmentUploadSessionStatus",
+		"method": "GET",
+		"path": "/attachment-upload-sessions/:uploadId",
+		"fullPath": "/internal/agent-api/attachment-upload-sessions/:uploadId",
+		"client": {
+			"resource": "attachments",
+			"method": "uploadSessionStatus"
+		},
+		"capability": "send",
+		"description": "Read a direct attachment upload session owned by the bound agent credential.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "attachmentDownload",
+		"method": "GET",
+		"path": "/attachments/:attachmentId",
+		"fullPath": "/internal/agent-api/attachments/:attachmentId",
+		"client": {
+			"resource": "attachments",
+			"method": "download"
+		},
+		"capability": "read",
+		"description": "Download attachment bytes visible to the bound agent credential.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "binary",
+			"body": false
+		}
+	},
+	{
+		"key": "attachmentCommentsList",
+		"method": "GET",
+		"path": "/attachments/:attachmentId/comments",
+		"fullPath": "/internal/agent-api/attachments/:attachmentId/comments",
+		"client": {
+			"resource": "attachments",
+			"method": "comments"
+		},
+		"capability": "read",
+		"description": "List comments scoped to an attachment visible to the bound agent credential.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": true,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "pushWebhookStatus",
+		"method": "GET",
+		"path": "/push-webhook",
+		"fullPath": "/internal/agent-api/push-webhook",
+		"client": {
+			"resource": "pushWebhook",
+			"method": "status"
+		},
+		"capability": "read",
+		"description": "Read the bound External Agent's inbox push registration and delivery status.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "external",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "pushWebhookRegister",
+		"method": "PUT",
+		"path": "/push-webhook",
+		"fullPath": "/internal/agent-api/push-webhook",
+		"client": {
+			"resource": "pushWebhook",
+			"method": "register"
+		},
+		"capability": "read",
+		"description": "Register or replace the bound External Agent's inbox push webhook (raft-agent-inbox-notice.v1); a new registration replaces the secret and re-enables delivery.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "external",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": true
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	},
+	{
+		"key": "pushWebhookDelete",
+		"method": "DELETE",
+		"path": "/push-webhook",
+		"fullPath": "/internal/agent-api/push-webhook",
+		"client": {
+			"resource": "pushWebhook",
+			"method": "unregister"
+		},
+		"capability": "read",
+		"description": "Remove the bound External Agent's inbox push registration.",
+		"sideEffect": "write",
+		"idempotency": "natural",
+		"destructive": true,
+		"audience": "external",
+		"request": {
+			"params": false,
+			"query": false,
+			"body": false
+		},
+		"response": {
+			"kind": "empty",
+			"body": false
+		}
+	},
+	{
+		"key": "mentionsList",
+		"method": "GET",
+		"path": "/mentions",
+		"fullPath": "/internal/agent-api/mentions",
+		"client": {
+			"resource": "mentions",
+			"method": "list"
+		},
+		"capability": "mentions",
+		"description": "List notifiable @mentions of the bound agent, newest first.",
+		"sideEffect": "read",
+		"idempotency": "natural",
+		"destructive": false,
+		"audience": "both",
+		"request": {
+			"params": false,
+			"query": true,
+			"body": false
+		},
+		"response": {
+			"kind": "json",
+			"body": true
+		}
+	}
+];
+/** Content hash of AGENT_API_ROUTE_MANIFEST; see computeAgentApiManifestVersion. */
+const AGENT_API_MANIFEST_VERSION = "337bf2c7ff90b908";
+//#endregion
+//#region src/routes.ts
+const ROUTE_INFO = Object.fromEntries(AGENT_API_ROUTE_MANIFEST.map((entry) => {
+	const meta = AGENT_API_ROUTE_META[entry.key];
+	return [entry.key, {
+		key: entry.key,
+		method: entry.method,
+		path: entry.path,
+		fullPath: entry.fullPath,
+		client: entry.client,
+		capability: entry.capability,
+		description: entry.description,
+		...meta,
+		retryPolicy: getAgentApiRetryPolicy(meta),
+		annotations: toAgentApiToolAnnotations(meta)
+	}];
+}));
+function describeRaftRoute(key) {
+	return ROUTE_INFO[key];
+}
+function listRaftRoutes() {
+	return AGENT_API_ROUTE_MANIFEST.map((entry) => ROUTE_INFO[entry.key]);
+}
+function clampAttempts(value) {
+	return Math.min(Math.max(1, Math.trunc(value ?? 1)), 5);
+}
+/**
+* Build the routes layer over two transports: a retrying one for routes the
+* contract marks retry-safe, and a single-attempt one for everything else.
+* The split is decided per route from `AGENT_API_ROUTE_META`, never by the
+* caller and never by the HTTP method.
+*/
+function createRaftRoutes(options) {
+	const base = {
+		baseUrl: options.serverUrl,
+		fetch: options.fetch,
+		headers: options.headers,
+		auth: { authorization: options.authorization },
+		throttle: { beforeRequest: options.beforeRequest }
+	};
+	const retrying = createAgentApiClient({ fetch: {
+		...base,
+		retry: { attempts: clampAttempts(options.readAttempts) }
+	} });
+	const single = createAgentApiClient({ fetch: {
+		...base,
+		retry: { attempts: 1 }
+	} });
+	const merged = {};
+	for (const route of Object.values(agentApiContract)) {
+		const key = route.key;
+		const resource = (ROUTE_INFO[key].retryPolicy === "retry" ? retrying : single)[route.client.resource];
+		merged[route.client.resource] ??= {};
+		merged[route.client.resource][route.client.method] = resource[route.client.method];
+	}
+	return {
+		...merged,
+		request: (routeKey, requestOptions) => {
+			return (ROUTE_INFO[routeKey].retryPolicy === "retry" ? retrying : single).request(routeKey, requestOptions);
+		},
+		manifestVersion: AGENT_API_MANIFEST_VERSION,
+		describe: describeRaftRoute,
+		list: listRaftRoutes
+	};
+}
+//#endregion
+//#region src/context.ts
+const projection = object({
+	agent: object({
+		id: string(),
+		name: string(),
+		displayName: string().nullable(),
+		description: string().nullable(),
+		runtime: string(),
+		external: boolean()
+	}),
+	server: object({
+		id: string(),
+		slug: string(),
+		name: string()
+	}),
+	credential: object({ capabilities: array(string()) }),
+	prompt: object({ text: string() }).nullable()
+});
+function failure$1(code, status) {
+	const messages = {
+		TRANSPORT_ERROR: "Agent context transport failed.",
+		HTTP_ERROR: "Agent context returned an HTTP error.",
+		INVALID_RESPONSE: "Agent context response did not match the SDK contract."
+	};
+	return {
+		ok: false,
+		...status === void 0 ? {} : { status },
+		error: {
+			code,
+			message: messages[code]
+		}
+	};
+}
+/** Internal adapter for `client.agent.context()`. Read-only; safe to retry. */
+async function getRaftContext(client) {
+	const result = await client.agent.context();
+	if (!result.ok) return failure$1(result.error.kind === "transport" ? "TRANSPORT_ERROR" : result.error.kind === "http" ? "HTTP_ERROR" : "INVALID_RESPONSE", result.status);
+	const parsed = projection.safeParse(result.data);
+	if (!parsed.success) return failure$1("INVALID_RESPONSE", result.status);
+	const { agent, server, credential, prompt } = parsed.data;
+	return {
+		ok: true,
+		status: result.status,
+		data: {
+			agent: { ...agent },
+			server: { ...server },
+			capabilities: [...credential.capabilities],
+			guide: prompt?.text ?? null
+		}
+	};
+}
+//#endregion
+//#region src/manage.ts
+const AVATAR_MIME_TYPES = /* @__PURE__ */ new Set([
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp"
+]);
+const AVATAR_MAX_BYTES = 5242880;
+const SERVER_ERROR_CODE$1 = /^[A-Za-z0-9_.:-]{1,64}$/;
+const MESSAGES = {
+	INVALID_REQUEST: "The request did not match the Agent API contract; nothing was sent.",
+	TRANSPORT_ERROR: "The request did not reach the Raft Server.",
+	HTTP_ERROR: "The Raft Server rejected the request.",
+	INVALID_RESPONSE: "The Raft Server response did not match the Agent API contract."
+};
+function failure(code, status, errorCode) {
+	const safeErrorCode = typeof errorCode === "string" && SERVER_ERROR_CODE$1.test(errorCode) ? errorCode : void 0;
+	return {
+		ok: false,
+		...status === void 0 ? {} : { status },
+		error: {
+			code,
+			message: MESSAGES[code],
+			...safeErrorCode ? { errorCode: safeErrorCode } : {}
+		}
+	};
+}
+/** Map a shared-client result to the SDK's body-free result. */
+function toRaftApiResult(result) {
+	if (result.ok) return {
+		ok: true,
+		status: result.status,
+		data: result.data
+	};
+	const { error } = result;
+	if (error.kind === "transport") return failure("TRANSPORT_ERROR");
+	if (error.kind === "http") return failure("HTTP_ERROR", error.status, error.errorCode);
+	return failure(error.reason === "request_contract_mismatch" || error.reason === "missing_path_param" || error.reason === "missing_route" ? "INVALID_REQUEST" : "INVALID_RESPONSE", result.status);
+}
+const AVATAR_PATH = "/internal/agent-api/profile/avatar";
+/** One multipart POST; never retried, because the upload is a write. */
+async function uploadRaftAvatar(transport, upload) {
+	if (!upload || !AVATAR_MIME_TYPES.has(upload.mimeType) || typeof upload.filename !== "string" || !upload.filename.trim()) return failure("INVALID_REQUEST");
+	const blob = upload.data instanceof Blob ? upload.data : upload.data instanceof Uint8Array ? new Blob([Uint8Array.from(upload.data)], { type: upload.mimeType }) : null;
+	if (!blob || blob.size === 0 || blob.size > AVATAR_MAX_BYTES) return failure("INVALID_REQUEST");
+	const form = new FormData();
+	form.append("avatar", blob, upload.filename);
+	await transport.beforeRequest?.({
+		method: "POST",
+		path: AVATAR_PATH
+	});
+	const headers = new Headers(transport.headers);
+	headers.delete("content-type");
+	headers.set("accept", "application/json");
+	headers.set("authorization", transport.authorization);
+	let response;
+	try {
+		response = await transport.fetch(`${transport.serverUrl}${AVATAR_PATH}`, {
+			method: "POST",
+			headers,
+			body: form
+		});
+	} catch {
+		return failure("TRANSPORT_ERROR");
+	}
+	let body = null;
+	try {
+		body = await response.json();
+	} catch {
+		body = null;
+	}
+	if (!response.ok) {
+		const errorCode = body && typeof body === "object" ? body.errorCode : void 0;
+		return failure("HTTP_ERROR", response.status, typeof errorCode === "string" ? errorCode : null);
+	}
+	try {
+		return {
+			ok: true,
+			status: response.status,
+			data: parseAgentApiResponse("profileAvatarUpdate", body)
+		};
+	} catch {
+		return failure("INVALID_RESPONSE", response.status);
+	}
+}
+/** `readApi` may retry; `writeApi` must make exactly one attempt. */
+function createRaftManageClient(readApi, writeApi, avatar) {
+	return {
+		profile: {
+			show: async (request = {}) => toRaftApiResult(await readApi.profile.show(request.target === void 0 ? {} : { target: request.target })),
+			update: async (request) => toRaftApiResult(await writeApi.profile.update(request)),
+			updateAvatar: (upload) => uploadRaftAvatar(avatar, upload)
+		},
+		server: { update: async (request) => toRaftApiResult(await writeApi.server.update(request)) },
+		actions: { prepare: async (request) => toRaftApiResult(await writeApi.actions.prepare(request)) },
+		apps: {
+			getConfig: async (appId) => toRaftApiResult(await readApi.apps.getConfig({ appId })),
+			patchConfig: async (appId, patch) => toRaftApiResult(await writeApi.apps.patchConfig({ appId }, patch))
+		}
+	};
+}
+//#endregion
+//#region src/client.ts
+var RaftSdkConfigurationError = class extends Error {
+	code;
+	name = "RaftSdkConfigurationError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function requireServerUrl(value) {
+	const serverUrl = value.trim();
+	if (!serverUrl) throw new RaftSdkConfigurationError("MISSING_SERVER_URL", "Raft Server URL is required");
+	let parsed;
+	try {
+		parsed = new URL(serverUrl);
+	} catch {
+		throw new RaftSdkConfigurationError("INVALID_SERVER_URL", "Raft Server URL must be an absolute HTTP(S) URL");
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw new RaftSdkConfigurationError("INVALID_SERVER_URL", "Raft Server URL must use HTTP or HTTPS");
+	if (parsed.username || parsed.password) throw new RaftSdkConfigurationError("INVALID_SERVER_URL", "Raft Server URL must not contain credentials");
+	return serverUrl.replace(/\/+$/, "");
+}
+function requireAgentCredential(value) {
+	const credential = value.trim();
+	if (!credential) throw new RaftSdkConfigurationError("MISSING_AGENT_CREDENTIAL", "Raft Agent credential is required");
+	if (!credential.startsWith("sk_agent_") || credential.length === 9) throw new RaftSdkConfigurationError("INVALID_AGENT_CREDENTIAL", "Raft Agent credential must be a long-lived External Agent credential");
+	return credential;
+}
+/**
+* Create a typed client for the credential-derived `/internal/agent-api/*`
+* surface. The SDK does not read CLI profiles, environment variables, or the
+* host user's home directory: the caller chooses and supplies the credential.
+*/
+function createRaftClient(options) {
+	const serverUrl = requireServerUrl(options.serverUrl);
+	const auth = { authorization: `Bearer ${requireAgentCredential(options.credential)}` };
+	const messageClient = createAgentApiMessageClient({
+		baseUrl: serverUrl,
 		fetch: options.fetch,
 		headers: options.headers,
 		retry: options.retry,
@@ -7732,255 +10148,1691 @@ function createRaftClient(options) {
 		auth
 	} });
 	return {
-		...messageClient,
-		...createRaftManageClient(agentApi, writeApi, {
-			serverUrl,
-			fetch: options.fetch ?? fetch,
-			headers: Object.fromEntries(new Headers(options.headers)),
-			authorization: auth.authorization,
-			beforeRequest: options.throttle?.beforeRequest
-		}),
-		events: { receive: (request) => receiveRaftEvents(eventsApi, request) },
-		channels: { join: (request) => joinRaftChannelByTarget(agentApi, request) },
-		agent: { context: () => getRaftContext(agentApi) }
+		...messageClient,
+		...createRaftManageClient(agentApi, writeApi, {
+			serverUrl,
+			fetch: options.fetch ?? fetch,
+			headers: Object.fromEntries(new Headers(options.headers)),
+			authorization: auth.authorization,
+			beforeRequest: options.throttle?.beforeRequest
+		}),
+		events: { receive: (request) => receiveRaftEvents(eventsApi, request) },
+		channels: { join: (request) => joinRaftChannelByTarget(agentApi, request) },
+		routes: createRaftRoutes({
+			serverUrl,
+			fetch: options.fetch,
+			headers: options.headers,
+			authorization: auth.authorization,
+			readAttempts: options.retry?.attempts,
+			beforeRequest: options.throttle?.beforeRequest
+		}),
+		agent: { context: () => getRaftContext(agentApi) }
+	};
+}
+//#endregion
+//#region ../shared/src/clock.ts
+function currentTimeMs() {
+	return Date.now();
+}
+function currentDate() {
+	return new Date(currentTimeMs());
+}
+//#endregion
+//#region src/credential.ts
+var RaftCredentialError = class extends Error {
+	code;
+	name = "RaftCredentialError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function parseIdentityResponse(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const input = value;
+	if (!isNonEmptyString(input.agentId) || !isNonEmptyString(input.agentName) || input.agentDisplayName !== null && typeof input.agentDisplayName !== "string" || !isNonEmptyString(input.serverId) || !isNonEmptyString(input.credentialId) || !Array.isArray(input.scopes) || !input.scopes.every(isNonEmptyString)) return null;
+	return {
+		agentId: input.agentId,
+		agentName: input.agentName,
+		agentDisplayName: input.agentDisplayName,
+		serverId: input.serverId,
+		credentialId: input.credentialId,
+		scopes: [...input.scopes]
+	};
+}
+function parseStoredRaftCredential(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const input = value;
+	if (input.schemaVersion !== 1 || !isNonEmptyString(input.serverUrl) || !isNonEmptyString(input.credential) || !isNonEmptyString(input.storedAt)) return null;
+	const identity = parseIdentityResponse(input);
+	if (!identity || Number.isNaN(Date.parse(input.storedAt))) return null;
+	let serverUrl;
+	let credential;
+	try {
+		serverUrl = requireServerUrl(input.serverUrl);
+		credential = requireAgentCredential(input.credential);
+	} catch {
+		return null;
+	}
+	return {
+		schemaVersion: 1,
+		serverUrl,
+		credential,
+		storedAt: input.storedAt,
+		...identity
+	};
+}
+/**
+* Validate an existing External Agent credential against Raft, derive its
+* bound identity from the credential-authenticated `whoami` surface, and save
+* it through the caller's explicit store. This does not mint or rotate a
+* credential and never returns the credential bytes.
+*/
+async function bootstrapRaftCredential(options) {
+	const serverUrl = requireServerUrl(options.serverUrl);
+	const credential = requireAgentCredential(options.credential);
+	const httpFetch = options.fetch ?? globalThis.fetch;
+	let existing;
+	try {
+		existing = await options.store.load();
+	} catch {
+		throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The existing Agent credential could not be checked before saving");
+	}
+	if (existing) {
+		const validatedExisting = parseStoredRaftCredential(existing);
+		if (!validatedExisting) throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The existing Agent credential record is invalid");
+		existing = validatedExisting;
+		if (existing.serverUrl !== serverUrl || existing.credential !== credential) throw new RaftCredentialError("CREDENTIAL_STORE_CONFLICT", "The credential store already contains a different Raft Agent credential");
+	}
+	let response;
+	try {
+		response = await httpFetch(`${serverUrl}/internal/agent-api/`, {
+			method: "GET",
+			headers: { authorization: `Bearer ${credential}` }
+		});
+	} catch {
+		throw new RaftCredentialError("CREDENTIAL_VERIFY_FAILED", "Could not reach the Raft Server to verify the Agent credential");
+	}
+	if (!response.ok) {
+		if (response.status === 401 || response.status === 403) throw new RaftCredentialError("CREDENTIAL_REJECTED", "The Raft Server rejected the Agent credential");
+		throw new RaftCredentialError("CREDENTIAL_VERIFY_FAILED", `The Raft Server could not verify the Agent credential (status ${response.status})`);
+	}
+	let payload;
+	try {
+		payload = await response.json();
+	} catch {
+		throw new RaftCredentialError("CREDENTIAL_RESPONSE_INVALID", "The Raft Server returned an invalid Agent identity response");
+	}
+	const identity = parseIdentityResponse(payload);
+	if (!identity) throw new RaftCredentialError("CREDENTIAL_RESPONSE_INVALID", "The Raft Server returned an invalid Agent identity response");
+	if (!identity.scopes.includes("send")) throw new RaftCredentialError("CREDENTIAL_SCOPE_MISSING", "The Raft Agent credential does not include the send capability required by this SDK");
+	if (existing && (existing.serverId !== identity.serverId || existing.agentId !== identity.agentId)) throw new RaftCredentialError("CREDENTIAL_STORE_CONFLICT", "The credential store is already bound to a different Raft Agent identity");
+	if (existing) return {
+		serverUrl,
+		...identity
+	};
+	const record = {
+		schemaVersion: 1,
+		serverUrl,
+		credential,
+		storedAt: currentDate().toISOString(),
+		...identity
+	};
+	try {
+		await options.store.save(record);
+	} catch (error) {
+		if (error instanceof RaftCredentialError && error.code === "CREDENTIAL_STORE_CONFLICT") throw error;
+		throw new RaftCredentialError("CREDENTIAL_STORE_WRITE_FAILED", "The verified Agent credential could not be saved");
+	}
+	return {
+		serverUrl,
+		...identity
+	};
+}
+/** Load the caller-selected credential store and create a normal Raft client. */
+async function createRaftClientFromStore(options) {
+	let record;
+	try {
+		record = await options.store.load();
+	} catch {
+		throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The stored Agent credential could not be loaded");
+	}
+	if (!record) throw new RaftCredentialError("CREDENTIAL_NOT_FOUND", "No stored Raft Agent credential was found");
+	const validated = parseStoredRaftCredential(record);
+	if (!validated) throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The stored Agent credential is invalid");
+	if (!validated.scopes.includes("send")) throw new RaftCredentialError("CREDENTIAL_SCOPE_MISSING", "The stored Raft Agent credential does not include the send capability required by this SDK");
+	return createRaftClient({
+		serverUrl: validated.serverUrl,
+		credential: validated.credential,
+		fetch: options.fetch,
+		headers: options.headers,
+		retry: options.retry,
+		throttle: options.throttle
+	});
+}
+//#endregion
+//#region src/fileCredentialStore.ts
+const MAX_CREDENTIAL_FILE_BYTES = 65536;
+/**
+* Create a Node.js credential store at one explicit absolute path. The SDK
+* never discovers CLI profiles or a home directory. Writes use a same-directory
+* temporary file followed by atomic rename, and the final file is mode 0600.
+*/
+function createFileCredentialStore(filePath) {
+	if (!filePath.trim() || !(0, node_path.isAbsolute)(filePath)) throw new RaftSdkConfigurationError("INVALID_CREDENTIAL_PATH", "Raft credential file path must be an explicit absolute path");
+	return {
+		load: () => loadFileCredential(filePath),
+		async save(record) {
+			const validated = parseStoredRaftCredential(record);
+			if (!validated) throw new RaftCredentialError("CREDENTIAL_STORE_WRITE_FAILED", "Refusing to write an invalid Raft Agent credential record");
+			const directory = (0, node_path.dirname)(filePath);
+			const temporaryPath = `${filePath}.${process.pid}.${(0, node_crypto.randomUUID)()}.tmp`;
+			let handle;
+			try {
+				await (0, node_fs_promises.mkdir)(directory, {
+					recursive: true,
+					mode: 448
+				});
+				const existing = await loadFileCredential(filePath);
+				if (existing) {
+					assertSameCredential(existing, validated);
+					return;
+				}
+				handle = await (0, node_fs_promises.open)(temporaryPath, "wx", 384);
+				await handle.writeFile(`${JSON.stringify(validated, null, 2)}\n`, "utf8");
+				await handle.sync();
+				await (0, node_fs_promises.chmod)(temporaryPath, 384);
+				await handle.close();
+				handle = void 0;
+				try {
+					await (0, node_fs_promises.link)(temporaryPath, filePath);
+				} catch (error) {
+					if (error.code !== "EEXIST") throw error;
+					const winner = await loadFileCredential(filePath);
+					if (!winner) throw error;
+					assertSameCredential(winner, validated);
+				}
+				await (0, node_fs_promises.unlink)(temporaryPath);
+			} catch (error) {
+				if (handle) await handle.close().catch(() => void 0);
+				await (0, node_fs_promises.unlink)(temporaryPath).catch(() => void 0);
+				if (error instanceof RaftCredentialError) throw error;
+				throw new RaftCredentialError("CREDENTIAL_STORE_WRITE_FAILED", "The Raft Agent credential could not be written atomically");
+			}
+		}
+	};
+}
+async function loadFileCredential(filePath) {
+	let initialMetadata;
+	try {
+		initialMetadata = await (0, node_fs_promises.lstat)(filePath);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw fileReadError();
+	}
+	if (!initialMetadata.isFile() || initialMetadata.isSymbolicLink() || initialMetadata.size > MAX_CREDENTIAL_FILE_BYTES) throw fileReadError();
+	let parsed;
+	let handle;
+	try {
+		const noFollow = process.platform === "win32" ? 0 : node_fs.constants.O_NOFOLLOW;
+		handle = await (0, node_fs_promises.open)(filePath, node_fs.constants.O_RDONLY | noFollow);
+		const openedMetadata = await handle.stat();
+		if (!openedMetadata.isFile() || openedMetadata.size > MAX_CREDENTIAL_FILE_BYTES || initialMetadata.dev !== openedMetadata.dev || initialMetadata.ino !== openedMetadata.ino) throw fileReadError();
+		if (process.platform !== "win32" && (openedMetadata.mode & 63) !== 0) throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The Raft credential file permissions are too broad; expected mode 0600");
+		parsed = JSON.parse(await handle.readFile("utf8"));
+	} catch (error) {
+		if (error instanceof RaftCredentialError) throw error;
+		throw fileReadError();
+	} finally {
+		await handle?.close().catch(() => void 0);
+	}
+	const record = parseStoredRaftCredential(parsed);
+	if (!record) throw fileReadError();
+	return record;
+}
+function assertSameCredential(existing, candidate) {
+	if (existing.credential !== candidate.credential) throw new RaftCredentialError("CREDENTIAL_STORE_CONFLICT", "The credential store already contains a different Raft Agent credential");
+}
+function fileReadError() {
+	return new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The Raft credential file is invalid or unreadable");
+}
+//#endregion
+//#region ../shared/src/agentOps/outcome.ts
+const SERVER_ERROR_CODE = /^[A-Za-z0-9_.:-]{1,64}$/;
+const DEFAULT_MESSAGES = {
+	INVALID_REQUEST: "The request did not match the Agent API contract; nothing was sent.",
+	TRANSPORT_ERROR: "The request did not reach the Raft Server.",
+	HTTP_ERROR: "The Raft Server rejected the request.",
+	INVALID_RESPONSE: "The Raft Server response did not match the Agent API contract.",
+	CAPABILITY_NOT_AUTHORIZED: "This credential does not carry the capability this operation needs.",
+	SCOPE_DENIED: "This agent's scope set does not allow this operation.",
+	NOT_FOUND: "The target or message does not exist or is not visible to this agent.",
+	CONFLICT: "The Raft Server refused the operation because of the current state.",
+	IDEMPOTENCY_KEY_REUSED: "This idempotency key was already used for a different message.",
+	UNSUPPORTED_FOR_EXTERNAL_AGENTS: "This operation is not available to External Agents.",
+	UNAVAILABLE: "The Raft Server could not serve this operation right now."
+};
+const DEFAULT_NEXT_ACTION = {
+	INVALID_REQUEST: "Fix the request arguments; nothing was sent.",
+	TRANSPORT_ERROR: "Check connectivity to the Raft Server and retry if the operation is safe to repeat.",
+	HTTP_ERROR: "Read the Server's error code and adjust the request.",
+	INVALID_RESPONSE: "Upgrade the SDK or report the Server version; the response shape is not the one this SDK knows.",
+	CAPABILITY_NOT_AUTHORIZED: "Ask a human who can mint credentials to include the missing capability.",
+	SCOPE_DENIED: "Ask a human with editAgents authority to extend this agent's scopes.",
+	NOT_FOUND: "Check the target spelling with `raft server info --channels` or resolve the message id first.",
+	CONFLICT: "Read the current state before repeating this operation.",
+	IDEMPOTENCY_KEY_REUSED: "Use a new idempotency key for a different message, or resend the identical payload to reconcile.",
+	UNSUPPORTED_FOR_EXTERNAL_AGENTS: "Use your own runtime for this; the Server does not provide it to External Agents.",
+	UNAVAILABLE: "Retry in a moment."
+};
+const RETRYABLE = {
+	INVALID_REQUEST: false,
+	TRANSPORT_ERROR: true,
+	HTTP_ERROR: false,
+	INVALID_RESPONSE: false,
+	CAPABILITY_NOT_AUTHORIZED: false,
+	SCOPE_DENIED: false,
+	NOT_FOUND: false,
+	CONFLICT: false,
+	IDEMPOTENCY_KEY_REUSED: false,
+	UNSUPPORTED_FOR_EXTERNAL_AGENTS: false,
+	UNAVAILABLE: true
+};
+function classifyHttp(status, serverCode) {
+	const code = serverCode?.toLowerCase() ?? "";
+	if (code === "idempotency_key_reused") return "IDEMPOTENCY_KEY_REUSED";
+	if (code === "reminders_unsupported_for_external_agents") return "UNSUPPORTED_FOR_EXTERNAL_AGENTS";
+	if (code === "capability_not_authorized") return "CAPABILITY_NOT_AUTHORIZED";
+	if (code === "scope_denied") return "SCOPE_DENIED";
+	if (status === 404) return "NOT_FOUND";
+	if (status === 409) return "CONFLICT";
+	if (status === 503) return "UNAVAILABLE";
+	if (status >= 500) return "UNAVAILABLE";
+	return "HTTP_ERROR";
+}
+function opErrorFromClientError(error, status) {
+	if (error.kind === "transport") return {
+		code: "TRANSPORT_ERROR",
+		message: DEFAULT_MESSAGES.TRANSPORT_ERROR,
+		nextAction: DEFAULT_NEXT_ACTION.TRANSPORT_ERROR,
+		retryable: true
+	};
+	if (error.kind === "http") {
+		const serverCode = typeof error.errorCode === "string" && SERVER_ERROR_CODE.test(error.errorCode) ? error.errorCode : void 0;
+		const code = classifyHttp(error.status, serverCode);
+		const nextAction = typeof error.suggestedNextAction === "string" && error.suggestedNextAction.trim() ? error.suggestedNextAction.trim() : DEFAULT_NEXT_ACTION[code];
+		return {
+			code,
+			message: DEFAULT_MESSAGES[code],
+			status: error.status,
+			...serverCode ? { serverCode } : {},
+			nextAction,
+			retryable: RETRYABLE[code]
+		};
+	}
+	const code = error.reason === "request_contract_mismatch" || error.reason === "missing_path_param" || error.reason === "missing_route" ? "INVALID_REQUEST" : "INVALID_RESPONSE";
+	return {
+		code,
+		message: DEFAULT_MESSAGES[code],
+		...status === void 0 ? {} : { status },
+		nextAction: DEFAULT_NEXT_ACTION[code],
+		retryable: false
+	};
+}
+function opError(code, overrides = {}) {
+	return {
+		code,
+		message: DEFAULT_MESSAGES[code],
+		nextAction: DEFAULT_NEXT_ACTION[code],
+		retryable: RETRYABLE[code],
+		...overrides
 	};
 }
+/** Render an error the way an agent should read it: what failed, the code, and the next action. */
+function formatOpErrorText(error) {
+	const lines = [`Error: ${error.message}`, `Code: ${error.code}`];
+	if (error.serverCode) lines.push(`Server code: ${error.serverCode}`);
+	lines.push(`Retryable: ${error.retryable ? "yes" : "no"}`);
+	lines.push(`Next action: ${error.nextAction}`);
+	return lines.join("\n");
+}
+function failureOutcome(error) {
+	return {
+		ok: false,
+		state: "error",
+		error,
+		next: {
+			kind: "recover",
+			why: error.nextAction
+		},
+		text: formatOpErrorText(error)
+	};
+}
+/** Map a shared-client failure to a failure outcome. */
+function failureFromClientResult(result) {
+	return failureOutcome(opErrorFromClientError(result.error, result.status));
+}
 //#endregion
-//#region ../shared/src/clock.ts
-function currentTimeMs() {
-	return Date.now();
+//#region ../shared/src/agentInbox.ts
+const NON_MEMBER_MENTION_REPLY_GUIDANCE = "[Raft notice: You were notified as a non-member, so you cannot reply in that channel. If no reply is needed, no action is required. Otherwise, DM the person who mentioned you or join the channel to participate.]";
+function projectAgentReplyAffordance(facts) {
+	if (facts.non_member_mention !== true) return null;
+	return {
+		kind: "non_member_mention",
+		guidance: NON_MEMBER_MENTION_REPLY_GUIDANCE
+	};
 }
-function currentDate() {
-	return new Date(currentTimeMs());
+function formatAgentReplyAffordance(facts) {
+	return projectAgentReplyAffordance(facts)?.guidance ?? "";
+}
+function formatAgentReplyAffordanceSuffix(facts) {
+	const guidance = formatAgentReplyAffordance(facts);
+	return guidance ? `\n${guidance}` : "";
+}
+//#endregion
+//#region ../shared/src/raftRefs.ts
+const RAFT_REF_CHANNEL_NAME_PATTERN = String.raw`[\p{L}\p{N}_-]+`;
+const RAFT_REF_USER_NAME_PATTERN = RAFT_REF_CHANNEL_NAME_PATTERN;
+const RAFT_REF_DM_PEER_PATTERN = String.raw`[\w.-]+(?:~(?:agent|human))?(?![\w.~-])`;
+const RAFT_REF_THREAD_SHORT_ID_PATTERN = String.raw`[\da-f]{6,8}`;
+const RAFT_REF_MESSAGE_ID_PATTERN = String.raw`[A-Za-z0-9][A-Za-z0-9-]{1,63}`;
+const RAFT_REF_TASK_NUMBER_PATTERN = String.raw`[1-9]\d*`;
+const RAFT_REF_COMPUTER_ID_PATTERN = String.raw`[\da-f]{8}-[\da-f]{4}-[1-5][\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}`;
+const RAFT_REF_APP_ID_PATTERN = String.raw`[a-z][a-z0-9]*(?:\.[a-z][a-z0-9]*)+`;
+function createRaftUserRefRegex() {
+	return new RegExp(`(^|[^\\p{L}\\p{N}_-])@(${RAFT_REF_USER_NAME_PATTERN})`, "gu");
+}
+function createRaftChannelThreadRefRegex() {
+	return new RegExp(`#(${RAFT_REF_CHANNEL_NAME_PATTERN}):(${RAFT_REF_THREAD_SHORT_ID_PATTERN})`, "giu");
+}
+function createRaftChannelRefRegex() {
+	return new RegExp(`#(${RAFT_REF_CHANNEL_NAME_PATTERN})`, "gu");
+}
+function createRaftDmThreadRefRegex() {
+	return new RegExp(`dm:@(${RAFT_REF_DM_PEER_PATTERN}):(${RAFT_REF_THREAD_SHORT_ID_PATTERN})`, "giu");
+}
+function createRaftDmRefRegex() {
+	return new RegExp(`dm:@(${RAFT_REF_DM_PEER_PATTERN})`, "giu");
+}
+/**
+* A `dm:@name~<suffix>` token whose suffix is not a known peer kind
+* (`~bot`, `~agentXYZ`, a bare `~`). Renderers claim it as plain text so it
+* never degrades into a link to a different target (`dm:@name` or `@name`).
+* Run after the valid DM passes; it also matches valid refs.
+*/
+function createRaftMalformedDmKindRefRegex() {
+	return new RegExp(String.raw`dm:@[\w.-]+~[\w.~-]*(?::${RAFT_REF_THREAD_SHORT_ID_PATTERN})?`, "giu");
+}
+function createRaftMessageRefRegex() {
+	return new RegExp(`#(${RAFT_REF_CHANNEL_NAME_PATTERN})(?::(${RAFT_REF_THREAD_SHORT_ID_PATTERN}))?\\s+msg=(${RAFT_REF_MESSAGE_ID_PATTERN})`, "giu");
+}
+function createRaftBareTaskRefRegex() {
+	return new RegExp(`(^|[^\\w/])(?:(task\\s+))?#(${RAFT_REF_TASK_NUMBER_PATTERN})\\b`, "giu");
+}
+const USER_RE = new RegExp(String.raw`^@(${RAFT_REF_USER_NAME_PATTERN})$`, "u");
+const COMPUTER_RE = new RegExp(String.raw`^computer:(${RAFT_REF_COMPUTER_ID_PATTERN})$`, "iu");
+const APP_RE = new RegExp(String.raw`^app:(${RAFT_REF_APP_ID_PATTERN})$`, "u");
+const CHANNEL_RE = new RegExp(String.raw`^#(${RAFT_REF_CHANNEL_NAME_PATTERN})$`, "u");
+const CHANNEL_THREAD_RE = new RegExp(String.raw`^#(${RAFT_REF_CHANNEL_NAME_PATTERN}):(${RAFT_REF_THREAD_SHORT_ID_PATTERN})$`, "iu");
+const DM_RE = new RegExp(String.raw`^dm:@(${RAFT_REF_DM_PEER_PATTERN})$`, "iu");
+const DM_THREAD_RE = new RegExp(String.raw`^dm:@(${RAFT_REF_DM_PEER_PATTERN}):(${RAFT_REF_THREAD_SHORT_ID_PATTERN})$`, "iu");
+const TASK_RE = new RegExp(String.raw`^task\s+#(${RAFT_REF_TASK_NUMBER_PATTERN})$`, "iu");
+const CHANNEL_MESSAGE_RE = new RegExp(String.raw`^#(${RAFT_REF_CHANNEL_NAME_PATTERN})(?::(${RAFT_REF_THREAD_SHORT_ID_PATTERN}))?\s+msg=(${RAFT_REF_MESSAGE_ID_PATTERN})$`, "iu");
+const DM_MESSAGE_RE = new RegExp(String.raw`^dm:@(${RAFT_REF_DM_PEER_PATTERN})(?::(${RAFT_REF_THREAD_SHORT_ID_PATTERN}))?\s+msg=(${RAFT_REF_MESSAGE_ID_PATTERN})$`, "iu");
+function parseRaftRefTarget(rawTarget) {
+	const target = rawTarget.trim();
+	if (!target) return null;
+	const channelMessage = CHANNEL_MESSAGE_RE.exec(target);
+	if (channelMessage) return {
+		kind: "message",
+		channelName: channelMessage[1],
+		threadParentShortId: channelMessage[2] ?? null,
+		messageId: channelMessage[3]
+	};
+	const dmMessage = DM_MESSAGE_RE.exec(target);
+	if (dmMessage) return {
+		kind: "dm-message",
+		peerName: dmMessage[1],
+		threadParentShortId: dmMessage[2] ?? null,
+		messageId: dmMessage[3]
+	};
+	const channelThread = CHANNEL_THREAD_RE.exec(target);
+	if (channelThread) return {
+		kind: "channel-thread",
+		channelName: channelThread[1],
+		threadShortId: channelThread[2]
+	};
+	const dmThread = DM_THREAD_RE.exec(target);
+	if (dmThread) return {
+		kind: "dm-thread",
+		peerName: dmThread[1],
+		threadShortId: dmThread[2]
+	};
+	const task = TASK_RE.exec(target);
+	if (task) return {
+		kind: "task",
+		taskNumber: Number(task[1])
+	};
+	const computer = COMPUTER_RE.exec(target);
+	if (computer) return {
+		kind: "computer",
+		machineId: computer[1].toLowerCase()
+	};
+	const app = APP_RE.exec(target);
+	if (app) return {
+		kind: "app",
+		appId: app[1]
+	};
+	const user = USER_RE.exec(target);
+	if (user) return {
+		kind: "user",
+		name: user[1]
+	};
+	const channel = CHANNEL_RE.exec(target);
+	if (channel) return {
+		kind: "channel",
+		channelName: channel[1]
+	};
+	const dm = DM_RE.exec(target);
+	if (dm) return {
+		kind: "dm",
+		peerName: dm[1]
+	};
+	return null;
+}
+function formatRaftRefTarget(target) {
+	switch (target.kind) {
+		case "user": return `@${target.name}`;
+		case "computer": return `computer:${target.machineId}`;
+		case "app": return `app:${target.appId}`;
+		case "channel": return `#${target.channelName}`;
+		case "channel-thread": return `#${target.channelName}:${target.threadShortId}`;
+		case "dm": return `dm:@${target.peerName}`;
+		case "dm-thread": return `dm:@${target.peerName}:${target.threadShortId}`;
+		case "task": return `task #${target.taskNumber}`;
+		case "message": return target.threadParentShortId ? `#${target.channelName}:${target.threadParentShortId} msg=${target.messageId}` : `#${target.channelName} msg=${target.messageId}`;
+		case "dm-message": return target.threadParentShortId ? `dm:@${target.peerName}:${target.threadParentShortId} msg=${target.messageId}` : `dm:@${target.peerName} msg=${target.messageId}`;
+	}
+}
+function markdownCodeSpans(source) {
+	const spans = [];
+	for (const match of source.matchAll(/```[\s\S]*?```/g)) spans.push({
+		start: match.index ?? 0,
+		end: (match.index ?? 0) + match[0].length
+	});
+	const fences = [...spans];
+	const scanInline = (from, to) => {
+		if (from >= to) return;
+		const segment = source.slice(from, to);
+		for (const match of segment.matchAll(/``[^`]+``|`[^`]+`/g)) {
+			const start = from + (match.index ?? 0);
+			spans.push({
+				start,
+				end: start + match[0].length
+			});
+		}
+	};
+	let cursor = 0;
+	for (const fence of fences) {
+		scanInline(cursor, fence.start);
+		cursor = fence.end;
+	}
+	scanInline(cursor, source.length);
+	return spans.sort((a, b) => a.start - b.start);
+}
+function visitMarkdownProseChunks(source, visitor) {
+	const spans = markdownCodeSpans(source);
+	if (spans.length === 0) {
+		visitor(source, 0);
+		return;
+	}
+	let cursor = 0;
+	for (const span of spans) {
+		if (span.end <= cursor) continue;
+		const start = span.start > cursor ? span.start : cursor;
+		if (start > cursor) visitor(source.slice(cursor, start), cursor);
+		cursor = span.end;
+	}
+	if (cursor < source.length) visitor(source.slice(cursor), cursor);
+}
+function collectParsedRef(refs, raw, start, end, dedupe) {
+	const target = parseRaftRefTarget(raw);
+	if (!target) return;
+	const canonical = formatRaftRefTarget(target);
+	refs.set(dedupe ? canonical : `${start}:${end}:${canonical}`, {
+		raw,
+		target,
+		start,
+		end
+	});
+}
+function extractRaftRefTargetsFromChunk(chunk, chunkOffset, dedupe) {
+	const refs = /* @__PURE__ */ new Map();
+	const occupiedRanges = [];
+	function occupy(match) {
+		if (match.index === void 0) return;
+		occupiedRanges.push({
+			start: match.index,
+			end: match.index + match[0].length
+		});
+	}
+	function isInsideOccupied(match, offset = 0) {
+		if (match.index === void 0) return false;
+		const start = match.index + offset;
+		const end = start + match[0].length - offset;
+		return occupiedRanges.some((range) => start >= range.start && end <= range.end);
+	}
+	for (const match of chunk.matchAll(/\[((?:\\.|[^\]\\])*)\]\(<([^<>\n]+)>\)/g)) {
+		const target = parseRaftRefTarget(match[2] ?? "");
+		if (target?.kind === "computer" || target?.kind === "app") occupy(match);
+	}
+	for (const match of chunk.matchAll(new RegExp(String.raw`<([^<>\n]+)>`, "gu"))) {
+		const raw = match[1] ?? "";
+		const rawStart = (match.index ?? 0) + 1;
+		collectParsedRef(refs, raw, chunkOffset + rawStart, chunkOffset + rawStart + raw.length, dedupe);
+		occupy(match);
+	}
+	for (const match of chunk.matchAll(createRaftMessageRefRegex())) {
+		collectParsedRef(refs, match[2] ? `#${match[1]}:${match[2]} msg=${match[3]}` : `#${match[1]} msg=${match[3]}`, chunkOffset + (match.index ?? 0), chunkOffset + (match.index ?? 0) + match[0].length, dedupe);
+		occupy(match);
+	}
+	for (const match of chunk.matchAll(createRaftDmThreadRefRegex())) {
+		collectParsedRef(refs, `dm:@${match[1]}:${match[2]}`, chunkOffset + (match.index ?? 0), chunkOffset + (match.index ?? 0) + match[0].length, dedupe);
+		occupy(match);
+	}
+	for (const match of chunk.matchAll(createRaftDmRefRegex())) {
+		if (isInsideOccupied(match)) continue;
+		collectParsedRef(refs, `dm:@${match[1]}`, chunkOffset + (match.index ?? 0), chunkOffset + (match.index ?? 0) + match[0].length, dedupe);
+		occupy(match);
+	}
+	for (const match of chunk.matchAll(createRaftMalformedDmKindRefRegex())) if (!isInsideOccupied(match)) occupy(match);
+	for (const match of chunk.matchAll(createRaftChannelThreadRefRegex())) {
+		if (isInsideOccupied(match)) continue;
+		collectParsedRef(refs, `#${match[1]}:${match[2]}`, chunkOffset + (match.index ?? 0), chunkOffset + (match.index ?? 0) + match[0].length, dedupe);
+		occupy(match);
+	}
+	for (const match of chunk.matchAll(createRaftBareTaskRefRegex())) {
+		const raw = `task #${match[3]}`;
+		const rawStart = (match.index ?? 0) + match[1].length;
+		collectParsedRef(refs, raw, chunkOffset + rawStart, chunkOffset + rawStart + match[0].length - match[1].length, dedupe);
+		occupy(match);
+	}
+	for (const match of chunk.matchAll(createRaftUserRefRegex())) {
+		if (isInsideOccupied(match)) continue;
+		const rawStart = (match.index ?? 0) + match[1].length;
+		collectParsedRef(refs, `@${match[2]}`, chunkOffset + rawStart, chunkOffset + (match.index ?? 0) + match[0].length, dedupe);
+		occupy(match);
+	}
+	for (const match of chunk.matchAll(createRaftChannelRefRegex())) {
+		if (isInsideOccupied(match)) continue;
+		collectParsedRef(refs, `#${match[1]}`, chunkOffset + (match.index ?? 0), chunkOffset + (match.index ?? 0) + match[0].length, dedupe);
+		occupy(match);
+	}
+	return refs;
+}
+function extractRaftRefTargets(source, options = {}) {
+	const refs = /* @__PURE__ */ new Map();
+	const dedupe = options.dedupe ?? true;
+	const collectChunk = (chunk, offset) => {
+		const chunkRefs = extractRaftRefTargetsFromChunk(chunk, offset, dedupe);
+		for (const [key, value] of chunkRefs) refs.set(key, value);
+	};
+	if (options.includeMarkdownCode) collectChunk(source, 0);
+	else visitMarkdownProseChunks(source, collectChunk);
+	return [...refs.values()].sort((a, b) => a.start - b.start || a.end - b.end);
+}
+//#endregion
+//#region ../shared/src/thirdPartyInertRenderer.ts
+/**
+* Shared inert renderer for app-controlled third-party text.
+*
+* Contract:
+* - Input is app-controlled free text such as app name, developer display name,
+*   description, and declared data-access wording.
+* - Output is canonical agent-facing text. It is safe to place in marketplace,
+*   install disclosure, app metadata, and tool-result readouts.
+* - Markdown inline/fenced code is literal data; ref-shaped text inside it is
+*   never parsed or rewritten.
+* - Structured values such as normalized domains, callback URLs, categories, and
+*   closed scope enums do not belong here; those should be rendered from
+*   server-normalized values at the call site.
+*/
+function escapeAgentMarkupLiterals(value) {
+	return value.replace(/<\/?(?:result|preview|match)\b[^>]*>|<omit\s*\/>/gi, (tag) => tag.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+}
+function neutralizeRaftRefLiterals(value) {
+	const refs = extractRaftRefTargets(value, {
+		dedupe: false,
+		includeMarkdownCode: false
+	}).filter((ref) => ref.start < ref.end).sort((a, b) => a.start - b.start || b.end - a.end);
+	if (refs.length === 0) return value;
+	let output = "";
+	let cursor = 0;
+	for (let index = 0; index < refs.length;) {
+		const first = refs[index];
+		if (first.start < cursor) {
+			index++;
+			continue;
+		}
+		const cluster = [first];
+		let clusterEnd = first.end;
+		index++;
+		while (index < refs.length && refs[index].start < clusterEnd) {
+			const next = refs[index];
+			cluster.push(next);
+			clusterEnd = Math.max(clusterEnd, next.end);
+			index++;
+		}
+		output += value.slice(cursor, first.start);
+		output += cluster.map((ref) => neutralRaftRefLabel(ref.target)).join(" ");
+		cursor = clusterEnd;
+	}
+	output += value.slice(cursor);
+	return output;
+}
+function neutralRaftRefLabel(target) {
+	switch (target.kind) {
+		case "user": return `user:${target.name}`;
+		case "computer": return `computer:${target.machineId}`;
+		case "app": return `app:${target.appId}`;
+		case "channel": return `channel:${target.channelName}`;
+		case "channel-thread": return `channel:${target.channelName}:${target.threadShortId}`;
+		case "dm": return `dm:user:${target.peerName}`;
+		case "dm-thread": return `dm:user:${target.peerName}:${target.threadShortId}`;
+		case "task": return `task:${target.taskNumber}`;
+		case "message": return target.threadParentShortId ? `channel:${target.channelName}:${target.threadParentShortId} msg=${target.messageId}` : `channel:${target.channelName} msg=${target.messageId}`;
+		case "dm-message": return target.threadParentShortId ? `dm:user:${target.peerName}:${target.threadParentShortId} msg=${target.messageId}` : `dm:user:${target.peerName} msg=${target.messageId}`;
+	}
+}
+/** Render an ingress-bounded JSON payload without hiding fields from the agent. */
+function renderThirdPartyInertJson(value) {
+	return neutralizeRaftRefLiterals(escapeAgentMarkupLiterals(JSON.stringify(value, null, 2)));
+}
+//#endregion
+//#region ../shared/src/utcTimestamp.ts
+/**
+* Format an agent-facing timestamp as an explicitly-labelled UTC value.
+*
+* Keep the space separator used by existing Raft message/log output while
+* adding the `Z` suffix that makes the timezone unambiguous.
+*/
+function formatUtcTimestamp(value) {
+	const date = value instanceof Date ? value : new Date(value);
+	if (Number.isNaN(date.getTime())) return typeof value === "string" ? value : String(value);
+	return `${date.toISOString().slice(0, 19).replace("T", " ")}Z`;
+}
+//#endregion
+//#region ../shared/src/agentMessageText.ts
+/**
+* The target an agent passes back to reply where a message came from:
+* `#channel`, `#channel:shortid`, `dm:@peer`, `dm:@peer:shortid`, or
+* `agent-event:shortid` for third-party app events.
+*/
+function formatAgentMessageTarget(m) {
+	if (m.third_party_event) return `agent-event:${m.third_party_event.id.slice(0, 8)}`;
+	if (m.channel_type === "thread" && m.parent_channel_name) {
+		const shortId = m.channel_name?.startsWith("thread-") ? m.channel_name.slice(7) : m.channel_name;
+		if (m.parent_channel_type === "dm") return `dm:@${m.parent_channel_name}:${shortId}`;
+		return `#${m.parent_channel_name}:${shortId}`;
+	}
+	if (m.channel_type === "dm") return `dm:@${m.channel_name}`;
+	return `#${m.channel_name}`;
+}
+function formatAgentSenderHandle(m) {
+	const name = m.sender_name ?? "unknown";
+	const desc = m.sender_description ?? null;
+	return desc ? `@${name} — ${desc}` : `@${name}`;
+}
+function formatAgentAttachmentSuffix(attachments) {
+	if (!attachments?.length) return "";
+	return ` [${attachments.length} attachment${attachments.length > 1 ? "s" : ""}: ${attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} — use raft attachment view to download]`;
+}
+function formatAgentTaskAssigneeSuffix(assigneeId, assigneeName) {
+	if (!assigneeId) return "";
+	return assigneeName ? ` assignee=@${assigneeName}` : " assignee=<unresolved>";
+}
+/**
+* Superseded-task projection suffix. `neutralize`, when given, rewrites quoted
+* title/description/actor text so pasted refs cannot route attention (the CLI
+* passes its search-preview neutraliser); the actor handle is then `user:<name>`.
+*/
+function formatAgentTaskCurrentProjection(projection, taskNumber, neutralize) {
+	const neutralizeRefs = neutralize !== void 0;
+	const renderPreviewText = neutralize ?? ((text) => text);
+	if (!projection?.superseded) return "";
+	const revision = Number.isInteger(projection.revision) ? projection.revision : "?";
+	const source = projection.source ?? "tasks_current_projection";
+	const actorName = projection.amendedByName ?? projection.amended_by_name ?? null;
+	const actorType = projection.amendedByType ?? projection.amended_by_type ?? null;
+	const actor = actorName ? neutralizeRefs ? `user:${actorName}` : `@${actorName}` : actorType === "system" ? "system" : "<unresolved>";
+	const amendedAt = projection.amendedAt ?? projection.amended_at ?? null;
+	const lines = [`[${taskNumber ? `task #${taskNumber} ` : "task "}superseded: current projection rev=${revision} source=${source} actor=${actor} time=${amendedAt ? formatUtcTimestamp(amendedAt) : "-"}]`, `Current title: ${neutralizeRefs ? renderPreviewText(projection.title ?? "") : projection.title ?? ""}`];
+	if (projection.description != null) lines.push(`Current description: ${neutralizeRefs ? renderPreviewText(projection.description) : projection.description}`);
+	return `\n${lines.join("\n")}`;
+}
+/** One received-message line: header bracket + sender + content + suffixes. */
+function formatAgentMessageLine(m) {
+	if (m.third_party_event) {
+		const msgId = m.message_id ? m.message_id.slice(0, 8) : m.third_party_event.id.slice(0, 8);
+		const time = m.timestamp ? formatUtcTimestamp(m.timestamp) : "-";
+		const event = m.third_party_event;
+		const content = m.content ?? "";
+		const source = event.source;
+		const sourceSuffix = source?.resource ? `; resource=${source.resource}${source.access_token_id_hash ? `; access_token_id_hash=${source.access_token_id_hash}` : ""}` : "";
+		const provenance = `kind=${event.kind}; payload_hash=${event.payload_hash}${sourceSuffix}`;
+		return `[target=agent-event:${event.id.slice(0, 8)} msg=${msgId} time=${time} type=third_party_app] @${event.client_id} — ${event.client_name}: ${provenance}\n${content}${event.payload ? `\npayload:\n${renderThirdPartyInertJson(event.payload)}` : ""}`;
+	}
+	const target = formatAgentMessageTarget(m);
+	const msgId = m.message_id ? m.message_id.slice(0, 8) : "-";
+	const time = m.timestamp ? formatUtcTimestamp(m.timestamp) : "-";
+	const senderType = ` type=${m.sender_type}`;
+	const content = m.content ?? "";
+	const attachSuffix = formatAgentAttachmentSuffix(m.attachments);
+	const taskSuffix = m.task_status ? ` [task #${m.task_number} status=${m.task_status}${formatAgentTaskAssigneeSuffix(m.task_assignee_id, m.task_assignee_name)}]` : "";
+	return `[target=${target} msg=${msgId} time=${time}${senderType}] ${formatAgentSenderHandle(m)}: ${content}${attachSuffix}${taskSuffix}${formatAgentReplyAffordanceSuffix(m)}${formatAgentTaskCurrentProjection(m.task_current_projection)}`;
+}
+/** Batch of received-message lines (`raft message check` output). */
+function formatAgentMessages(messages) {
+	if (messages.length === 0) return "No new inbox messages.";
+	return messages.map(formatAgentMessageLine).join("\n");
+}
+/**
+* `message check` hands over a bounded batch, oldest first per conversation;
+* the server reports how many conversations still have unread after it.
+*/
+function formatAgentInboxHint(hint) {
+	const n = hint.unread_conversations;
+	return `Still unread: ${n} ${n === 1 ? "conversation" : "conversations"}. Run \`raft inbox check\` to list them.`;
+}
+//#endregion
+//#region ../shared/src/agentOps/message.ts
+function senderType(value) {
+	return value === "human" || value === "agent" || value === "system" || value === "third_party_app" ? value : "unknown";
+}
+function nullableNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function nullableString(value) {
+	return typeof value === "string" ? value : null;
+}
+/** Normalise an envelope (snake_case wire keys win, camelCase legacy keys fill in) into the formatter's shape. */
+function toAgentMessageLike(envelope) {
+	return {
+		...envelope,
+		message_id: envelope.message_id ?? envelope.id,
+		timestamp: envelope.timestamp ?? envelope.createdAt,
+		sender_type: envelope.sender_type ?? envelope.senderType,
+		sender_name: envelope.sender_name ?? envelope.senderName,
+		sender_description: envelope.sender_description ?? envelope.senderDescription ?? null,
+		task_status: envelope.task_status ?? envelope.taskStatus ?? null,
+		task_number: envelope.task_number ?? envelope.taskNumber ?? null,
+		task_assignee_id: envelope.task_assignee_id ?? envelope.taskAssigneeId ?? null,
+		task_assignee_type: envelope.task_assignee_type ?? envelope.taskAssigneeType ?? null,
+		task_assignee_name: envelope.task_assignee_name ?? envelope.taskAssigneeName ?? null,
+		task_current_projection: envelope.task_current_projection ?? envelope.taskCurrentProjection ?? null
+	};
+}
+function projectRaftMessage(envelope) {
+	const like = toAgentMessageLike(envelope);
+	const id = nullableString(like.message_id);
+	const taskNumber = nullableNumber(like.task_number);
+	const taskStatus = nullableString(like.task_status);
+	const raw = envelope;
+	return {
+		id,
+		shortId: id ? id.slice(0, 8) : null,
+		seq: nullableNumber(envelope.seq),
+		target: formatAgentMessageTarget(like),
+		timestamp: nullableString(like.timestamp),
+		sender: {
+			type: senderType(like.sender_type),
+			name: nullableString(like.sender_name),
+			description: nullableString(like.sender_description)
+		},
+		content: envelope.content ?? "",
+		attachments: (envelope.attachments ?? []).map((a) => ({
+			id: a.id,
+			filename: a.filename
+		})),
+		mentioned: typeof raw.mentioned === "boolean" ? raw.mentioned : null,
+		task: taskNumber !== null || taskStatus !== null ? {
+			number: taskNumber,
+			status: taskStatus,
+			assigneeName: nullableString(like.task_assignee_name)
+		} : null,
+		thread: {
+			id: nullableString(envelope.threadId),
+			replyCount: nullableNumber(envelope.replyCount)
+		},
+		text: formatAgentMessageLine(like),
+		raw: envelope
+	};
+}
+function sortBySeq(messages) {
+	return [...messages].sort((a, b) => (a.seq ?? Number.MAX_SAFE_INTEGER) - (b.seq ?? Number.MAX_SAFE_INTEGER));
+}
+//#endregion
+//#region ../shared/src/agentOps/frontier.ts
+const MAX_EXACT_SEQS = 2500;
+function positiveInt(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+var SeenFrontier = class SeenFrontier {
+	targets = /* @__PURE__ */ new Map();
+	aliases = /* @__PURE__ */ new Map();
+	static fromSnapshot(snapshot) {
+		const frontier = new SeenFrontier();
+		if (!snapshot || snapshot.version !== 1) return frontier;
+		for (const [target, state] of Object.entries(snapshot.targets ?? {})) {
+			if (positiveInt(state.upTo)) frontier.recordUpTo(target, state.upTo);
+			if (Array.isArray(state.exact)) frontier.recordExact(target, state.exact);
+		}
+		for (const [alias, canonical] of Object.entries(snapshot.aliases ?? {})) frontier.recordAlias(alias, canonical);
+		return frontier;
+	}
+	/** Remember that the Server resolved `requested` to `canonical` (a thread spelling, a `~agent` suffix, …). */
+	recordAlias(requested, canonical) {
+		if (requested && canonical && requested !== canonical) this.aliases.set(requested, canonical);
+	}
+	canonical(target) {
+		return this.aliases.get(target) ?? target;
+	}
+	/** Advance the contiguous boundary for a target; never lowers it. */
+	recordUpTo(target, seq) {
+		if (!positiveInt(seq)) return;
+		const state = this.state(this.canonical(target));
+		if (state.upTo === void 0 || seq > state.upTo) state.upTo = seq;
+		for (const exact of state.exact) if (exact <= state.upTo) state.exact.delete(exact);
+	}
+	/** Record bodies that were rendered without proving contiguity. */
+	recordExact(target, seqs) {
+		const state = this.state(this.canonical(target));
+		for (const seq of seqs) {
+			if (!positiveInt(seq)) continue;
+			if (state.upTo !== void 0 && seq <= state.upTo) continue;
+			state.exact.add(seq);
+		}
+		if (state.exact.size > MAX_EXACT_SEQS) {
+			const keep = [...state.exact].sort((a, b) => b - a).slice(0, MAX_EXACT_SEQS);
+			state.exact.clear();
+			for (const seq of keep) state.exact.add(seq);
+		}
+	}
+	/** What to attest on a send or claim to `target`; omits `seenUpToSeq` when nothing contiguous is known. */
+	attestation(target) {
+		const state = this.targets.get(this.canonical(target));
+		if (!state) return { seenExactSeqs: [] };
+		return {
+			...state.upTo === void 0 ? {} : { seenUpToSeq: state.upTo },
+			seenExactSeqs: [...state.exact].sort((a, b) => a - b)
+		};
+	}
+	snapshot() {
+		const targets = {};
+		for (const [target, state] of this.targets) targets[target] = {
+			...state.upTo === void 0 ? {} : { upTo: state.upTo },
+			...state.exact.size === 0 ? {} : { exact: [...state.exact].sort((a, b) => a - b) }
+		};
+		return {
+			version: 1,
+			targets,
+			aliases: Object.fromEntries(this.aliases)
+		};
+	}
+	state(target) {
+		let state = this.targets.get(target);
+		if (!state) {
+			state = { exact: /* @__PURE__ */ new Set() };
+			this.targets.set(target, state);
+		}
+		return state;
+	}
+};
+//#endregion
+//#region ../shared/src/agentOps/inbox.ts
+const MAX_DRAIN_ROUNDS = 50;
+function batchNext(batch) {
+	if (batch.hasMore) return {
+		kind: "check_inbox_again",
+		command: "raft message check",
+		...batch.cursor === null ? {} : { args: { since: batch.cursor } },
+		why: "The Server trimmed this batch; more messages are pending."
+	};
+	if ((batch.stillUnreadConversations ?? 0) > 0) return {
+		kind: "list_inbox",
+		command: "raft inbox check",
+		why: "Conversations remain unread beyond this batch."
+	};
+	if (batch.messages.length > 0) return {
+		kind: "reply_or_act",
+		args: { target: batch.messages[0].target },
+		why: "Handle the messages above; reply where each one came from."
+	};
+	return null;
+}
+function batchText(batch) {
+	const lines = [formatAgentMessages(batch.messages.map((m) => toAgentMessageLike(m.raw)))];
+	if (batch.hasMore) lines.push("More messages are pending. Run `raft message check` again.");
+	else if (batch.messages.length > 0) lines.push("No more new inbox messages.");
+	if ((batch.stillUnreadConversations ?? 0) > 0) lines.push(formatAgentInboxHint({ unread_conversations: batch.stillUnreadConversations }));
+	return lines.join("\n");
+}
+function recordExactSeen(frontier, messages) {
+	if (!frontier) return;
+	const byTarget = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (message.seq === null) continue;
+		byTarget.set(message.target, [...byTarget.get(message.target) ?? [], message.seq]);
+	}
+	for (const [target, seqs] of byTarget) frontier.recordExact(target, seqs);
+}
+/** One bounded pull. Records exact seen seqs on `frontier` (sparse drains never advance the high-water mark). */
+async function checkInbox(client, request = {}, frontier) {
+	const ack = request.ack ?? "cursor";
+	const result = await client.events.get({
+		since: request.since === void 0 ? "latest" : String(request.since),
+		...request.limit === void 0 ? {} : { limit: String(request.limit) },
+		ack
+	});
+	if (!result.ok) return failureFromClientResult(result);
+	const data = result.data;
+	const messages = sortBySeq(data.events.map(projectRaftMessage));
+	recordExactSeen(frontier, messages);
+	const batch = {
+		messages,
+		cursor: typeof data.last_seen_seq === "number" ? data.last_seen_seq : null,
+		ackMode: data.ack_mode ?? "immediate",
+		hasMore: data.has_more === true,
+		stillUnreadConversations: data.inbox_hint?.unread_conversations ?? null,
+		replyTarget: data.reply_target ?? null
+	};
+	return {
+		ok: true,
+		state: messages.length > 0 ? "batch" : "empty",
+		data: batch,
+		next: batchNext(batch),
+		text: batchText(batch)
+	};
+}
+/**
+* Pull until the Server reports nothing more, like `raft message check`, but
+* as an async iterator so that acknowledgement follows consumption: under
+* cursor acks, the pull that acknowledges batch N is only sent when the
+* consumer asks for batch N+1, i.e. after it has processed batch N. A consumer
+* that stops midway leaves the current batch unacknowledged, and a later pull
+* without a cursor returns it again. Capped at 50 rounds. The generator's
+* return value summarises the drain; the batch that ends the iteration is
+* acknowledged only by the caller's next pull (`summary.cursor`).
+*/
+async function* drainInbox(client, request = {}, frontier) {
+	const ack = request.ack ?? "cursor";
+	let cursor = request.since ?? null;
+	let ackMode = ack;
+	let stillUnread = null;
+	let rounds = 0;
+	while (rounds < MAX_DRAIN_ROUNDS) {
+		const sent = cursor;
+		rounds += 1;
+		const round = await checkInbox(client, {
+			...sent === null ? {} : { since: sent },
+			limit: request.limit,
+			ack
+		}, frontier);
+		if (!round.ok) return {
+			cursor,
+			ackMode,
+			rounds,
+			hasMore: true,
+			stillUnreadConversations: stillUnread,
+			error: round
+		};
+		const batch = round.data;
+		ackMode = batch.ackMode;
+		stillUnread = batch.stillUnreadConversations;
+		if (batch.messages.length > 0) {
+			cursor = batch.cursor ?? sent;
+			yield batch;
+			if (ack === "cursor" && batch.ackMode === "cursor") continue;
+			if (batch.hasMore) continue;
+			return {
+				cursor,
+				ackMode,
+				rounds,
+				hasMore: false,
+				stillUnreadConversations: stillUnread,
+				error: null
+			};
+		}
+		if (ack === "cursor" && batch.ackMode === "cursor" && batch.cursor !== null && batch.cursor !== sent) {
+			cursor = batch.cursor;
+			continue;
+		}
+		return {
+			cursor,
+			ackMode,
+			rounds,
+			hasMore: batch.hasMore,
+			stillUnreadConversations: stillUnread,
+			error: null
+		};
+	}
+	return {
+		cursor,
+		ackMode,
+		rounds,
+		hasMore: true,
+		stillUnreadConversations: stillUnread,
+		error: null
+	};
+}
+function openCommandFor(item) {
+	return `raft message read --target "${item.target}" --after ${item.lastReadSeq}`;
+}
+function listingNext(listing) {
+	const first = listing.conversations[0];
+	if (first) return {
+		kind: "read_target",
+		command: first.openCommand,
+		args: {
+			target: first.target,
+			after: first.lastReadSeq
+		},
+		why: "Open the newest unread conversation from your read position."
+	};
+	return null;
+}
+function listingText(listing) {
+	const t = listing.totals;
+	const head = t.conversations === 0 ? "Inbox: nothing unread." : `Inbox: ${t.conversations} unread ${t.conversations === 1 ? "conversation" : "conversations"} (${t.dms} DMs, ${t.mentions} with mentions).${listing.conversations.length > 0 ? " Newest activity first." : ""}`;
+	const rows = listing.conversations.map((c) => {
+		const flags = [c.mentions > 0 ? "mentions you" : null, c.kind === "thread" ? "thread" : null].filter(Boolean).join(" · ");
+		return `${c.target} · ${c.unread} unread${flags ? ` · ${flags}` : ""}${c.latestSenderName ? ` · latest @${c.latestSenderName}` : ""}\n  open: ${c.openCommand}`;
+	});
+	const trailer = [];
+	if (listing.hasMore && listing.nextBeforeSeq !== null) trailer.push(`More: raft inbox check${listing.view === "mentions" ? " --view mentions" : ""} --before ${listing.nextBeforeSeq}`);
+	const next = listingNext(listing);
+	trailer.push(next?.command ? `Next: open the first conversation above: ${next.command}` : "Next: nothing to do.");
+	return [
+		head,
+		...rows,
+		...trailer
+	].join("\n");
+}
+/** The agent's Activity panel. Lists only; nothing is consumed. */
+async function listInbox(client, request = {}) {
+	const result = await client.inbox.list({
+		...request.view && request.view !== "unread" ? { view: request.view } : {},
+		...request.before === void 0 ? {} : { before_seq: String(request.before) },
+		...request.limit === void 0 ? {} : { limit: String(request.limit) }
+	});
+	if (!result.ok) return failureFromClientResult(result);
+	const data = result.data;
+	const listing = {
+		view: data.view,
+		conversations: data.items.map((item) => ({
+			target: item.target,
+			kind: item.kind,
+			unread: item.unread,
+			mentions: item.mentions,
+			lastReadSeq: item.lastReadSeq,
+			activitySeq: item.activitySeq,
+			latestSenderName: item.latestSenderName,
+			latestAt: item.latestAt,
+			openCommand: openCommandFor(item)
+		})),
+		totals: data.totals,
+		hasMore: data.hasMore,
+		nextBeforeSeq: data.nextBeforeSeq
+	};
+	return {
+		ok: true,
+		state: listing.conversations.length > 0 ? "listed" : "empty",
+		data: listing,
+		next: listingNext(listing),
+		text: listingText(listing)
+	};
+}
+//#endregion
+//#region ../shared/src/agentOps/messages.ts
+function historyNext(page) {
+	const seqs = page.messages.map((m) => m.seq).filter((s) => s !== null);
+	if (page.hasNewer && seqs.length > 0) {
+		const max = Math.max(...seqs);
+		return {
+			kind: "read_newer",
+			command: `raft message read --target "${page.target}" --after ${max}`,
+			args: {
+				target: page.target,
+				after: max
+			},
+			why: "Newer messages exist beyond this window."
+		};
+	}
+	if (page.hasOlder && seqs.length > 0) {
+		const min = Math.min(...seqs);
+		return {
+			kind: "read_older",
+			command: `raft message read --target "${page.target}" --before ${min}`,
+			args: {
+				target: page.target,
+				before: min
+			},
+			why: "Older messages exist before this window; read them only if the task needs them."
+		};
+	}
+	return null;
+}
+function historyText(page) {
+	if (page.messages.length === 0) return `No messages in ${page.target}.`;
+	const lines = [formatAgentMessages(page.messages.map((m) => toAgentMessageLike(m.raw)))];
+	const next = historyNext(page);
+	if (next?.command) lines.push(`${next.kind === "read_newer" ? "Newer" : "Older"} exist: ${next.command}`);
+	return lines.join("\n");
+}
+/**
+* Frontier rules (FH-EXT-001, mirrored from the CLI): a contiguous window may
+* advance the high-water mark to the Server's `model_seen_up_to_seq`; an
+* `around` lookup and a legacy Server without that field record exact seqs.
+*/
+function recordHistorySeen(frontier, requested, page, around) {
+	if (!frontier) return;
+	frontier.recordAlias(requested, page.target);
+	const seqs = page.messages.map((m) => m.seq).filter((s) => s !== null);
+	if (seqs.length === 0) return;
+	if (!around && page.modelSeenUpToSeq !== null && page.modelSeenUpToSeq > 0) {
+		frontier.recordUpTo(page.target, page.modelSeenUpToSeq);
+		return;
+	}
+	frontier.recordExact(page.target, seqs);
+}
+async function readHistory(client, request, frontier) {
+	if (!request.target?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A target is required to read history." }));
+	const result = await client.history.read({
+		channel: request.target,
+		...request.after === void 0 ? {} : { after: String(request.after) },
+		...request.before === void 0 ? {} : { before: String(request.before) },
+		...request.around === void 0 ? {} : { around: String(request.around) },
+		...request.limit === void 0 ? {} : { limit: String(request.limit) }
+	});
+	if (!result.ok) return failureFromClientResult(result);
+	const data = result.data;
+	const page = {
+		target: typeof data.target === "string" && data.target ? data.target : request.target,
+		messages: sortBySeq(data.messages.map(projectRaftMessage)),
+		hasOlder: data.has_older === true,
+		hasNewer: data.has_newer === true,
+		lastReadSeq: typeof data.last_read_seq === "number" ? data.last_read_seq : null,
+		modelSeenUpToSeq: typeof data.model_seen_up_to_seq === "number" ? data.model_seen_up_to_seq : null
+	};
+	recordHistorySeen(frontier, request.target, page, request.around !== void 0);
+	return {
+		ok: true,
+		state: page.messages.length > 0 ? "page" : "empty",
+		data: page,
+		next: historyNext(page),
+		text: historyText(page)
+	};
+}
+/** Attempts for a keyed send whose request never reached the Server (transport failure only). */
+const SEND_TRANSPORT_ATTEMPTS = 3;
+function heldText(held, action) {
+	const noun = held.newMessageCount === 1 ? "message" : "messages";
+	const head = `Held — ${held.newMessageCount} unread ${noun} in ${held.target}. ${action}`;
+	if (held.withheld) return `${head}\nContext withheld (reviewer isolation).`;
+	const lines = [head];
+	if (held.formalMentionCount > 0) lines.push(`Note: ${held.formalMentionCount} of these messages formally @mention you.`);
+	if (held.omittedMessageCount > 0) lines.push(`${held.omittedMessageCount} earlier ${held.omittedMessageCount === 1 ? "message" : "messages"} not shown.`);
+	if (held.heldMessages.length > 0) lines.push(formatAgentMessages(held.heldMessages.map((m) => toAgentMessageLike(m.raw))));
+	lines.push(`Full text: raft message read --target "${held.target}"`);
+	return lines.join("\n");
+}
+function heldNext(held) {
+	return {
+		kind: "review_then_resend",
+		command: `raft message read --target "${held.target}"`,
+		args: {
+			target: held.target,
+			newMessageCount: held.newMessageCount
+		},
+		why: "Newer messages arrived in this conversation; read them, then resend if the message still applies."
+	};
+}
+function projectHeld(target, data) {
+	const withheld = data.freshnessContextMode === "withheld";
+	const heldMessages = (data.heldMessages ?? []).map(projectRaftMessage);
+	return {
+		target,
+		newMessageCount: withheld ? data.withheldMessageCount ?? 0 : data.newMessageCount ?? heldMessages.length,
+		heldMessages,
+		omittedMessageCount: data.omittedMessageCount ?? 0,
+		formalMentionCount: data.mentionAnnotation?.formalMentionCount ?? 0,
+		seenUpToSeq: typeof data.seenUpToSeq === "number" ? data.seenUpToSeq : null,
+		withheld
+	};
+}
+function isHeldResponse(data) {
+	return Boolean(data) && typeof data === "object" && data.state === "held";
+}
+function sentOutcome(target, data) {
+	const sent = {
+		messageId: data.messageId,
+		messageSeq: typeof data.messageSeq === "number" ? data.messageSeq : null,
+		unresolvedMentionHandles: data.unresolvedMentionHandles ?? [],
+		recentUnread: (data.recentUnread ?? []).map(projectRaftMessage)
+	};
+	const warn = sent.unresolvedMentionHandles.length > 0 ? ` Unresolved @handles: ${sent.unresolvedMentionHandles.map((h) => `@${h}`).join(", ")}.` : "";
+	return {
+		ok: true,
+		state: "sent",
+		data: sent,
+		next: sent.recentUnread.length > 0 ? {
+			kind: "read_target",
+			command: `raft message read --target "${target}"`,
+			args: { target },
+			why: "Newer messages arrived while you were sending."
+		} : null,
+		text: `Message sent to ${target}. Message ID: ${sent.messageId}${warn}`
+	};
+}
+async function sendMessage(client, request, frontier, internal = {}) {
+	if (!request.target?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A target is required to send a message." }));
+	if (typeof request.content !== "string" || !request.content.trim() && !request.attachmentIds?.length) return failureOutcome(opError("INVALID_REQUEST", { message: "Message content (or an attachment) is required." }));
+	const idempotencyKey = request.idempotencyKey?.trim() || crypto.randomUUID();
+	const attestation = request.seen ? {
+		...request.seen.upToSeq === void 0 ? {} : { seenUpToSeq: request.seen.upToSeq },
+		seenExactSeqs: request.seen.exactSeqs ?? []
+	} : frontier?.attestation(request.target) ?? { seenExactSeqs: [] };
+	const body = {
+		target: request.target,
+		content: request.content,
+		...request.attachmentIds?.length ? { attachmentIds: request.attachmentIds } : {},
+		idempotencyKey,
+		...request.mentions?.length ? { mentions: request.mentions } : {},
+		...attestation.seenUpToSeq === void 0 ? {} : { seenUpToSeq: attestation.seenUpToSeq },
+		...attestation.seenExactSeqs.length > 0 ? { seenExactSeqs: attestation.seenExactSeqs.slice(0, 2500) } : {},
+		...internal.sendDraft ? { sendDraft: true } : {},
+		...internal.continueAnyway ? { continueAnyway: true } : {},
+		...internal.reholdCount ? { draftReholdCount: internal.reholdCount } : {}
+	};
+	let result = await client.messages.sendV2(body);
+	for (let attempt = 1; !result.ok && result.error.kind === "transport" && attempt < SEND_TRANSPORT_ATTEMPTS; attempt += 1) result = await client.messages.sendV2(body);
+	if (!result.ok) return failureFromClientResult(result);
+	const data = result.data;
+	if (isHeldResponse(data)) {
+		const reholdCount = (internal.reholdCount ?? 0) + 1;
+		const keyed = {
+			...request,
+			idempotencyKey
+		};
+		const held = {
+			...projectHeld(request.target, data),
+			resend: (options) => sendMessage(client, options.seen === "held" && typeof data.seenUpToSeq === "number" ? {
+				...keyed,
+				seen: {
+					upToSeq: data.seenUpToSeq,
+					exactSeqs: attestation.seenExactSeqs
+				}
+			} : keyed, frontier, {
+				sendDraft: true,
+				reholdCount,
+				...options.seen === "anyway" ? { continueAnyway: true } : {}
+			})
+		};
+		return {
+			ok: true,
+			state: "held",
+			data: held,
+			next: heldNext(held),
+			text: heldText(held, "Your message was not sent.")
+		};
+	}
+	if (data.state === "sent") return sentOutcome(request.target, data);
+	return failureOutcome(opError("INVALID_RESPONSE", { message: `Unexpected send state "${data.state}".` }));
+}
+/** Reply where a received message came from. */
+function replyTo(client, message, request, frontier) {
+	return sendMessage(client, {
+		...request,
+		target: message.target
+	}, frontier);
 }
 //#endregion
-//#region src/credential.ts
-var RaftCredentialError = class extends Error {
-	code;
-	name = "RaftCredentialError";
-	constructor(code, message) {
-		super(message);
-		this.code = code;
+//#region ../shared/src/agentOps/tasks.ts
+const TASK_CLAIM_REASON_ALREADY_CLAIMED_BY_YOU = "already claimed by you";
+function rowState(result) {
+	if (result.success) return "claimed";
+	if (result.reason === TASK_CLAIM_REASON_ALREADY_CLAIMED_BY_YOU) return "already_yours";
+	if (result.conflict?.kind === "claim_conflict") return "conflict";
+	return "refused";
+}
+function claimNext(claim) {
+	const first = claim.rows.find((row) => row.mayWork);
+	if (first) {
+		const suffix = first.messageId ? first.messageId.slice(0, 8) : null;
+		return {
+			kind: "start_work",
+			...suffix ? {
+				command: `raft message send --target "${claim.target}:${suffix}"`,
+				args: { thread: `${claim.target}:${suffix}` }
+			} : {},
+			why: "The claim is yours; post progress in the task's thread."
+		};
 	}
-};
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.trim().length > 0;
+	return {
+		kind: "do_not_start",
+		why: "No claim authorised work. Do not retry the identical claim and do not start conflicting execution; if you own this lane, correct the routing in the original thread."
+	};
 }
-function parseIdentityResponse(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	const input = value;
-	if (!isNonEmptyString(input.agentId) || !isNonEmptyString(input.agentName) || input.agentDisplayName !== null && typeof input.agentDisplayName !== "string" || !isNonEmptyString(input.serverId) || !isNonEmptyString(input.credentialId) || !Array.isArray(input.scopes) || !input.scopes.every(isNonEmptyString)) return null;
+function claimText(claim) {
+	const lines = claim.rows.map((row) => {
+		const label = row.taskNumber ? `#${row.taskNumber}` : `msg:${row.ref}`;
+		if (row.state === "claimed") return `${label}: claimed`;
+		if (row.state === "already_yours") return `${label}: already claimed by you`;
+		if (row.state === "conflict") return `${label}: held by ${row.holder?.name ? `@${row.holder.name}` : "another assignee"}`;
+		return `${label}: refused${row.reason ? ` (${row.reason})` : ""}`;
+	});
+	const head = `Claim results (${claim.rows.filter((row) => row.mayWork).length} of ${claim.rows.length} authorise work):`;
+	const next = claimNext(claim);
+	return [
+		head,
+		...lines,
+		next?.command ? `Follow up in the task's thread: ${next.command}` : next?.why ?? ""
+	].filter(Boolean).join("\n");
+}
+async function claimTasks(client, request) {
+	const numbers = (request.taskNumbers ?? []).filter((n) => Number.isInteger(n) && n > 0);
+	const ids = (request.messageIds ?? []).map((id) => id.trim()).filter(Boolean);
+	if (!request.target?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A channel target is required to claim tasks." }));
+	if (numbers.length === 0 && ids.length === 0) return failureOutcome(opError("INVALID_REQUEST", { message: "Pass at least one task number or message id to claim." }));
+	const result = await client.tasks.claim({
+		channel: request.target,
+		...numbers.length ? { task_numbers: numbers } : {},
+		...ids.length ? { message_ids: ids } : {}
+	});
+	if (!result.ok) return failureFromClientResult(result);
+	const data = result.data;
+	if (isHeldResponse(data)) {
+		const held = {
+			...projectHeld(request.target, data),
+			retry: () => claimTasks(client, request)
+		};
+		return {
+			ok: true,
+			state: "held",
+			data: held,
+			next: {
+				kind: "review_then_retry",
+				command: `raft message read --target "${request.target}"`,
+				args: {
+					target: request.target,
+					newMessageCount: held.newMessageCount
+				},
+				why: "Unread messages in this channel may change the task; read them, then claim again if it is still right."
+			},
+			text: `Held — ${held.newMessageCount} unread ${held.newMessageCount === 1 ? "message" : "messages"} in ${request.target}. Your task claim was not applied.\nRead them with: raft message read --target "${request.target}"\nAfter reviewing, rerun the claim if it is still correct.`
+		};
+	}
+	const rows = (data.results ?? []).map((row) => {
+		const state = rowState(row);
+		return {
+			ref: row.taskNumber ? String(row.taskNumber) : row.messageId ?? "?",
+			taskNumber: row.taskNumber ?? null,
+			messageId: row.messageId ?? null,
+			state,
+			mayWork: state === "claimed" || state === "already_yours",
+			reason: row.reason ?? null,
+			holder: row.conflict?.currentAssignee ?? null,
+			conflict: row.conflict ?? null
+		};
+	});
+	const claim = {
+		target: request.target,
+		rows,
+		anyAuthorised: rows.some((row) => row.mayWork)
+	};
 	return {
-		agentId: input.agentId,
-		agentName: input.agentName,
-		agentDisplayName: input.agentDisplayName,
-		serverId: input.serverId,
-		credentialId: input.credentialId,
-		scopes: [...input.scopes]
+		ok: true,
+		state: !claim.anyAuthorised ? "refused" : rows.every((row) => row.mayWork) ? "claimed" : "partial",
+		data: claim,
+		next: claimNext(claim),
+		text: claimText(claim)
 	};
 }
-function parseStoredRaftCredential(value) {
+//#endregion
+//#region ../shared/src/agentOps/wake.ts
+const RAFT_INBOX_NOTICE_SCHEMA = "raft-agent-inbox-notice.v1";
+const RAFT_NOTICE_SIGNATURE_HEADER = "x-raft-signature-256";
+const RAFT_NOTICE_DELIVERY_ID_HEADER = "x-raft-delivery-id";
+function headerValue(headers, name) {
+	if (typeof headers.get === "function") return headers.get(name);
+	const record = headers;
+	const key = Object.keys(record).find((k) => k.toLowerCase() === name);
+	const value = key ? record[key] : void 0;
+	return Array.isArray(value) ? value[0] ?? null : value ?? null;
+}
+function hexToBytes(hex) {
+	if (hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex)) return null;
+	const out = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < out.length; i += 1) out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+	return out;
+}
+function constantTimeEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let diff = 0;
+	for (let i = 0; i < a.length; i += 1) diff |= a[i] ^ b[i];
+	return diff === 0;
+}
+async function hmacSha256(secret, body) {
+	const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const bytes = new Uint8Array(body.byteLength);
+	bytes.set(body);
+	return new Uint8Array(await crypto.subtle.sign("HMAC", key, bytes.buffer));
+}
+const SENDER_TYPES = /* @__PURE__ */ new Set([
+	"human",
+	"agent",
+	"system",
+	"third_party_app"
+]);
+const FLAGS = /* @__PURE__ */ new Set([
+	"mention",
+	"non_member_mention",
+	"thread",
+	"dm",
+	"task"
+]);
+function parseNotice(value, deliveryId) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	const input = value;
-	if (input.schemaVersion !== 1 || !isNonEmptyString(input.serverUrl) || !isNonEmptyString(input.credential) || !isNonEmptyString(input.storedAt)) return null;
-	const identity = parseIdentityResponse(input);
-	if (!identity || Number.isNaN(Date.parse(input.storedAt))) return null;
-	let serverUrl;
-	let credential;
-	try {
-		serverUrl = requireServerUrl(input.serverUrl);
-		credential = requireAgentCredential(input.credential);
-	} catch {
-		return null;
+	const v = value;
+	if (typeof v.noticeId !== "string" || typeof v.recipientAgentId !== "string" || typeof v.occurredAt !== "string" || !Array.isArray(v.targets)) return null;
+	const targets = [];
+	for (const raw of v.targets) {
+		if (!raw || typeof raw !== "object") return null;
+		const t = raw;
+		if (typeof t.target !== "string") return null;
+		const flags = Array.isArray(t.flags) ? t.flags.filter((f) => typeof f === "string" && FLAGS.has(f)) : [];
+		targets.push({
+			target: t.target,
+			channelId: typeof t.channelId === "string" ? t.channelId : null,
+			channelType: typeof t.channelType === "string" ? t.channelType : null,
+			pendingCount: typeof t.pendingCount === "number" ? t.pendingCount : 0,
+			firstPendingMsgId: typeof t.firstPendingMsgId === "string" ? t.firstPendingMsgId : null,
+			latestMsgId: typeof t.latestMsgId === "string" ? t.latestMsgId : null,
+			latestSenderName: typeof t.latestSenderName === "string" ? t.latestSenderName : null,
+			latestSenderType: typeof t.latestSenderType === "string" && SENDER_TYPES.has(t.latestSenderType) ? t.latestSenderType : null,
+			flags,
+			mentionsYou: flags.includes("mention") || flags.includes("non_member_mention")
+		});
 	}
 	return {
-		schemaVersion: 1,
-		serverUrl,
-		credential,
-		storedAt: input.storedAt,
-		...identity
+		noticeId: v.noticeId,
+		deliveryId,
+		recipientAgentId: v.recipientAgentId,
+		occurredAt: v.occurredAt,
+		text: typeof v.text === "string" ? v.text : "",
+		targets
 	};
 }
 /**
-* Validate an existing External Agent credential against Raft, derive its
-* bound identity from the credential-authenticated `whoami` surface, and save
-* it through the caller's explicit store. This does not mint or rotate a
-* credential and never returns the credential bytes.
+* Verify and parse a push notice. Async, WebCrypto, raw bytes. Never rejects
+* on time: treat every accepted notice as "pull your inbox now".
 */
-async function bootstrapRaftCredential(options) {
-	const serverUrl = requireServerUrl(options.serverUrl);
-	const credential = requireAgentCredential(options.credential);
-	const httpFetch = options.fetch ?? globalThis.fetch;
-	let existing;
-	try {
-		existing = await options.store.load();
-	} catch {
-		throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The existing Agent credential could not be checked before saving");
-	}
-	if (existing) {
-		const validatedExisting = parseStoredRaftCredential(existing);
-		if (!validatedExisting) throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The existing Agent credential record is invalid");
-		existing = validatedExisting;
-		if (existing.serverUrl !== serverUrl || existing.credential !== credential) throw new RaftCredentialError("CREDENTIAL_STORE_CONFLICT", "The credential store already contains a different Raft Agent credential");
-	}
-	let response;
-	try {
-		response = await httpFetch(`${serverUrl}/internal/agent-api/`, {
-			method: "GET",
-			headers: { authorization: `Bearer ${credential}` }
-		});
-	} catch {
-		throw new RaftCredentialError("CREDENTIAL_VERIFY_FAILED", "Could not reach the Raft Server to verify the Agent credential");
-	}
-	if (!response.ok) {
-		if (response.status === 401 || response.status === 403) throw new RaftCredentialError("CREDENTIAL_REJECTED", "The Raft Server rejected the Agent credential");
-		throw new RaftCredentialError("CREDENTIAL_VERIFY_FAILED", `The Raft Server could not verify the Agent credential (status ${response.status})`);
-	}
-	let payload;
+async function verifyInboxNotice(input) {
+	const header = headerValue(input.headers, "x-raft-signature-256")?.trim() ?? "";
+	if (!header) return {
+		ok: false,
+		reason: "missing_signature",
+		message: `Missing ${RAFT_NOTICE_SIGNATURE_HEADER} header.`
+	};
+	const presented = header.toLowerCase().startsWith("sha256=") ? hexToBytes(header.slice(7)) : null;
+	if (!presented) return {
+		ok: false,
+		reason: "bad_signature",
+		message: "Signature header is not `sha256=<hex>`."
+	};
+	if (!constantTimeEqual(presented, await hmacSha256(input.secret, input.body))) return {
+		ok: false,
+		reason: "bad_signature",
+		message: "Signature does not match the body."
+	};
+	let parsed;
 	try {
-		payload = await response.json();
+		parsed = JSON.parse(new TextDecoder().decode(input.body));
 	} catch {
-		throw new RaftCredentialError("CREDENTIAL_RESPONSE_INVALID", "The Raft Server returned an invalid Agent identity response");
+		return {
+			ok: false,
+			reason: "invalid_body",
+			message: "Body is not JSON."
+		};
 	}
-	const identity = parseIdentityResponse(payload);
-	if (!identity) throw new RaftCredentialError("CREDENTIAL_RESPONSE_INVALID", "The Raft Server returned an invalid Agent identity response");
-	if (!identity.scopes.includes("send")) throw new RaftCredentialError("CREDENTIAL_SCOPE_MISSING", "The Raft Agent credential does not include the send capability required by this SDK");
-	if (existing && (existing.serverId !== identity.serverId || existing.agentId !== identity.agentId)) throw new RaftCredentialError("CREDENTIAL_STORE_CONFLICT", "The credential store is already bound to a different Raft Agent identity");
-	if (existing) return {
-		serverUrl,
-		...identity
+	if ((parsed && typeof parsed === "object" ? parsed.schema : void 0) !== "raft-agent-inbox-notice.v1") return {
+		ok: false,
+		reason: "unsupported_schema",
+		message: `Expected schema ${RAFT_INBOX_NOTICE_SCHEMA}.`
 	};
-	const record = {
-		schemaVersion: 1,
-		serverUrl,
-		credential,
-		storedAt: currentDate().toISOString(),
-		...identity
+	const notice = parseNotice(parsed, headerValue(input.headers, RAFT_NOTICE_DELIVERY_ID_HEADER));
+	if (!notice) return {
+		ok: false,
+		reason: "invalid_body",
+		message: "Notice body does not match the contract."
 	};
-	try {
-		await options.store.save(record);
-	} catch (error) {
-		if (error instanceof RaftCredentialError && error.code === "CREDENTIAL_STORE_CONFLICT") throw error;
-		throw new RaftCredentialError("CREDENTIAL_STORE_WRITE_FAILED", "The verified Agent credential could not be saved");
-	}
 	return {
-		serverUrl,
-		...identity
+		ok: true,
+		notice
 	};
 }
-/** Load the caller-selected credential store and create a normal Raft client. */
-async function createRaftClientFromStore(options) {
-	let record;
-	try {
-		record = await options.store.load();
-	} catch {
-		throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The stored Agent credential could not be loaded");
-	}
-	if (!record) throw new RaftCredentialError("CREDENTIAL_NOT_FOUND", "No stored Raft Agent credential was found");
-	const validated = parseStoredRaftCredential(record);
-	if (!validated) throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The stored Agent credential is invalid");
-	if (!validated.scopes.includes("send")) throw new RaftCredentialError("CREDENTIAL_SCOPE_MISSING", "The stored Raft Agent credential does not include the send capability required by this SDK");
-	return createRaftClient({
-		serverUrl: validated.serverUrl,
-		credential: validated.credential,
-		fetch: options.fetch,
-		headers: options.headers,
-		retry: options.retry,
-		throttle: options.throttle
-	});
+function statusText(status) {
+	if (!status.registered) return "Push webhook: not registered.";
+	return `Push webhook: ${status.url ?? "(url hidden)"} · ${status.enabled ? "enabled" : `disabled (${status.disabledReason ?? "unknown"})`}${status.lastDeliveryAt ? ` · last delivery ${status.lastDeliveryAt}` : ""}${status.consecutiveFailures > 0 ? ` · ${status.consecutiveFailures} consecutive failures` : ""}`;
 }
-//#endregion
-//#region src/fileCredentialStore.ts
-const MAX_CREDENTIAL_FILE_BYTES = 65536;
-/**
-* Create a Node.js credential store at one explicit absolute path. The SDK
-* never discovers CLI profiles or a home directory. Writes use a same-directory
-* temporary file followed by atomic rename, and the final file is mode 0600.
-*/
-function createFileCredentialStore(filePath) {
-	if (!filePath.trim() || !(0, node_path.isAbsolute)(filePath)) throw new RaftSdkConfigurationError("INVALID_CREDENTIAL_PATH", "Raft credential file path must be an explicit absolute path");
+async function webhookStatus(client) {
+	const result = await client.pushWebhook.status();
+	if (!result.ok) return failureFromClientResult(result);
 	return {
-		load: () => loadFileCredential(filePath),
-		async save(record) {
-			const validated = parseStoredRaftCredential(record);
-			if (!validated) throw new RaftCredentialError("CREDENTIAL_STORE_WRITE_FAILED", "Refusing to write an invalid Raft Agent credential record");
-			const directory = (0, node_path.dirname)(filePath);
-			const temporaryPath = `${filePath}.${process.pid}.${(0, node_crypto.randomUUID)()}.tmp`;
-			let handle;
-			try {
-				await (0, node_fs_promises.mkdir)(directory, {
-					recursive: true,
-					mode: 448
-				});
-				const existing = await loadFileCredential(filePath);
-				if (existing) {
-					assertSameCredential(existing, validated);
-					return;
-				}
-				handle = await (0, node_fs_promises.open)(temporaryPath, "wx", 384);
-				await handle.writeFile(`${JSON.stringify(validated, null, 2)}\n`, "utf8");
-				await handle.sync();
-				await (0, node_fs_promises.chmod)(temporaryPath, 384);
-				await handle.close();
-				handle = void 0;
-				try {
-					await (0, node_fs_promises.link)(temporaryPath, filePath);
-				} catch (error) {
-					if (error.code !== "EEXIST") throw error;
-					const winner = await loadFileCredential(filePath);
-					if (!winner) throw error;
-					assertSameCredential(winner, validated);
-				}
-				await (0, node_fs_promises.unlink)(temporaryPath);
-			} catch (error) {
-				if (handle) await handle.close().catch(() => void 0);
-				await (0, node_fs_promises.unlink)(temporaryPath).catch(() => void 0);
-				if (error instanceof RaftCredentialError) throw error;
-				throw new RaftCredentialError("CREDENTIAL_STORE_WRITE_FAILED", "The Raft Agent credential could not be written atomically");
-			}
-		}
+		ok: true,
+		state: "status",
+		data: result.data,
+		next: null,
+		text: statusText(result.data)
 	};
 }
-async function loadFileCredential(filePath) {
-	let initialMetadata;
-	try {
-		initialMetadata = await (0, node_fs_promises.lstat)(filePath);
-	} catch (error) {
-		if (error.code === "ENOENT") return null;
-		throw fileReadError();
-	}
-	if (!initialMetadata.isFile() || initialMetadata.isSymbolicLink() || initialMetadata.size > MAX_CREDENTIAL_FILE_BYTES) throw fileReadError();
-	let parsed;
-	let handle;
-	try {
-		const noFollow = process.platform === "win32" ? 0 : node_fs.constants.O_NOFOLLOW;
-		handle = await (0, node_fs_promises.open)(filePath, node_fs.constants.O_RDONLY | noFollow);
-		const openedMetadata = await handle.stat();
-		if (!openedMetadata.isFile() || openedMetadata.size > MAX_CREDENTIAL_FILE_BYTES || initialMetadata.dev !== openedMetadata.dev || initialMetadata.ino !== openedMetadata.ino) throw fileReadError();
-		if (process.platform !== "win32" && (openedMetadata.mode & 63) !== 0) throw new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The Raft credential file permissions are too broad; expected mode 0600");
-		parsed = JSON.parse(await handle.readFile("utf8"));
-	} catch (error) {
-		if (error instanceof RaftCredentialError) throw error;
-		throw fileReadError();
-	} finally {
-		await handle?.close().catch(() => void 0);
-	}
-	const record = parseStoredRaftCredential(parsed);
-	if (!record) throw fileReadError();
-	return record;
+async function registerWebhook(client, request) {
+	const result = await client.pushWebhook.register({
+		url: request.url,
+		secret: request.secret
+	});
+	if (!result.ok) return failureFromClientResult(result);
+	return {
+		ok: true,
+		state: "registered",
+		data: result.data,
+		next: null,
+		text: statusText(result.data)
+	};
 }
-function assertSameCredential(existing, candidate) {
-	if (existing.credential !== candidate.credential) throw new RaftCredentialError("CREDENTIAL_STORE_CONFLICT", "The credential store already contains a different Raft Agent credential");
+async function unregisterWebhook(client) {
+	const result = await client.pushWebhook.unregister();
+	if (!result.ok) return failureFromClientResult(result);
+	return {
+		ok: true,
+		state: "unregistered",
+		data: null,
+		next: null,
+		text: "Push webhook: removed."
+	};
 }
-function fileReadError() {
-	return new RaftCredentialError("CREDENTIAL_STORE_READ_FAILED", "The Raft credential file is invalid or unreadable");
+//#endregion
+//#region src/raft.ts
+function createRaft(options) {
+	const serverUrl = requireServerUrl(options.serverUrl);
+	const authorization = `Bearer ${requireAgentCredential(options.credential)}`;
+	const frontier = SeenFrontier.fromSnapshot(options.frontier);
+	const routes = createRaftRoutes({
+		serverUrl,
+		fetch: options.fetch,
+		headers: options.headers,
+		authorization,
+		readAttempts: options.retry?.attempts,
+		beforeRequest: options.throttle?.beforeRequest
+	});
+	const inboxApi = createAgentApiClient({ fetch: {
+		baseUrl: serverUrl,
+		fetch: (input, init) => (options.fetch ?? fetch)(input, {
+			...init,
+			cache: "no-store",
+			redirect: "error"
+		}),
+		headers: Object.fromEntries(new Headers(options.headers)),
+		retry: { attempts: 1 },
+		throttle: options.throttle,
+		auth: { authorization }
+	} });
+	return {
+		identity: { whoami: () => getRaftContext(routes) },
+		wake: {
+			verifyNotice: (input) => verifyInboxNotice(input),
+			webhook: {
+				status: () => webhookStatus(routes),
+				register: (request) => registerWebhook(routes, request),
+				unregister: () => unregisterWebhook(routes)
+			}
+		},
+		inbox: {
+			check: (request) => checkInbox(inboxApi, request, frontier),
+			drain: (request) => drainInbox(inboxApi, request, frontier),
+			list: (request) => listInbox(routes, request)
+		},
+		messages: {
+			read: (request) => readHistory(routes, request, frontier),
+			send: (request) => sendMessage(routes, request, frontier),
+			reply: (message, request) => replyTo(routes, message, request, frontier)
+		},
+		tasks: { claim: (request) => claimTasks(routes, request) },
+		frontier,
+		routes
+	};
 }
 //#endregion
+exports.RAFT_INBOX_NOTICE_SCHEMA = RAFT_INBOX_NOTICE_SCHEMA;
+exports.RAFT_NOTICE_DELIVERY_ID_HEADER = RAFT_NOTICE_DELIVERY_ID_HEADER;
+exports.RAFT_NOTICE_SIGNATURE_HEADER = RAFT_NOTICE_SIGNATURE_HEADER;
 exports.RaftCredentialError = RaftCredentialError;
 exports.RaftSdkConfigurationError = RaftSdkConfigurationError;
+exports.SeenFrontier = SeenFrontier;
 exports.bootstrapRaftCredential = bootstrapRaftCredential;
 exports.createFileCredentialStore = createFileCredentialStore;
+exports.createRaft = createRaft;
 exports.createRaftClient = createRaftClient;
 exports.createRaftClientFromStore = createRaftClientFromStore;
+exports.createRaftRoutes = createRaftRoutes;
+exports.describeRaftRoute = describeRaftRoute;
 exports.joinRaftChannelByTarget = joinRaftChannelByTarget;
+exports.listRaftRoutes = listRaftRoutes;
 exports.parseRaftRegularChannelTarget = parseRaftRegularChannelTarget;
+exports.verifyInboxNotice = verifyInboxNotice;