@botiverse/raft-sdk 0.6.0 → 0.7.0

package/dist/cjs/index.cjs

@@ -3113,6 +3113,12 @@ const numberProcessor = (schema, ctx, _json, _params) => {
 const booleanProcessor = (_schema, _ctx, json, _params) => {
 	json.type = "boolean";
 };
+const bigintProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("BigInt cannot be represented in JSON Schema");
+};
+const symbolProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Symbols cannot be represented in JSON Schema");
+};
 const nullProcessor = (_schema, ctx, json, _params) => {
 	if (ctx.target === "openapi-3.0") {
 		json.type = "string";
@@ -3120,9 +3126,20 @@ const nullProcessor = (_schema, ctx, json, _params) => {
 		json.enum = [null];
 	} else json.type = "null";
 };
+const undefinedProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Undefined cannot be represented in JSON Schema");
+};
+const voidProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Void cannot be represented in JSON Schema");
+};
 const neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
+const anyProcessor = (_schema, _ctx, _json, _params) => {};
+const unknownProcessor = (_schema, _ctx, _json, _params) => {};
+const dateProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Date cannot be represented in JSON Schema");
+};
 const enumProcessor = (schema, _ctx, json, _params) => {
 	const def = schema._zod.def;
 	const values = getEnumValues(def.entries);
@@ -3152,12 +3169,54 @@ const literalProcessor = (schema, ctx, json, _params) => {
 		json.enum = vals;
 	}
 };
+const nanProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("NaN cannot be represented in JSON Schema");
+};
+const templateLiteralProcessor = (schema, _ctx, json, _params) => {
+	const _json = json;
+	const pattern = schema._zod.pattern;
+	if (!pattern) throw new Error("Pattern not found in template literal");
+	_json.type = "string";
+	_json.pattern = pattern.source;
+};
+const fileProcessor = (schema, _ctx, json, _params) => {
+	const _json = json;
+	const file = {
+		type: "string",
+		format: "binary",
+		contentEncoding: "binary"
+	};
+	const { minimum, maximum, mime } = schema._zod.bag;
+	if (minimum !== void 0) file.minLength = minimum;
+	if (maximum !== void 0) file.maxLength = maximum;
+	if (mime) {
+		if (mime.length === 1) {
+			file.contentMediaType = mime[0];
+			Object.assign(_json, file);
+		} else {
+			Object.assign(_json, file);
+			_json.anyOf = mime.map((m) => ({ contentMediaType: m }));
+		}
+	} else Object.assign(_json, file);
+};
+const successProcessor = (_schema, _ctx, json, _params) => {
+	json.type = "boolean";
+};
 const customProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
 };
+const functionProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Function types cannot be represented in JSON Schema");
+};
 const transformProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Transforms cannot be represented in JSON Schema");
 };
+const mapProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Map cannot be represented in JSON Schema");
+};
+const setProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Set cannot be represented in JSON Schema");
+};
 const arrayProcessor = (schema, ctx, _json, params) => {
 	const json = _json;
 	const def = schema._zod.def;
@@ -3234,6 +3293,44 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
 	json.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
 };
+const tupleProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "array";
+	const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
+	const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
+	const prefixItems = def.items.map((x, i) => process$1(x, ctx, {
+		...params,
+		path: [
+			...params.path,
+			prefixPath,
+			i
+		]
+	}));
+	const rest = def.rest ? process$1(def.rest, ctx, {
+		...params,
+		path: [
+			...params.path,
+			restPath,
+			...ctx.target === "openapi-3.0" ? [def.items.length] : []
+		]
+	}) : null;
+	if (ctx.target === "draft-2020-12") {
+		json.prefixItems = prefixItems;
+		if (rest) json.items = rest;
+	} else if (ctx.target === "openapi-3.0") {
+		json.items = { anyOf: prefixItems };
+		if (rest) json.items.anyOf.push(rest);
+		json.minItems = prefixItems.length;
+		if (!rest) json.maxItems = prefixItems.length;
+	} else {
+		json.items = prefixItems;
+		if (rest) json.additionalItems = rest;
+	}
+	const { minimum, maximum } = schema._zod.bag;
+	if (typeof minimum === "number") json.minItems = minimum;
+	if (typeof maximum === "number") json.maxItems = maximum;
+};
 const recordProcessor = (schema, ctx, _json, params) => {
 	const json = _json;
 	const def = schema._zod.def;
@@ -3323,12 +3420,99 @@ const readonlyProcessor = (schema, ctx, json, params) => {
 	seen.ref = def.innerType;
 	json.readOnly = true;
 };
+const promiseProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	process$1(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+};
 const optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
 	process$1(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
+const lazyProcessor = (schema, ctx, _json, params) => {
+	const innerType = schema._zod.innerType;
+	process$1(innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = innerType;
+};
+const allProcessors = {
+	string: stringProcessor,
+	number: numberProcessor,
+	boolean: booleanProcessor,
+	bigint: bigintProcessor,
+	symbol: symbolProcessor,
+	null: nullProcessor,
+	undefined: undefinedProcessor,
+	void: voidProcessor,
+	never: neverProcessor,
+	any: anyProcessor,
+	unknown: unknownProcessor,
+	date: dateProcessor,
+	enum: enumProcessor,
+	literal: literalProcessor,
+	nan: nanProcessor,
+	template_literal: templateLiteralProcessor,
+	file: fileProcessor,
+	success: successProcessor,
+	custom: customProcessor,
+	function: functionProcessor,
+	transform: transformProcessor,
+	map: mapProcessor,
+	set: setProcessor,
+	array: arrayProcessor,
+	object: objectProcessor,
+	union: unionProcessor,
+	intersection: intersectionProcessor,
+	tuple: tupleProcessor,
+	record: recordProcessor,
+	nullable: nullableProcessor,
+	nonoptional: nonoptionalProcessor,
+	default: defaultProcessor,
+	prefault: prefaultProcessor,
+	catch: catchProcessor,
+	pipe: pipeProcessor,
+	readonly: readonlyProcessor,
+	promise: promiseProcessor,
+	optional: optionalProcessor,
+	lazy: lazyProcessor
+};
+function toJSONSchema(input, params) {
+	if ("_idmap" in input) {
+		const registry = input;
+		const ctx = initializeContext({
+			...params,
+			processors: allProcessors
+		});
+		const defs = {};
+		for (const entry of registry._idmap.entries()) {
+			const [_, schema] = entry;
+			process$1(schema, ctx);
+		}
+		const schemas = {};
+		ctx.external = {
+			registry,
+			uri: params?.uri,
+			defs
+		};
+		for (const entry of registry._idmap.entries()) {
+			const [key, schema] = entry;
+			extractDefs(ctx, schema);
+			schemas[key] = finalize(ctx, schema);
+		}
+		if (Object.keys(defs).length > 0) schemas.__shared = { [ctx.target === "draft-2020-12" ? "$defs" : "definitions"]: defs };
+		return { schemas };
+	}
+	const ctx = initializeContext({
+		...params,
+		processors: allProcessors
+	});
+	process$1(input, ctx);
+	extractDefs(ctx, input);
+	return finalize(ctx, input);
+}
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.js
 const ZodISODateTime = /*@__PURE__*/ $constructor("ZodISODateTime", (inst, def) => {
@@ -7622,7 +7806,7 @@ async function joinRaftChannelByTarget(client, request) {
 //#endregion
 //#region src/events.ts
 const sequence = number$1().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-const requestSchema = object({
+const requestSchema$1 = object({
 	since: union([sequence, literal("latest")]).optional(),
 	limit: number$1().int().min(1).max(200).optional(),
 	ack: literal("cursor").optional()
@@ -7678,7 +7862,7 @@ function failure$2(code, status, cursorAck = false) {
 }
 /** Internal adapter. The caller must supply a single-attempt transport: receive drains the returned batch. */
 async function receiveRaftEvents(client, request = {}) {
-	const parsed = requestSchema.safeParse(request);
+	const parsed = requestSchema$1.safeParse(request);
 	if (!parsed.success) return failure$2("INVALID_REQUEST");
 	const cursorAck = parsed.data.ack === "cursor";
 	const result = await client.events.get({
@@ -10267,7 +10451,8 @@ const DEFAULT_MESSAGES = {
 	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."
+	UNAVAILABLE: "The Raft Server could not serve this operation right now.",
+	MODEL_ONLY: "This operation only counts when the model sees its result, so it cannot be run from code; nothing was sent."
 };
 const DEFAULT_NEXT_ACTION = {
 	INVALID_REQUEST: "Fix the request arguments; nothing was sent.",
@@ -10280,7 +10465,8 @@ const DEFAULT_NEXT_ACTION = {
 	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."
+	UNAVAILABLE: "Retry in a moment.",
+	MODEL_ONLY: "Call it as a model tool call instead of from code."
 };
 const RETRYABLE = {
 	INVALID_REQUEST: false,
@@ -10293,7 +10479,8 @@ const RETRYABLE = {
 	CONFLICT: false,
 	IDEMPOTENCY_KEY_REUSED: false,
 	UNSUPPORTED_FOR_EXTERNAL_AGENTS: false,
-	UNAVAILABLE: true
+	UNAVAILABLE: true,
+	MODEL_ONLY: false
 };
 function classifyHttp(status, serverCode) {
 	const code = serverCode?.toLowerCase() ?? "";
@@ -10369,6 +10556,22 @@ function failureOutcome(error) {
 function failureFromClientResult(result) {
 	return failureOutcome(opErrorFromClientError(result.error, result.status));
 }
+const MAX_REPORTED_ISSUES = 3;
+/**
+* Validate an operation's input with its zod request schema. Returns null when
+* it is valid, otherwise an `INVALID_REQUEST` failure whose message names the
+* offending fields and what was expected (zod's issue text, which never
+* echoes the input value); nothing is sent.
+*/
+function validateOpRequest(schema, value) {
+	const parsed = schema.safeParse(value);
+	if (parsed.success) return null;
+	const issues = parsed.error.issues.slice(0, MAX_REPORTED_ISSUES).map((issue) => {
+		return `${issue.path.map((part) => typeof part === "number" ? `[${part}]` : String(part)).join(".").replace(/\.\[/g, "[") || "request"}: ${issue.message}`;
+	});
+	const more = parsed.error.issues.length > MAX_REPORTED_ISSUES ? ` (+${parsed.error.issues.length - MAX_REPORTED_ISSUES} more)` : "";
+	return failureOutcome(opError("INVALID_REQUEST", { message: `Invalid request: ${issues.join("; ")}${more}. Nothing was sent.` }));
+}
 //#endregion
 //#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.]";
@@ -11002,50 +11205,75 @@ const MAX_EXACT_SEQS = 2500;
 function positiveInt(value) {
 	return typeof value === "number" && Number.isInteger(value) && value > 0;
 }
+function contextOrNull(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
 var SeenFrontier = class SeenFrontier {
-	targets = /* @__PURE__ */ new Map();
-	aliases = /* @__PURE__ */ new Map();
+	core = {
+		targets: /* @__PURE__ */ new Map(),
+		aliases: /* @__PURE__ */ new Map(),
+		context: null
+	};
+	/** Set on a view from `inContext`: the context this view books and attests under. */
+	bound = void 0;
 	static fromSnapshot(snapshot) {
 		const frontier = new SeenFrontier();
 		frontier.absorb(snapshot);
 		return frontier;
 	}
-	/** Merge a snapshot into this frontier by the same monotonic rules (never lowers a mark). */
+	/** The model context this frontier books and attests under; null means no context scoping. */
+	get contextId() {
+		return this.bound !== void 0 ? this.bound : this.core.context;
+	}
+	/**
+	* Set the current model context (shared by every view of this frontier that
+	* is not bound to its own context). Call it when the model's context
+	* changes (a new session, a compaction): reads booked under the previous
+	* context then no longer attest a send. `null` turns scoping off.
+	*/
+	setContext(contextId) {
+		this.core.context = contextOrNull(contextId);
+	}
+	/**
+	* A view over the same records that books and attests under `contextId`
+	* (for one call made on behalf of that model context), without changing the
+	* frontier's current context. `undefined` returns this frontier.
+	*/
+	inContext(contextId) {
+		if (contextId === void 0) return this;
+		const view = new SeenFrontier();
+		view.core = this.core;
+		view.bound = contextOrNull(contextId);
+		return view;
+	}
+	/**
+	* Merge a snapshot into this frontier: each record is booked under the
+	* context it was booked in (same context: monotonic, never lowers a mark).
+	* Adopts the snapshot's current context when this frontier has none.
+	*/
 	absorb(snapshot) {
 		if (!snapshot || snapshot.version !== 1) return;
 		for (const [alias, canonical] of Object.entries(snapshot.aliases ?? {})) this.recordAlias(alias, canonical);
 		for (const [target, state] of Object.entries(snapshot.targets ?? {})) {
-			if (positiveInt(state.upTo)) this.recordUpTo(target, state.upTo);
-			if (Array.isArray(state.exact)) this.recordExact(target, state.exact);
+			if (positiveInt(state.upTo)) this.bookUpTo(target, state.upTo, contextOrNull(state.upToContextId));
+			if (Array.isArray(state.exact)) this.bookExact(target, state.exact, contextOrNull(state.exactContextId));
 		}
+		if (this.core.context === null) this.core.context = contextOrNull(snapshot.contextId);
 	}
 	/** 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);
+		if (requested && canonical && requested !== canonical) this.core.aliases.set(requested, canonical);
 	}
 	canonical(target) {
-		return this.aliases.get(target) ?? target;
+		return this.core.aliases.get(target) ?? target;
 	}
-	/** Advance the contiguous boundary for a target; never lowers it. */
+	/** Advance the contiguous boundary for a target in the current context; never lowers it within one context. */
 	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);
+		this.bookUpTo(target, seq, this.contextId);
 	}
-	/** Record bodies that were rendered without proving contiguity. */
+	/** Record bodies that were rendered without proving contiguity, in the current context. */
 	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);
-		}
+		this.bookExact(target, seqs, this.contextId);
 	}
 	/**
 	* Attest that the model saw the context of an interrupt (`outcome.interrupt`
@@ -11060,32 +11288,75 @@ var SeenFrontier = class SeenFrontier {
 		this.recordUpTo(held.target, held.seenUpToSeq);
 		return true;
 	}
-	/** What to attest on a send or claim to `target`; omits `seenUpToSeq` when nothing contiguous is known. */
+	/**
+	* What to attest on a send or claim to `target`; omits `seenUpToSeq` when
+	* nothing contiguous is known. With a current context, only bookings made
+	* in that context count.
+	*/
 	attestation(target) {
-		const state = this.targets.get(this.canonical(target));
+		const state = this.core.targets.get(this.canonical(target));
 		if (!state) return { seenExactSeqs: [] };
+		const context = this.contextId;
+		const upTo = context === null || state.upToContext === context ? state.upTo : void 0;
+		const exact = context === null || state.exactContext === context ? [...state.exact] : [];
 		return {
-			...state.upTo === void 0 ? {} : { seenUpToSeq: state.upTo },
-			seenExactSeqs: [...state.exact].sort((a, b) => a - b)
+			...upTo === void 0 ? {} : { seenUpToSeq: upTo },
+			seenExactSeqs: exact.filter((seq) => upTo === void 0 || seq > upTo).sort((a, b) => a - b)
 		};
 	}
 	snapshot() {
 		const targets = {};
-		for (const [target, state] of this.targets) targets[target] = {
+		for (const [target, state] of this.core.targets) targets[target] = {
 			...state.upTo === void 0 ? {} : { upTo: state.upTo },
-			...state.exact.size === 0 ? {} : { exact: [...state.exact].sort((a, b) => a - b) }
+			...state.exact.size === 0 ? {} : { exact: [...state.exact].sort((a, b) => a - b) },
+			...state.upTo === void 0 || state.upToContext === null ? {} : { upToContextId: state.upToContext },
+			...state.exact.size === 0 || state.exactContext === null ? {} : { exactContextId: state.exactContext }
 		};
 		return {
 			version: 1,
 			targets,
-			aliases: Object.fromEntries(this.aliases)
+			aliases: Object.fromEntries(this.core.aliases),
+			...this.core.context === null ? {} : { contextId: this.core.context }
 		};
 	}
+	/** A high-water booking (seenPolicy `bookStreamEntries`): another context's record is replaced, not merged. */
+	bookUpTo(target, seq, context) {
+		if (!positiveInt(seq)) return;
+		const state = this.state(this.canonical(target));
+		if (state.exact.size > 0 && state.exactContext !== context) state.exact.clear();
+		if (state.upTo === void 0 || state.upToContext !== context || seq > state.upTo) state.upTo = seq;
+		state.upToContext = context;
+		state.exactContext = context;
+		for (const exact of state.exact) if (exact <= state.upTo) state.exact.delete(exact);
+	}
+	/** A sparse booking (seenPolicy `bookExactSeqs`): merges within a context, replaces across; never moves `upTo`. */
+	bookExact(target, seqs, context) {
+		const state = this.state(this.canonical(target));
+		if (state.exactContext !== context) {
+			state.exact.clear();
+			state.exactContext = context;
+		}
+		const floor = state.upToContext === context ? state.upTo : void 0;
+		for (const seq of seqs) {
+			if (!positiveInt(seq)) continue;
+			if (floor !== void 0 && seq <= floor) 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);
+		}
+	}
 	state(target) {
-		let state = this.targets.get(target);
+		let state = this.core.targets.get(target);
 		if (!state) {
-			state = { exact: /* @__PURE__ */ new Set() };
-			this.targets.set(target, state);
+			state = {
+				upToContext: null,
+				exact: /* @__PURE__ */ new Set(),
+				exactContext: null
+			};
+			this.core.targets.set(target, state);
 		}
 		return state;
 	}
@@ -11158,7 +11429,18 @@ function latestReadThreadFromCliReadState(raw) {
 	};
 }
 //#endregion
+//#region ../shared/src/agentOps/requestSchema.ts
+function requestSchema() {
+	return (schema) => schema;
+}
+//#endregion
 //#region ../shared/src/agentOps/inbox.ts
+const inboxPullFields = {
+	since: number$1().int().nonnegative().optional().describe("Cursor of the previous batch; under cursor acks it acknowledges that batch. Omit to continue from the last committed cursor."),
+	limit: number$1().int().positive().optional().describe("Messages per batch, 1..200 (Server default 50)."),
+	ack: _enum(["cursor", "immediate"]).optional().describe("cursor (default): a batch is acknowledged by the next pull; immediate: acknowledged as it is returned.")
+};
+const checkInboxRequestSchema = requestSchema()(object(inboxPullFields));
 const MAX_DRAIN_ROUNDS = 50;
 function batchNext(batch) {
 	if (batch.hasMore) return {
@@ -11197,6 +11479,8 @@ function recordExactSeen(frontier, messages) {
 }
 /** One bounded pull. Records exact seen seqs on `frontier` (sparse drains never advance the high-water mark). */
 async function checkInbox(client, request = {}, frontier) {
+	const invalid = validateOpRequest(checkInboxRequestSchema, request);
+	if (invalid) return invalid;
 	const ack = request.ack ?? "cursor";
 	const result = await client.events.get({
 		since: request.since === void 0 ? "latest" : String(request.since),
@@ -11223,6 +11507,7 @@ async function checkInbox(client, request = {}, frontier) {
 		text: batchText(batch)
 	};
 }
+const drainInboxRequestSchema = requestSchema()(object(inboxPullFields));
 /**
 * Pull until the Server reports nothing more, like `raft message check`, but
 * as an async iterator so that acknowledgement follows consumption: under
@@ -11235,6 +11520,15 @@ async function checkInbox(client, request = {}, frontier) {
 */
 async function* drainInbox(client, request = {}, frontier, onPull) {
 	const ack = request.ack ?? "cursor";
+	const invalid = validateOpRequest(drainInboxRequestSchema, request);
+	if (invalid) return {
+		cursor: null,
+		ackMode: ack,
+		rounds: 0,
+		hasMore: true,
+		stillUnreadConversations: null,
+		error: invalid
+	};
 	let cursor = request.since ?? null;
 	let ackMode = ack;
 	let stillUnread = null;
@@ -11295,6 +11589,47 @@ async function* drainInbox(client, request = {}, frontier, onPull) {
 		error: null
 	};
 }
+/** Fold a finished drain into one outcome; a drain that failed before its first batch is that failure. */
+function drainedInboxOutcome(batches, summary) {
+	if (summary.error && batches.length === 0) return summary.error;
+	const messages = batches.flatMap((batch) => batch.messages);
+	const lines = [formatAgentMessages(messages.map((m) => toAgentMessageLike(m.raw)))];
+	if (summary.error) lines.push("The drain stopped early on an error; more messages may be pending. Check the inbox again.");
+	else if (summary.hasMore) lines.push("More messages are pending. Check the inbox again.");
+	else if (messages.length > 0) lines.push("No more new inbox messages.");
+	const stillUnread = summary.stillUnreadConversations ?? 0;
+	if (stillUnread > 0) lines.push(formatAgentInboxHint({ unread_conversations: stillUnread }));
+	const first = messages[0];
+	const next = summary.hasMore ? {
+		kind: "check_inbox_again",
+		command: "raft message check",
+		why: "More messages are pending."
+	} : stillUnread > 0 ? {
+		kind: "list_inbox",
+		command: "raft inbox check",
+		why: "Conversations remain unread beyond this drain."
+	} : first ? {
+		kind: "reply_or_act",
+		args: { target: first.target },
+		why: "Handle the messages above; reply where each one came from."
+	} : null;
+	return {
+		ok: true,
+		state: messages.length > 0 ? "batch" : "empty",
+		data: {
+			messages,
+			batches: batches.length,
+			summary
+		},
+		next,
+		text: lines.join("\n")
+	};
+}
+const listInboxRequestSchema = requestSchema()(object({
+	view: _enum(["unread", "mentions"]).optional().describe("unread (default): every unread conversation; mentions: only those that @mention you."),
+	before: number$1().int().nonnegative().optional().describe("Next page: the nextBeforeSeq of the previous page."),
+	limit: number$1().int().positive().optional().describe("Conversations per page, 1..50 (Server default 20).")
+}));
 function openCommandFor(item) {
 	return `raft message read --target "${item.target}" --after ${item.lastReadSeq}`;
 }
@@ -11330,6 +11665,8 @@ function listingText(listing) {
 }
 /** The agent's Activity panel. Lists only; nothing is consumed. */
 async function listInbox(client, request = {}) {
+	const invalid = validateOpRequest(listInboxRequestSchema, request);
+	if (invalid) return invalid;
 	const result = await client.inbox.list({
 		...request.view && request.view !== "unread" ? { view: request.view } : {},
 		...request.before === void 0 ? {} : { before_seq: String(request.before) },
@@ -11364,6 +11701,16 @@ async function listInbox(client, request = {}) {
 }
 //#endregion
 //#region ../shared/src/agentOps/messages.ts
+/** A conversation target as agents spell it. */
+const raftTargetSchema = string().describe("Conversation: `#channel`, `dm:@peer`, or a thread `#channel:shortid` / `dm:@peer:shortid`.");
+const readHistoryRequestSchema = requestSchema()(object({
+	target: raftTargetSchema,
+	after: number$1().int().nonnegative().optional().describe("Only messages after this seq (exclusive): read what is new since a position, for example the `--after` an inbox listing prints."),
+	before: number$1().int().nonnegative().optional().describe("Only messages before this seq (exclusive): browse older history."),
+	around: union([number$1().int(), string()]).optional().describe("Anchor a window around a message: its seq number (for example \"12345\") or its message id."),
+	limit: number$1().int().positive().optional().describe("Maximum messages in the window."),
+	consume: boolean().optional().describe("false reads without consuming: the conversation is not marked read and nothing counts as seen.")
+}));
 function historyNext(page) {
 	const seqs = page.messages.map((m) => m.seq).filter((s) => s !== null);
 	if (page.hasNewer && seqs.length > 0) {
@@ -11416,6 +11763,8 @@ function recordHistorySeen(frontier, requested, page, around) {
 	frontier.recordExact(page.target, seqs);
 }
 async function readHistory(client, request, frontier) {
+	const invalid = validateOpRequest(readHistoryRequestSchema, request);
+	if (invalid) return invalid;
 	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,
@@ -11446,6 +11795,24 @@ async function readHistory(client, request, frontier) {
 }
 /** Attempts for a keyed send whose request never reached the Server (transport failure only). */
 const SEND_TRANSPORT_ATTEMPTS = 3;
+const sendMessageFields = {
+	content: string().describe("Message text (Markdown). May be empty only when attachmentIds are given."),
+	attachmentIds: array(string()).optional().describe("Attachment ids from an upload, posted with this message."),
+	idempotencyKey: string().optional().describe("One key per logical message; generated when omitted. Reuse it to retry, and to resume an interrupted send (interrupt.resume.idempotencyKey)."),
+	mentions: array(agentApiStructuredMentionSchema).optional().describe("Structured @mentions (user or agent id and name), in addition to @handles in the text."),
+	seen: object({
+		upToSeq: number$1().int().nonnegative().optional(),
+		exactSeqs: array(number$1().int().positive()).optional()
+	}).optional().describe("Override the seen attestation for this send (runtimes that track what their model saw themselves).")
+};
+const sendMessageRequestSchema = requestSchema()(object({
+	target: raftTargetSchema,
+	...sendMessageFields
+}));
+const replyToRequestSchema = requestSchema()(object({
+	message: object({ target: raftTargetSchema }).describe("The received message to reply to; only its `target` is used."),
+	...sendMessageFields
+}));
 /** Today's held text (unchanged); it is the interrupt's `context` and the outcome's `text`. */
 function heldText(held, action) {
 	const noun = held.newMessageCount === 1 ? "message" : "messages";
@@ -11509,6 +11876,8 @@ function sentOutcome(target, data) {
 	};
 }
 async function sendMessage(client, request, frontier) {
+	const invalid = validateOpRequest(sendMessageRequestSchema, request);
+	if (invalid) return invalid;
 	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();
@@ -11712,7 +12081,21 @@ function formatAgentTaskHistory(data) {
 }
 //#endregion
 //#region ../shared/src/agentOps/tasks.ts
+const taskChannelSchema = string().describe("The channel the task board belongs to, for example `#proj-sdk`.");
+const taskNumberSchema = number$1().int().positive().describe("The task number on that channel's board.");
+const raftTaskStatusSchema = _enum([
+	"todo",
+	"in_progress",
+	"in_review",
+	"done",
+	"closed"
+]);
 const TASK_CLAIM_REASON_ALREADY_CLAIMED_BY_YOU = "already claimed by you";
+const claimTasksRequestSchema = requestSchema()(object({
+	target: taskChannelSchema,
+	taskNumbers: array(number$1().int().positive()).optional().describe("Task numbers to claim."),
+	messageIds: array(string()).optional().describe("Full or short ids of top-level messages to claim as tasks.")
+}));
 /**
 * A held task call: the interrupt whose resume is the identical command, with
 * no cancel (a held task call saved nothing). `context` is today's held text.
@@ -11761,6 +12144,8 @@ function claimText(claim) {
 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);
+	const invalid = validateOpRequest(claimTasksRequestSchema, request);
+	if (invalid) return invalid;
 	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({
@@ -11812,7 +12197,21 @@ async function claimTasks(client, request) {
 		text: claimText(claim)
 	};
 }
+const listTasksRequestSchema = requestSchema()(object({
+	target: string().optional().describe("A channel's board, for example `#proj-sdk`. Pass exactly one of target or mine."),
+	mine: boolean().optional().describe("true: your own tasks across channels instead of one board."),
+	status: _enum([
+		"todo",
+		"in_progress",
+		"in_review",
+		"done",
+		"closed",
+		"all"
+	]).optional().describe("Filter by status; all includes done and closed.")
+}));
 async function listTasks(client, request) {
+	const invalid = validateOpRequest(listTasksRequestSchema, request);
+	if (invalid) return invalid;
 	const mine = request.mine === true;
 	if (mine === Boolean(request.target?.trim())) return failureOutcome(opError("INVALID_REQUEST", { message: "Pass exactly one of a channel target or mine: true." }));
 	const result = await client.tasks.list({
@@ -11846,7 +12245,17 @@ async function listTasks(client, request) {
 		text
 	};
 }
+const createTasksRequestSchema = requestSchema()(object({
+	target: taskChannelSchema,
+	tasks: array(object({
+		title: string().describe("Task title."),
+		createsResource: boolean().optional().describe("The task produces a resource (for example a document) that needs a receipt.")
+	})).describe("One entry per task to create."),
+	assignee: string().optional().describe("`@handle`: yourself to start in_progress, or (owner/admin) someone else to reserve a todo.")
+}));
 async function createTasks(client, request) {
+	const invalid = validateOpRequest(createTasksRequestSchema, request);
+	if (invalid) return invalid;
 	if (!request.target?.trim() || !request.tasks?.length) return failureOutcome(opError("INVALID_REQUEST", { message: "A channel target and at least one task title are required." }));
 	const result = await client.tasks.create({
 		channel: request.target,
@@ -11875,7 +12284,14 @@ async function createTasks(client, request) {
 		text: formatAgentTasksCreated(request.target, data)
 	};
 }
-function requireTaskRef(request) {
+const taskRefFields = {
+	target: taskChannelSchema,
+	taskNumber: taskNumberSchema
+};
+const taskRefSchema = requestSchema()(object(taskRefFields));
+function requireTaskRef(request, schema = taskRefSchema) {
+	const invalid = validateOpRequest(schema, request);
+	if (invalid) return invalid;
 	if (!request.target?.trim() || !Number.isInteger(request.taskNumber) || request.taskNumber <= 0) return failureOutcome(opError("INVALID_REQUEST", { message: "A channel target and a positive task number are required." }));
 	return null;
 }
@@ -11895,8 +12311,13 @@ async function unclaimTask(client, request) {
 		text: formatAgentTaskUnclaimed(request.taskNumber)
 	};
 }
+const assignTaskRequestSchema = requestSchema()(object({
+	...taskRefFields,
+	assignee: string().trim().min(1).describe("`@handle` to assign (yourself, or someone else if you are an owner/admin). To clear an assignment use tasks.unassign."),
+	expectedRevision: number$1().int().nonnegative().optional().describe("Revision of the task you just read; the change is refused if it moved.")
+}));
 async function assignTask(client, request) {
-	const invalid = requireTaskRef(request);
+	const invalid = requireTaskRef(request, assignTaskRequestSchema);
 	if (invalid) return invalid;
 	const result = await client.tasks.assign({
 		channel: request.target,
@@ -11919,6 +12340,38 @@ async function assignTask(client, request) {
 		text: formatAgentTaskAssigned(request.taskNumber, assignee)
 	};
 }
+const unassignTaskRequestSchema = requestSchema()(object({
+	...taskRefFields,
+	expectedRevision: number$1().int().nonnegative().optional().describe("Revision of the task you just read; the change is refused if it moved.")
+}));
+/** Clear a task's assignee (the CLI's `raft task unassign`): the explicit way to clear, never an omitted `assignee`. */
+async function unassignTask(client, request) {
+	const invalid = requireTaskRef(request, unassignTaskRequestSchema);
+	if (invalid) return invalid;
+	const result = await client.tasks.assign({
+		channel: request.target,
+		task_number: request.taskNumber,
+		assignee: null,
+		...request.expectedRevision === void 0 ? {} : { expected_revision: request.expectedRevision }
+	});
+	if (!result.ok) return failureFromClientResult(result);
+	return {
+		ok: true,
+		state: "unassigned",
+		data: {
+			target: request.target,
+			taskNumber: request.taskNumber,
+			assignee: null,
+			revision: result.data.revision
+		},
+		next: null,
+		text: formatAgentTaskAssigned(request.taskNumber, null)
+	};
+}
+const updateTaskStatusRequestSchema = requestSchema()(object({
+	...taskRefFields,
+	status: raftTaskStatusSchema.describe("todo → in_progress → in_review → done; closed from anywhere.")
+}));
 /** A held task write: the interrupt whose resume is the identical command; nothing to cancel. */
 function heldTaskWrite(target, data, action, kind, argv) {
 	const interrupt = heldTaskInterrupt(target, data, action, "After reviewing, repeat the operation if it is still correct.", argv);
@@ -11936,7 +12389,7 @@ function heldTaskWrite(target, data, action, kind, argv) {
 	};
 }
 async function updateTaskStatus(client, request) {
-	const invalid = requireTaskRef(request);
+	const invalid = requireTaskRef(request, updateTaskStatusRequestSchema);
 	if (invalid) return invalid;
 	const result = await client.tasks.updateStatus({
 		channel: request.target,
@@ -11956,6 +12409,11 @@ async function updateTaskStatus(client, request) {
 		text: formatAgentTaskStatusUpdated(request.taskNumber, request.status)
 	};
 }
+const amendTaskRequestSchema = requestSchema()(object({
+	...taskRefFields,
+	title: string().optional().describe("New title."),
+	description: string().nullable().optional().describe("New description; null clears it.")
+}));
 function taskAmendArgv(request) {
 	return [
 		"task",
@@ -11969,7 +12427,7 @@ function taskAmendArgv(request) {
 	];
 }
 async function amendTask(client, request) {
-	const invalid = requireTaskRef(request);
+	const invalid = requireTaskRef(request, amendTaskRequestSchema);
 	if (invalid) return invalid;
 	if (request.title === void 0 && request.description === void 0) return failureOutcome(opError("INVALID_REQUEST", { message: "Pass a new title, a new description, or description: null to clear it." }));
 	const result = await client.tasks.amend({
@@ -12010,7 +12468,13 @@ async function taskHistory(client, request) {
 		text: formatAgentTaskHistory(result.data)
 	};
 }
+const convertMessageToTaskRequestSchema = requestSchema()(object({
+	target: taskChannelSchema,
+	messageId: string().describe("Full or short id of a top-level message in that channel.")
+}));
 async function convertMessageToTask(client, request) {
+	const invalid = validateOpRequest(convertMessageToTaskRequestSchema, request);
+	if (invalid) return invalid;
 	if (!request.target?.trim() || !request.messageId?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A channel target and a message id are required." }));
 	const result = await client.tasks.convert({
 		channel: request.target,
@@ -12606,6 +13070,15 @@ function formatAgentProfile(profile, options = {}) {
 }
 //#endregion
 //#region ../shared/src/agentOps/channels.ts
+/** `{ target }` of a regular channel (join, leave, mute, unmute). */
+const channelTargetRequestSchema = requestSchema()(object({ target: string().describe("A regular channel, `#channel-name`. DMs and threads are not accepted.") }));
+const channelMembersRequestSchema = requestSchema()(object({ target: string().describe("A channel, DM, or thread target.") }));
+/** `threads.list` takes no arguments. */
+const listThreadsRequestSchema = object({});
+const unfollowThreadRequestSchema = requestSchema()(object({
+	target: string().describe("The thread, for example `#channel:shortid` or `dm:@peer:shortid`."),
+	reason: string().optional().describe("Short reason, kept with the unfollow.")
+}));
 const INVALID_CHANNEL_TARGET = "Target must be a regular channel in the form '#channel-name'. DMs and thread targets are not supported.";
 async function resolveRegularChannel(client, target) {
 	const name = parseRaftRegularChannelTarget$1(target ?? "");
@@ -12624,6 +13097,8 @@ async function resolveRegularChannel(client, target) {
 	};
 }
 async function joinChannel(client, request) {
+	const invalid = validateOpRequest(channelTargetRequestSchema, request);
+	if (invalid) return invalid;
 	const result = await joinRaftChannelByTarget$1(client, { target: request.target });
 	if (!result.ok) {
 		const error = result.error;
@@ -12657,6 +13132,8 @@ async function joinChannel(client, request) {
 	};
 }
 async function leaveChannel(client, request) {
+	const invalid = validateOpRequest(channelTargetRequestSchema, request);
+	if (invalid) return invalid;
 	const channel = await resolveRegularChannel(client, request.target);
 	if ("ok" in channel) return channel;
 	if (!channel.joined) return {
@@ -12689,6 +13166,8 @@ function formatSeq(value) {
 	return value == null ? "none" : String(value);
 }
 async function setChannelMute(client, request, action) {
+	const invalid = validateOpRequest(channelTargetRequestSchema, request);
+	if (invalid) return invalid;
 	const channel = await resolveRegularChannel(client, request.target);
 	if ("ok" in channel) return channel;
 	const result = action === "mute" ? await client.channels.mute({ channelId: channel.id }, {}) : await client.channels.unmute({ channelId: channel.id });
@@ -12731,6 +13210,8 @@ function unmuteChannel(client, request) {
 	return setChannelMute(client, request, "unmute");
 }
 async function channelMembers(client, request) {
+	const invalid = validateOpRequest(channelMembersRequestSchema, request);
+	if (invalid) return invalid;
 	if (!request.target?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A channel, DM, or thread target is required." }));
 	const result = await client.channels.members({ channel: request.target });
 	if (!result.ok) return failureFromClientResult(result);
@@ -12755,6 +13236,8 @@ async function listThreads(client) {
 	};
 }
 async function unfollowThread(client, request) {
+	const invalid = validateOpRequest(unfollowThreadRequestSchema, request);
+	if (invalid) return invalid;
 	if (!request.target?.includes(":")) return failureOutcome(opError("INVALID_REQUEST", { message: "A thread target is required, for example '#channel:shortid' or 'dm:@peer:shortid'." }));
 	const result = await client.threads.unfollow({
 		thread: request.target,
@@ -12771,6 +13254,21 @@ async function unfollowThread(client, request) {
 }
 //#endregion
 //#region ../shared/src/agentOps/server.ts
+const serverInfoRequestSchema = requestSchema()(object({
+	view: _enum([
+		"summary",
+		"full",
+		"channels",
+		"agents",
+		"humans"
+	]).optional().describe("summary (default): counts; full: the whole overview; channels / agents / humans: one paged section."),
+	offset: number$1().optional().describe("Section paging: rows to skip."),
+	limit: number$1().optional().describe("Section paging: rows per page (default 50)."),
+	joined: boolean().optional().describe("channels view only: only channels you have joined.")
+}));
+const showProfileRequestSchema = requestSchema()(object({ target: string().optional().describe("`@handle` of someone else; omit for your own profile.") }));
+/** The Agent API's profile body schema; at least one field is required (checked by the operation). */
+const updateProfileRequestSchema = agentApiProfileUpdateBodySchema;
 function nextCommand(section, request, offset, limit, total) {
 	const nextOffset = offset + limit;
 	if (nextOffset >= total) return void 0;
@@ -12784,6 +13282,8 @@ function nextCommand(section, request, offset, limit, total) {
 	return parts.join(" ");
 }
 async function serverInfo(client, request = {}) {
+	const invalid = validateOpRequest(serverInfoRequestSchema, request);
+	if (invalid) return invalid;
 	const result = await client.server.info();
 	if (!result.ok) return failureFromClientResult(result);
 	const server = result.data;
@@ -12849,6 +13349,8 @@ async function serverInfo(client, request = {}) {
 	};
 }
 async function showProfile(client, request = {}, options = {}) {
+	const invalid = validateOpRequest(showProfileRequestSchema, request);
+	if (invalid) return invalid;
 	const result = await client.profile.show(request.target ? { target: request.target } : {});
 	if (!result.ok) return failureFromClientResult(result);
 	return {
@@ -12860,6 +13362,8 @@ async function showProfile(client, request = {}, options = {}) {
 	};
 }
 async function updateProfile(client, request, options = {}) {
+	const invalid = validateOpRequest(updateProfileRequestSchema, request);
+	if (invalid) return invalid;
 	if (request.displayName === void 0 && request.description === void 0 && request.avatarUrl === void 0) return failureOutcome(opError("INVALID_REQUEST", { message: "Pass a displayName, description, or avatarUrl to update." }));
 	const result = await client.profile.update(request);
 	if (!result.ok) return failureFromClientResult(result);
@@ -12913,6 +13417,10 @@ function formatAgentAttachmentComments(attachmentId, comments, threadChannelId)
 }
 //#endregion
 //#region ../shared/src/agentOps/attachments.ts
+const attachmentCommentsRequestSchema = requestSchema()(object({
+	attachmentId: string().describe("The attachment id."),
+	limit: number$1().int().positive().optional().describe("Maximum comments to return.")
+}));
 /** Compatibility fallback for Servers that predate the capability endpoint (the CLI's constant). */
 const AGENT_ATTACHMENT_UPLOAD_FALLBACK_MAX_BYTES = 52428800;
 const FILENAME_MIME_MAP = {
@@ -13120,6 +13628,8 @@ async function downloadAttachment(client, request) {
 	};
 }
 async function attachmentComments(client, request) {
+	const invalid = validateOpRequest(attachmentCommentsRequestSchema, request);
+	if (invalid) return invalid;
 	if (!request.attachmentId?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "An attachment id is required." }));
 	const result = await client.attachments.comments({ attachmentId: request.attachmentId }, request.limit === void 0 ? {} : { limit: String(request.limit) });
 	if (!result.ok) return failureFromClientResult(result);
@@ -13136,101 +13646,12 @@ async function attachmentComments(client, request) {
 	};
 }
 //#endregion
-//#region ../shared/src/zonedTime.ts
-const MS_PER_SECOND = 1e3;
-const MS_PER_MINUTE = 6e4;
-const MS_PER_DAY = 864e5;
-const formatters = /* @__PURE__ */ new Map();
-function formatterFor(timeZone) {
-	let formatter = formatters.get(timeZone);
-	if (!formatter) {
-		formatter = new Intl.DateTimeFormat("en-US", {
-			timeZone,
-			hourCycle: "h23",
-			era: "short",
-			year: "numeric",
-			month: "numeric",
-			day: "numeric",
-			hour: "numeric",
-			minute: "numeric",
-			second: "numeric"
-		});
-		formatters.set(timeZone, formatter);
-	}
-	return formatter;
-}
-/** Days from 1970-01-01 to the proleptic Gregorian date (H. Hinnant's days_from_civil). */
-function daysFromCivil(year, month, day) {
-	const y = month <= 2 ? year - 1 : year;
-	const era = Math.floor(y / 400);
-	const yoe = y - era * 400;
-	const mp = (month + 9) % 12;
-	const doy = Math.floor((153 * mp + 2) / 5) + day - 1;
-	const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
-	return era * 146097 + doe - 719468;
-}
-/** The wall clock as milliseconds on a UTC timeline (no Date, so no 0-99 year quirk or range limit). */
-function wallClockMs(wall) {
-	return daysFromCivil(wall.year, wall.month, wall.day) * MS_PER_DAY + wall.hour * 36e5 + wall.minute * MS_PER_MINUTE + wall.second * MS_PER_SECOND + wall.millisecond;
-}
-function floorMod(value, modulus) {
-	return (value % modulus + modulus) % modulus;
-}
-/** Wall clock of `epochMs` in `timeZone` plus the exact offset in ms (seconds precision). */
-function wallClockAt(epochMs, timeZone) {
-	const parts = {};
-	for (const part of formatterFor(timeZone).formatToParts(epochMs)) parts[part.type] = part.value;
-	const eraYear = Number(parts.year);
-	const wall = {
-		year: /^b/i.test(parts.era ?? "") ? 1 - eraYear : eraYear,
-		month: Number(parts.month),
-		day: Number(parts.day),
-		hour: Number(parts.hour),
-		minute: Number(parts.minute),
-		second: Number(parts.second),
-		millisecond: floorMod(epochMs, MS_PER_SECOND)
-	};
-	return {
-		wall,
-		offsetMs: wallClockMs(wall) - epochMs
-	};
-}
-function offsetMinutesOf(offsetMs) {
-	return -Math.trunc(-offsetMs / MS_PER_MINUTE);
-}
-/** The wall clock and getTimezoneOffset-style offset of `epochMs` in `timeZone`. */
-function zonedInstant(epochMs, timeZone) {
-	const { wall, offsetMs } = wallClockAt(epochMs, timeZone);
-	return {
-		...wall,
-		offsetMinutes: offsetMinutesOf(offsetMs)
-	};
-}
-function pad2(n) {
-	return String(n).padStart(2, "0");
-}
-/** `+08:00` / `-04:00` / `+05:30`, as the CLI has always printed offsets. */
-function formatUtcOffset(offsetMinutes) {
-	const sign = offsetMinutes >= 0 ? "+" : "-";
-	const abs = Math.abs(offsetMinutes);
-	return `${sign}${pad2(Math.floor(abs / 60))}:${pad2(abs % 60)}`;
-}
-//#endregion
 //#region ../shared/src/agentText/search.ts
-/**
-* Wall-clock rendering with offset, as the CLI prints search hit times. With
-* `timeZone` (an IANA name) the time is rendered in that zone; without it, in
-* the process's local zone (the SDK's historical behaviour). The two agree
-* byte for byte when `timeZone` is the process zone.
-*/
-function formatLocalTimeWithOffset(iso, timeZone) {
+/** Local wall-clock rendering with offset, as the CLI prints search hit times. */
+function formatLocalTimeWithOffset(iso) {
 	const d = new Date(iso);
 	if (isNaN(d.getTime())) return iso;
 	const pad = (n) => String(n).padStart(2, "0");
-	if (timeZone !== void 0) {
-		const z = zonedInstant(d.getTime(), timeZone);
-		return `${z.year}-${pad(z.month)}-${pad(z.day)} ${pad(z.hour)}:${pad(z.minute)}:${pad(z.second)} ${formatUtcOffset(z.offsetMinutes)}`;
-	}
 	const offsetMinutes = -d.getTimezoneOffset();
 	const sign = offsetMinutes >= 0 ? "+" : "-";
 	const absOffset = Math.abs(offsetMinutes);
@@ -13353,11 +13774,8 @@ function renderSearchPreview(content, query) {
 		trailingOmit
 	].join("");
 }
-/**
-* Search results with <match>/<omit /> preview markup. Hit times render in
-* `timeZone` when given, else in the process's local zone.
-*/
-function formatAgentSearchResults(query, data, offset, sort, limit, timeZone) {
+/** Search results with <match>/<omit /> preview markup. */
+function formatAgentSearchResults(query, data, offset, sort, limit) {
 	const trimmedQuery = query.trim();
 	const oldestShown = data.results?.length ? data.results[data.results.length - 1]?.createdAt : void 0;
 	const nextPageHint = sort === "recent" && oldestShown ? `page with --before ${oldestShown} (pages OLDER only; NOT a complete traversal: stored times are microsecond but this key is millisecond, so rows inside the boundary millisecond can be skipped, and a full page sharing one timestamp can repeat indefinitely; copy the key verbatim)` : `page with --offset ${(offset ?? 0) + (data.results?.length ?? 0)}`;
@@ -13377,7 +13795,7 @@ function formatAgentSearchResults(query, data, offset, sort, limit, timeZone) {
 			`<result ref="${ref}">`,
 			`Source: ${renderSearchSource(result)}`,
 			`Sender: ${sender}${senderType}`,
-			`Time: ${result.createdAt ? formatLocalTimeWithOffset(result.createdAt, timeZone) : "-"}`,
+			`Time: ${result.createdAt ? formatLocalTimeWithOffset(result.createdAt) : "-"}`,
 			...taskProjection ? [taskProjection] : [],
 			"",
 			"<preview>",
@@ -13398,7 +13816,24 @@ function formatAgentSearchResults(query, data, offset, sort, limit, timeZone) {
 }
 //#endregion
 //#region ../shared/src/agentOps/search.ts
+const searchMessagesRequestSchema = requestSchema()(object({
+	query: string().optional().describe("Free-text query; may be omitted when filtering by target or sender."),
+	target: string().optional().describe("Only this channel, DM, or thread."),
+	sender: string().optional().describe("Only messages from this handle."),
+	sort: _enum(["relevance", "recent"]).optional(),
+	before: string().optional().describe("ISO timestamp; only messages at or before it."),
+	after: string().optional().describe("ISO timestamp; only messages at or after it."),
+	limit: number$1().int().positive().optional().describe("Results per page, 1..50 (Server default 20)."),
+	offset: number$1().int().nonnegative().optional().describe("Skip this many results (paging).")
+}));
+const resolveMessageRequestSchema = requestSchema()(object({ messageId: string().describe("Full or short message id.") }));
+const reactRequestSchema = requestSchema()(object({
+	messageId: string().describe("Full or short message id."),
+	emoji: string().describe("One reaction emoji.")
+}));
 async function searchMessages(client, request) {
+	const invalid = validateOpRequest(searchMessagesRequestSchema, request);
+	if (invalid) return invalid;
 	if (!request.query?.trim() && !request.target && !request.sender) return failureOutcome(opError("INVALID_REQUEST", { message: "Pass a query, or filter by target or sender." }));
 	const result = await client.messages.search({
 		...request.query?.trim() ? { q: request.query.trim() } : {},
@@ -13438,6 +13873,8 @@ async function searchMessages(client, request) {
 	};
 }
 async function resolveMessage(client, request) {
+	const invalid = validateOpRequest(resolveMessageRequestSchema, request);
+	if (invalid) return invalid;
 	if (!request.messageId?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A message id is required." }));
 	const result = await client.messages.resolve({ msgId: request.messageId });
 	if (!result.ok) return failureFromClientResult(result);
@@ -13460,6 +13897,8 @@ async function resolveMessage(client, request) {
 	};
 }
 async function reactToMessage(client, request, action = "add") {
+	const invalid = validateOpRequest(reactRequestSchema, request);
+	if (invalid) return invalid;
 	const emoji = request.emoji?.trim();
 	if (!request.messageId?.trim() || !emoji || /\s/.test(emoji) || emoji.length > 16) return failureOutcome(opError("INVALID_REQUEST", { message: "A message id and a single reaction emoji are required." }));
 	const params = { msgId: request.messageId };
@@ -13661,7 +14100,15 @@ function formatAgentSenderMentionDeliveries(messageId, deliveries) {
 }
 //#endregion
 //#region ../shared/src/agentOps/mentions.ts
+const pendingMentionActionsRequestSchema = requestSchema()(object({ limit: number$1().int().positive().optional().describe("Maximum pending mentions to list.") }));
+const executeMentionActionRequestSchema = requestSchema()(object({
+	action: _enum(["notify", "add"]).describe("notify: tell the mentioned target about the message; add: add them to the conversation."),
+	resolutionIds: array(string()).describe("resolutionId values from mentions.pending.")
+}));
+const senderMentionDeliveriesRequestSchema = requestSchema()(object({ messageId: string().describe("Id of a message you sent.") }));
 async function pendingMentionActions(client, request = {}) {
+	const invalid = validateOpRequest(pendingMentionActionsRequestSchema, request);
+	if (invalid) return invalid;
 	const result = await client.mentions.pendingActions(request.limit === void 0 ? {} : { limit: String(request.limit) });
 	if (!result.ok) return failureFromClientResult(result);
 	const actions = normalizeAgentPendingMentionActions(result.data);
@@ -13693,6 +14140,8 @@ async function pendingMentionActions(client, request = {}) {
 	};
 }
 async function executeMentionAction(client, request) {
+	const invalid = validateOpRequest(executeMentionActionRequestSchema, request);
+	if (invalid) return invalid;
 	const ids = (request.resolutionIds ?? []).map((id) => id.trim()).filter(Boolean);
 	if (ids.length === 0 || request.action !== "notify" && request.action !== "add") return failureOutcome(opError("INVALID_REQUEST", { message: "Pass an action (notify | add) and at least one resolution id." }));
 	const result = await client.mentions.executeAction({
@@ -13713,6 +14162,8 @@ async function executeMentionAction(client, request) {
 	};
 }
 async function senderMentionDeliveries(client, request) {
+	const invalid = validateOpRequest(senderMentionDeliveriesRequestSchema, request);
+	if (invalid) return invalid;
 	if (!request.messageId?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A message id is required." }));
 	const result = await client.mentions.senderDeliveries({ messageId: request.messageId });
 	if (!result.ok) return failureFromClientResult(result);
@@ -13745,11 +14196,26 @@ function formatAgentKnowledgeStdout(content) {
 }
 //#endregion
 //#region ../shared/src/agentOps/manual.ts
+const manualContextFields = {
+	intent: string().min(12).max(500).describe("What the user wants to accomplish with Raft, in a few words. Never a prompt, credential, URL, or message text."),
+	reason: string().min(12).max(500).describe("Why the Manual is needed now, in a few words. Same rules as intent.")
+};
+const getManualTopicRequestSchema = requestSchema()(object({
+	topic: string().describe("Topic id (slug), for example one returned by manual.search."),
+	...manualContextFields
+}));
+const searchManualRequestSchema = requestSchema()(object({
+	query: string().describe("Search keywords."),
+	scope: string().optional().describe("Restrict the search to one Manual section."),
+	...manualContextFields
+}));
 function requireContext(context) {
 	if (!context?.intent?.trim() || !context?.reason?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "Manual calls need a short `intent` and `reason`." }));
 	return null;
 }
 async function getManualTopic(client, request) {
+	const malformed = validateOpRequest(getManualTopicRequestSchema, request);
+	if (malformed) return malformed;
 	const invalid = requireContext(request);
 	if (invalid) return invalid;
 	if (!request.topic?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A topic id is required." }));
@@ -13768,6 +14234,8 @@ async function getManualTopic(client, request) {
 	};
 }
 async function searchManual(client, request) {
+	const malformed = validateOpRequest(searchManualRequestSchema, request);
+	if (malformed) return malformed;
 	const invalid = requireContext(request);
 	if (invalid) return invalid;
 	if (!request.query?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "Search keywords are required." }));
@@ -13956,14 +14424,63 @@ var RaftStateSession = class {
 	}
 };
 //#endregion
+//#region ../shared/src/agentOps/seenPolicy/consumedSeqs.ts
+function getParentTargetForThread(target) {
+	if (target.startsWith("dm:@")) {
+		const separatorIndex = target.indexOf(":", 4);
+		return separatorIndex > 0 ? target.slice(0, separatorIndex) : null;
+	}
+	if (target.startsWith("#")) {
+		const separatorIndex = target.indexOf(":");
+		return separatorIndex > 0 ? target.slice(0, separatorIndex) : null;
+	}
+	return null;
+}
+//#endregion
 //#region ../shared/src/agentOps/actions.ts
+/**
+* The Agent API's own body schema (a discriminated union over the card
+* types), so the SDK checks exactly what the Server checks. The operation
+* manifest projects it flattened (see the SDK's operations.ts).
+*/
+const prepareActionCardRequestSchema = agentApiActionPrepareBodySchema;
 /** Text is the CLI's `raft action prepare` output. */
 function formatAgentActionCardPosted(target, messageId) {
 	const shortId = messageId ? messageId.slice(0, 8) : null;
 	return shortId ? `Action card posted to ${target} as message ${messageId} (short ${shortId}). The human can click the action verb to commit.\n` : `Action card posted to ${target}.\n`;
 }
+/**
+* Where the card's outcome arrives (Server #8604): when a human executes the
+* card, or execution fails, the Server posts a system reply that @mentions
+* the preparer in the card's own thread; a card posted inside a thread has no
+* thread of its own, so the reply lands in that same thread.
+*/
+function awaitConfirmationNext(target, messageId) {
+	const short = messageId.slice(0, 8);
+	if (getParentTargetForThread(target) !== null) return {
+		kind: "await_confirmation",
+		command: `raft message read --target "${target}" --around ${short}`,
+		args: {
+			target,
+			messageId
+		},
+		why: "A human must click the card to commit it. When it is executed (or fails), the outcome arrives as a reply in this thread that @mentions you; you do not need to poll."
+	};
+	const thread = agentTaskThreadTarget(target, messageId);
+	return {
+		kind: "await_confirmation",
+		command: `raft message read --target "${thread}"`,
+		args: {
+			target: thread,
+			messageId
+		},
+		why: "A human must click the card to commit it. When it is executed (or fails), the outcome arrives as a reply in the card's thread that @mentions you; you do not need to poll."
+	};
+}
 async function prepareActionCard(client, request) {
-	if (!request?.target?.trim() || !request.action) return failureOutcome(opError("INVALID_REQUEST", { message: "A target and an action are required to prepare a card." }));
+	if (typeof request?.target !== "string" || !request.target.trim() || !request.action) return failureOutcome(opError("INVALID_REQUEST", { message: "A target and an action are required to prepare a card." }));
+	const invalid = validateOpRequest(prepareActionCardRequestSchema, request);
+	if (invalid) return invalid;
 	const result = await client.actions.prepare(request);
 	if (!result.ok) return failureFromClientResult(result);
 	const card = {
@@ -13974,15 +14491,7 @@ async function prepareActionCard(client, request) {
 		ok: true,
 		state: "prepared",
 		data: card,
-		next: {
-			kind: "await_confirmation",
-			command: `raft message read --target "${request.target}" --around ${card.messageId.slice(0, 8)}`,
-			args: {
-				target: request.target,
-				messageId: card.messageId
-			},
-			why: "A human must click the card to commit it. You are not notified of the result yet; read the card message to see its state instead of waiting."
-		},
+		next: awaitConfirmationNext(request.target, card.messageId),
 		text: formatAgentActionCardPosted(request.target, card.messageId)
 	};
 }
@@ -14042,6 +14551,695 @@ async function readLatestReadThread(options = {}) {
 	return latestReadThreadFromCliReadState(raw);
 }
 //#endregion
+//#region src/operationSchemas.ts
+/** `identity.whoami` takes no arguments. */
+const whoamiRequestSchema = object({});
+/** `inbox.commit`: no cursor commits the pending batch; a cursor commits up to it. */
+const commitInboxRequestSchema = requestSchema()(object({ cursor: number$1().int().nonnegative().nullable().optional().describe("Commit up to this batch cursor; omit to commit the batch the last inbox pull returned.") }));
+//#endregion
+//#region src/toolSchema.ts
+/** Every keyword the subset allows. */
+const RAFT_JSON_SCHEMA_KEYWORDS = [
+	"type",
+	"description",
+	"properties",
+	"required",
+	"items",
+	"enum",
+	"minimum",
+	"maximum",
+	"minLength",
+	"maxLength"
+];
+const PRIMITIVES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"null"
+]);
+const SAFE = Number.MAX_SAFE_INTEGER;
+function isRaw(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function jsonTypeOf(value) {
+	if (value === null) return "null";
+	if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+	if (typeof value === "boolean") return "boolean";
+	return "string";
+}
+function project(node, where, options) {
+	if (!isRaw(node)) throw new Error(`${where}: not a JSON Schema object`);
+	const branches = node.anyOf ?? node.oneOf;
+	if (Array.isArray(branches)) {
+		const projected = branches.map((branch, index) => project(branch, `${where}|${index}`, options));
+		const flattened = projected.every((b) => b.type !== void 0 && b.type !== "array" && b.type !== "object") ? primitiveUnion(projected, where, options) : flattenDiscriminatedUnion(projected, where);
+		return typeof node.description === "string" ? {
+			...flattened,
+			description: node.description
+		} : flattened;
+	}
+	if (node.allOf !== void 0 || node.$ref !== void 0 || node.not !== void 0) throw new Error(`${where}: allOf / $ref / not cannot be projected to the tool-schema subset`);
+	const out = {};
+	if (node.type !== void 0) {
+		if (Array.isArray(node.type)) throw new Error(`${where}: type arrays are outside the tool-schema subset`);
+		const type = String(node.type);
+		if (type !== "object" && type !== "array" && !PRIMITIVES.has(type)) throw new Error(`${where}: unknown type ${type}`);
+		out.type = type;
+	}
+	if (typeof node.description === "string") out.description = node.description;
+	if (node.const !== void 0) {
+		out.enum = [node.const];
+		out.type ??= jsonTypeOf(node.const);
+	}
+	if (Array.isArray(node.enum)) out.enum = [...node.enum];
+	if (isRaw(node.properties)) {
+		out.properties = {};
+		const required = Array.isArray(node.required) ? node.required : [];
+		for (const [key, value] of Object.entries(node.properties)) {
+			if (required.includes(key) && isNullable(value)) throw new Error(`${where}.${key}: a required nullable field has no tool-schema form; make it optional (omitted = null)`);
+			out.properties[key] = project(value, `${where}.${key}`, options);
+		}
+		out.type ??= "object";
+	}
+	if (Array.isArray(node.required) && node.required.length > 0) out.required = [...node.required];
+	if (node.items !== void 0) out.items = project(node.items, `${where}[]`, options);
+	const integer = out.type === "integer";
+	const lower = [typeof node.minimum === "number" ? node.minimum : void 0, typeof node.exclusiveMinimum === "number" ? node.exclusiveMinimum + (integer ? 1 : 0) : void 0].filter((v) => v !== void 0 && v > -SAFE);
+	const upper = [typeof node.maximum === "number" ? node.maximum : void 0, typeof node.exclusiveMaximum === "number" ? node.exclusiveMaximum - (integer ? 1 : 0) : void 0].filter((v) => v !== void 0 && v < SAFE);
+	if (lower.length > 0) out.minimum = Math.max(...lower);
+	if (upper.length > 0) out.maximum = Math.min(...upper);
+	if (typeof node.minLength === "number" && node.minLength > 0) out.minLength = node.minLength;
+	if (typeof node.maxLength === "number") out.maxLength = node.maxLength;
+	return out;
+}
+function isNullable(node) {
+	if (!isRaw(node)) return false;
+	const branches = node.anyOf ?? node.oneOf;
+	return node.type === "null" || Array.isArray(branches) && branches.some((b) => isRaw(b) && b.type === "null");
+}
+/**
+* `T | null` → `T` (the field is optional, so omitting it is the JSON form of
+* null); any other union of primitives → the type the operation names in
+* `unionAs`. The branch constraints are dropped (looser).
+*/
+function primitiveUnion(branches, where, options) {
+	const types = [...new Set(branches.map((b) => b.type).filter((t) => t !== "null"))];
+	if (types.length === 1) return { type: types[0] };
+	const chosen = options.unionAs[where];
+	if (!chosen || !types.includes(chosen)) throw new Error(`${where}: a union of ${types.join(" | ")} needs unionAs (the one type to advertise)`);
+	return { type: chosen };
+}
+/** The one property every object branch pins to a distinct single value. */
+function discriminatorOf(branches) {
+	const first = branches[0];
+	if (!first?.properties) return null;
+	for (const key of Object.keys(first.properties)) {
+		const values = branches.map((b) => b.properties?.[key]?.enum);
+		if (values.every((v) => Array.isArray(v) && v.length === 1) && new Set(values.map((v) => v[0])).size === branches.length) return key;
+	}
+	return null;
+}
+function flattenDiscriminatedUnion(branches, where) {
+	if (!branches.every((b) => b.type === "object")) throw new Error(`${where}: only unions of primitives or discriminated unions of objects can be projected`);
+	const discriminator = discriminatorOf(branches);
+	if (!discriminator) throw new Error(`${where}: a union of objects needs a discriminator property to be flattened`);
+	const tags = branches.map((b) => b.properties[discriminator].enum[0]);
+	const properties = { [discriminator]: {
+		type: "string",
+		enum: tags,
+		description: `Which variant this is; the other fields apply per ${discriminator} as their descriptions say.`
+	} };
+	const order = [];
+	const byKey = /* @__PURE__ */ new Map();
+	branches.forEach((branch, index) => {
+		for (const [key, schema] of Object.entries(branch.properties ?? {})) {
+			if (key === discriminator) continue;
+			if (!byKey.has(key)) {
+				byKey.set(key, []);
+				order.push(key);
+			}
+			byKey.get(key).push({
+				tag: tags[index],
+				schema
+			});
+		}
+	});
+	for (const key of order) {
+		const uses = byKey.get(key);
+		const merged = uses.map((u) => u.schema).reduce(loosest);
+		const descriptions = [...new Set(uses.map((u) => u.schema.description).filter((d) => Boolean(d)))];
+		const usedBy = uses.length === branches.length ? "" : `Only for ${discriminator} ${uses.map((u) => u.tag).join(", ")}.`;
+		const description = [...descriptions, usedBy].filter(Boolean).join(" ");
+		const { description: _drop, ...rest } = merged;
+		properties[key] = description ? {
+			...rest,
+			description
+		} : rest;
+	}
+	return {
+		type: "object",
+		properties,
+		required: [discriminator]
+	};
+}
+/** The loosest schema accepting everything either side accepts (within the subset). */
+function loosest(a, b) {
+	if (JSON.stringify(a) === JSON.stringify(b)) return a;
+	const out = {};
+	if (a.type !== void 0 && a.type === b.type) out.type = a.type;
+	if (a.enum && b.enum) out.enum = [.../* @__PURE__ */ new Set([...a.enum, ...b.enum])];
+	if (a.minimum !== void 0 && b.minimum !== void 0) out.minimum = Math.min(a.minimum, b.minimum);
+	if (a.maximum !== void 0 && b.maximum !== void 0) out.maximum = Math.max(a.maximum, b.maximum);
+	if (a.minLength !== void 0 && b.minLength !== void 0) out.minLength = Math.min(a.minLength, b.minLength);
+	if (a.maxLength !== void 0 && b.maxLength !== void 0) out.maxLength = Math.max(a.maxLength, b.maxLength);
+	if (a.items && b.items) out.items = loosest(a.items, b.items);
+	if (a.properties && b.properties) {
+		out.properties = {};
+		for (const key of /* @__PURE__ */ new Set([...Object.keys(a.properties), ...Object.keys(b.properties)])) {
+			const pa = a.properties[key];
+			const pb = b.properties[key];
+			out.properties[key] = pa && pb ? loosest(pa, pb) : pa ?? pb;
+		}
+		const required = (a.required ?? []).filter((key) => (b.required ?? []).includes(key));
+		if (required.length > 0) out.required = required;
+	}
+	if (a.description) out.description = a.description;
+	return out;
+}
+/** The tool-schema projection of an operation's zod request schema (input side). */
+function toRaftToolInputSchema(schema, options = {}) {
+	const projected = project(toJSONSchema(schema, {
+		io: "input",
+		target: "draft-2020-12",
+		reused: "inline",
+		unrepresentable: "throw"
+	}), "input", { unionAs: Object.fromEntries(Object.entries(options.unionAs ?? {}).map(([key, type]) => [`input.${key}`, type])) });
+	if (projected.type !== "object") throw new Error("an operation's input schema must be an object");
+	for (const key of options.omit ?? []) {
+		if (projected.properties) delete projected.properties[key];
+		if (projected.required) projected.required = projected.required.filter((r) => r !== key);
+	}
+	for (const [key, description] of Object.entries(options.describe ?? {})) {
+		const property = projected.properties?.[key];
+		if (!property) throw new Error(`cannot describe unknown field ${key}`);
+		property.description = description;
+	}
+	if (projected.required?.length === 0) delete projected.required;
+	projected.properties ??= {};
+	return projected;
+}
+//#endregion
+//#region src/operations.ts
+const nothing = {
+	model: [],
+	code: []
+};
+const small = {
+	mayBeLarge: false,
+	boundBy: []
+};
+const OPERATION_DEFS = [
+	{
+		name: "identity.whoami",
+		description: "Who this credential is: your agent, the server, the capabilities granted to the credential, and the operating guide for External Agents.",
+		schema: whoamiRequestSchema,
+		routes: ["agentContext"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: []
+		}
+	},
+	{
+		name: "inbox.check",
+		description: "Pull one batch of new messages addressed to you (DMs, @mentions, followed threads, joined channels). Handle them, then call inbox.commit; the next check acknowledges the committed batch.",
+		schema: checkInboxRequestSchema,
+		routes: ["events"],
+		consumes: {
+			model: ["inbox", "seen"],
+			code: "refused"
+		},
+		output: {
+			mayBeLarge: true,
+			boundBy: ["limit"]
+		}
+	},
+	{
+		name: "inbox.drain",
+		description: "Pull new messages until the server reports nothing more, returned together. Each batch is acknowledged by the pull after it; call inbox.commit after handling the result.",
+		schema: drainInboxRequestSchema,
+		routes: ["events"],
+		consumes: {
+			model: ["inbox", "seen"],
+			code: "refused"
+		},
+		output: {
+			mayBeLarge: true,
+			boundBy: ["limit"]
+		}
+	},
+	{
+		name: "inbox.commit",
+		description: "Mark the last pulled inbox batch as handled (or the batch with the given cursor); the next inbox check acknowledges it on the server. Call it only after the messages were handled.",
+		schema: commitInboxRequestSchema,
+		routes: [],
+		local: {
+			sideEffect: "write",
+			idempotency: "natural"
+		},
+		consumes: {
+			model: ["inbox"],
+			code: "refused"
+		},
+		output: small
+	},
+	{
+		name: "inbox.list",
+		description: "List conversations with unread messages, newest activity first, each with where to start reading. Consumes nothing.",
+		schema: listInboxRequestSchema,
+		routes: ["inboxList"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: ["before", "limit"]
+		}
+	},
+	{
+		name: "messages.read",
+		description: "Read a conversation (channel, DM, or thread): the newest messages, or a window after / before / around a position. Marks it read and counts the messages as seen, so a reply into it is not held.",
+		schema: readHistoryRequestSchema,
+		unionAs: { around: "string" },
+		routes: ["historyRead"],
+		consumes: {
+			model: ["read_cursor", "seen"],
+			code: []
+		},
+		output: {
+			mayBeLarge: true,
+			boundBy: [
+				"after",
+				"before",
+				"around",
+				"limit"
+			]
+		}
+	},
+	{
+		name: "messages.send",
+		description: "Send a message to a channel, DM, or thread. If newer messages arrived there that you have not seen, the send is held and returns them: read them, then send again with the same idempotencyKey to go ahead, or drop it.",
+		schema: sendMessageRequestSchema,
+		hiddenFields: ["seen"],
+		routes: ["messageSendV2"],
+		idempotencyArg: "idempotencyKey",
+		mayInterrupt: true,
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "messages.reply",
+		description: "Reply where a received message came from (its conversation or thread). Held like messages.send when newer messages arrived there.",
+		schema: replyToRequestSchema,
+		hiddenFields: ["seen"],
+		routes: ["messageSendV2"],
+		idempotencyArg: "idempotencyKey",
+		mayInterrupt: true,
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "messages.search",
+		description: "Search messages by text, conversation, sender, or time; results are previews. Use it to find a specific message, not to check what is new.",
+		schema: searchMessagesRequestSchema,
+		routes: ["messageSearch"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: ["limit", "offset"]
+		}
+	},
+	{
+		name: "messages.resolve",
+		description: "Resolve a message id to the full message and the conversation it belongs to.",
+		schema: resolveMessageRequestSchema,
+		routes: ["messageResolve"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "messages.react",
+		description: "Add an emoji reaction to a message.",
+		schema: reactRequestSchema,
+		routes: ["messageReactionAdd"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "messages.unreact",
+		description: "Remove your emoji reaction from a message.",
+		schema: reactRequestSchema,
+		routes: ["messageReactionRemove"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "attachments.comments",
+		description: "List the comments on an attachment.",
+		schema: attachmentCommentsRequestSchema,
+		routes: ["attachmentCommentsList"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: ["limit"]
+		}
+	},
+	{
+		name: "mentions.pending",
+		description: "List @mentions you sent that reached nobody, each with the actions that would deliver it.",
+		schema: pendingMentionActionsRequestSchema,
+		routes: ["mentionActionsPending"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: ["limit"]
+		}
+	},
+	{
+		name: "mentions.execute",
+		description: "Deliver unreached @mentions: notify the mentioned target, or add them to the conversation.",
+		schema: executeMentionActionRequestSchema,
+		routes: ["mentionActionsExecute"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "mentions.deliveries",
+		description: "Whether each @mention in a message you sent reached its target.",
+		schema: senderMentionDeliveriesRequestSchema,
+		routes: ["senderMentionDeliveries"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "actions.prepare",
+		description: "Post an action card (create a channel, add members, create an agent, or an integration step) for a human to confirm; the human who clicks it carries it out as themselves. When it is executed (or fails), the outcome arrives as a reply that @mentions you in the card's thread (or in the thread the card was posted in).",
+		schema: prepareActionCardRequestSchema,
+		fieldDescriptions: {
+			target: "Conversation to post the card in: `#channel`, `dm:@peer`, or a thread.",
+			action: "The operation the card proposes: `type` picks it, and the other fields apply per type as described."
+		},
+		routes: ["actionPrepare"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "manual.get",
+		description: "Fetch a topic of the Raft Manual for Agents. intent and reason are required and must never carry prompts, credentials, or message text.",
+		schema: getManualTopicRequestSchema,
+		routes: ["knowledgeGet"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: []
+		}
+	},
+	{
+		name: "manual.search",
+		description: "Search the Raft Manual for Agents by keywords; returns topic ids to fetch with manual.get.",
+		schema: searchManualRequestSchema,
+		routes: ["knowledgeSearch"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: []
+		}
+	},
+	{
+		name: "tasks.claim",
+		description: "Claim tasks (by number, or a top-level message to claim as a task) before working on them. Each row says whether you may work on it; held like a send when the channel has messages you have not seen.",
+		schema: claimTasksRequestSchema,
+		routes: ["taskClaim"],
+		mayInterrupt: true,
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "tasks.list",
+		description: "A channel's task board, or your own tasks across channels with mine: true.",
+		schema: listTasksRequestSchema,
+		routes: ["taskList"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: ["status"]
+		}
+	},
+	{
+		name: "tasks.create",
+		description: "Create one or more tasks on a channel's board; each gets its own thread.",
+		schema: createTasksRequestSchema,
+		routes: ["taskCreate"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "tasks.unclaim",
+		description: "Release your claim on a task so someone else can take it.",
+		schema: taskRefSchema,
+		routes: ["taskUnclaim"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "tasks.assign",
+		description: "Assign a task to someone (yourself, or anyone if you are an owner/admin). To clear the assignee use tasks.unassign.",
+		schema: assignTaskRequestSchema,
+		routes: ["taskAssign"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "tasks.unassign",
+		description: "Clear a task's assignee.",
+		schema: unassignTaskRequestSchema,
+		routes: ["taskAssign"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "tasks.updateStatus",
+		description: "Move a task: todo → in_progress → in_review → done, or closed from anywhere. Held like a send when the channel has messages you have not seen.",
+		schema: updateTaskStatusRequestSchema,
+		routes: ["taskUpdateStatus"],
+		mayInterrupt: true,
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "tasks.amend",
+		description: "Change a task's title or description. Held like a send when the channel has messages you have not seen.",
+		schema: amendTaskRequestSchema,
+		routes: ["taskAmend"],
+		mayInterrupt: true,
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "tasks.history",
+		description: "A task's history: status changes, claims, and assignments.",
+		schema: taskRefSchema,
+		routes: ["taskHistory"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: []
+		}
+	},
+	{
+		name: "tasks.convert",
+		description: "Turn a top-level message into an unassigned task.",
+		schema: convertMessageToTaskRequestSchema,
+		routes: ["taskConvert"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "tasks.delete",
+		description: "Delete a task.",
+		schema: taskRefSchema,
+		routes: ["taskDelete"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "channels.join",
+		description: "Join a public channel. Joining is explicit; sending never joins.",
+		schema: channelTargetRequestSchema,
+		routes: ["serverInfo", "channelJoin"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "channels.leave",
+		description: "Leave a channel; ordinary channel messages stop arriving.",
+		schema: channelTargetRequestSchema,
+		routes: ["serverInfo", "channelLeave"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "channels.mute",
+		description: "Mute a channel's ordinary activity; @mentions, DMs, and followed threads still arrive.",
+		schema: channelTargetRequestSchema,
+		routes: ["serverInfo", "channelMute"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "channels.unmute",
+		description: "Unmute a channel's ordinary activity.",
+		schema: channelTargetRequestSchema,
+		routes: ["serverInfo", "channelUnmute"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "channels.members",
+		description: "Who is in a channel, DM, or thread.",
+		schema: channelMembersRequestSchema,
+		routes: ["channelMembers"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: []
+		}
+	},
+	{
+		name: "threads.list",
+		description: "The threads you follow.",
+		schema: listThreadsRequestSchema,
+		routes: ["threadList"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: []
+		}
+	},
+	{
+		name: "threads.unfollow",
+		description: "Stop following a thread; a direct @mention follows it again.",
+		schema: unfollowThreadRequestSchema,
+		routes: ["threadUnfollow"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "server.info",
+		description: "The server you are on: a summary by default, or one paged section (channels, agents, humans), or the full overview.",
+		schema: serverInfoRequestSchema,
+		routes: ["serverInfo"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: [
+				"view",
+				"offset",
+				"limit"
+			]
+		}
+	},
+	{
+		name: "profile.show",
+		description: "Show your profile, or someone else's by @handle.",
+		schema: showProfileRequestSchema,
+		routes: ["profileShow"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		name: "profile.update",
+		description: "Update your display name, description, or avatar URL.",
+		schema: updateProfileRequestSchema,
+		fieldDescriptions: {
+			displayName: "New display name.",
+			description: "New profile description.",
+			avatarUrl: "URL of the new avatar image."
+		},
+		routes: ["profileUpdate"],
+		consumes: nothing,
+		output: small
+	}
+];
+/** `tasks.updateStatus` → `tasks_update_status`. */
+function raftToolNameFor(name) {
+	return name.replace(/\./g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+const IDEMPOTENCY_STRENGTH = {
+	natural: 0,
+	key: 1,
+	none: 2
+};
+function deriveSpec(def) {
+	const metas = def.routes.map((route) => AGENT_API_ROUTE_META[route]);
+	const sideEffect = def.local ? def.local.sideEffect : metas.every((meta) => meta.sideEffect === "read") ? "read" : "write";
+	const idempotencyKind = def.local ? def.local.idempotency : metas.map((meta) => meta.idempotency).reduce((a, b) => IDEMPOTENCY_STRENGTH[b] > IDEMPOTENCY_STRENGTH[a] ? b : a, "natural");
+	if (idempotencyKind === "key" && !def.idempotencyArg) throw new Error(`${def.name}: keyed routes need idempotencyArg`);
+	const capability = [...new Set(def.routes.map((route) => agentApiContract[route].capability))].sort();
+	return {
+		name: def.name,
+		toolName: def.toolName ?? raftToolNameFor(def.name),
+		description: def.description,
+		inputSchema: toRaftToolInputSchema(def.schema, {
+			omit: def.hiddenFields,
+			describe: def.fieldDescriptions,
+			unionAs: def.unionAs
+		}),
+		sideEffect,
+		idempotency: idempotencyKind === "key" ? {
+			kind: "key",
+			arg: def.idempotencyArg
+		} : { kind: idempotencyKind },
+		capability,
+		modelOnly: def.consumes.code === "refused",
+		mayInterrupt: def.mayInterrupt === true,
+		consumes: {
+			model: [...def.consumes.model],
+			code: def.consumes.code === "refused" ? "refused" : [...def.consumes.code]
+		},
+		output: {
+			mayBeLarge: def.output.mayBeLarge,
+			boundBy: [...def.output.boundBy]
+		},
+		...def.deprecated ? { deprecated: true } : {}
+	};
+}
+function fnv1a64(text) {
+	let hash = 14695981039346656037n;
+	const prime = 1099511628211n;
+	const mask = 18446744073709551615n;
+	for (let index = 0; index < text.length; index += 1) {
+		hash ^= BigInt(text.charCodeAt(index));
+		hash = hash * prime & mask;
+	}
+	return hash.toString(16).padStart(16, "0");
+}
+/** Every agent operation on `createRaft`, in a stable order. */
+const RAFT_OPERATIONS = Object.freeze(OPERATION_DEFS.map((def) => deriveSpec(def)));
+/** Content hash of `RAFT_OPERATIONS` (16 hex digits); changes whenever any field of any operation changes. */
+const RAFT_OPERATIONS_VERSION = fnv1a64(JSON.stringify(RAFT_OPERATIONS));
+const RAFT_OPERATIONS_SCHEMA = "raft-sdk-operations.v1";
+const DEFS_BY_NAME = new Map(OPERATION_DEFS.map((def) => [def.name, def]));
+const SPECS_BY_NAME = new Map(RAFT_OPERATIONS.map((spec) => [spec.name, spec]));
+/** The manifest entry and the zod request schema for a name, or undefined. */
+function lookupRaftOperation(name) {
+	const def = DEFS_BY_NAME.get(name);
+	const spec = SPECS_BY_NAME.get(name);
+	return def && spec ? {
+		spec,
+		schema: def.schema
+	} : void 0;
+}
+//#endregion
 //#region src/raft.ts
 function createRaft(options) {
 	const serverUrl = requireServerUrl(options.serverUrl);
@@ -14081,13 +15279,13 @@ function createRaft(options) {
 	* (same target, content, attachments) reuses the held send's idempotency key;
 	* a hold is remembered; a successful send clears it.
 	*/
-	const sendWithState = (request) => withState(async () => {
+	const sendWithState = (request, seen) => withState(async () => {
 		const contentHash = await hashRaftSendContent(request.target, request.content ?? "", request.attachmentIds ?? []);
 		const pending = request.idempotencyKey ? void 0 : session.findContinuation(request.target, contentHash);
 		const outcome = await sendMessage(api, pending ? {
 			...request,
 			idempotencyKey: pending.idempotencyKey
-		} : request, frontier);
+		} : request, seen);
 		if (outcome.ok && outcome.state === "interrupted" && outcome.interrupt.resume.idempotencyKey) session.rememberContinuation({
 			target: request.target,
 			idempotencyKey: outcome.interrupt.resume.idempotencyKey,
@@ -14097,7 +15295,47 @@ function createRaft(options) {
 		else if (outcome.ok && outcome.state === "sent") session.forgetContinuation(request.target, contentHash);
 		return outcome;
 	});
-	return {
+	const checkWithState = (request, seen) => withState(async () => {
+		const since = request.since ?? session.cursor ?? void 0;
+		const outcome = await checkInbox(inboxApi, {
+			...request,
+			...since === void 0 ? {} : { since }
+		}, seen);
+		if (outcome.ok) {
+			session.markDirty();
+			if (since !== void 0 && (request.ack ?? "cursor") === "cursor") session.commit(since);
+			if (outcome.data.ackMode === "cursor" && outcome.data.messages.length > 0) session.setPending(outcome.data.cursor);
+		}
+		return outcome;
+	});
+	const drainWithState = (request, seen) => (async function* () {
+		await session.ensureLoaded();
+		const since = request.since ?? session.cursor ?? void 0;
+		return yield* drainInbox(inboxApi, {
+			...request,
+			...since === void 0 ? {} : { since }
+		}, seen, async (sent, batch) => {
+			if (sent !== null) session.commit(sent);
+			if (batch.ackMode === "cursor" && batch.messages.length > 0) session.setPending(batch.cursor);
+			session.markDirty();
+			await session.save();
+		});
+	})();
+	const commitInbox = async (target) => {
+		await session.ensureLoaded();
+		const cursor = session.commit(target === void 0 ? void 0 : target.cursor);
+		return {
+			cursor,
+			saved: cursor === null ? true : await session.save()
+		};
+	};
+	/** `seen` undefined: read without recording anything (a code read). */
+	const readWithState = (request, seen) => withState(async () => {
+		const outcome = await readHistory(api, request, seen);
+		if (outcome.ok && seen) session.markDirty();
+		return outcome;
+	});
+	const raft = {
 		identity: { whoami: () => getRaftContext(api) },
 		wake: {
 			verifyNotice: (input) => verifyInboxNotice(input),
@@ -14108,53 +15346,18 @@ function createRaft(options) {
 			}
 		},
 		inbox: {
-			check: (request = {}) => withState(async () => {
-				const since = request.since ?? session.cursor ?? void 0;
-				const outcome = await checkInbox(inboxApi, {
-					...request,
-					...since === void 0 ? {} : { since }
-				}, frontier);
-				if (outcome.ok) {
-					session.markDirty();
-					if (since !== void 0 && (request.ack ?? "cursor") === "cursor") session.commit(since);
-					if (outcome.data.ackMode === "cursor" && outcome.data.messages.length > 0) session.setPending(outcome.data.cursor);
-				}
-				return outcome;
-			}),
-			commit: async (target) => {
-				await session.ensureLoaded();
-				const cursor = session.commit(target === void 0 ? void 0 : target.cursor);
-				return {
-					cursor,
-					saved: cursor === null ? true : await session.save()
-				};
-			},
-			drain: (request = {}) => (async function* () {
-				await session.ensureLoaded();
-				const since = request.since ?? session.cursor ?? void 0;
-				return yield* drainInbox(inboxApi, {
-					...request,
-					...since === void 0 ? {} : { since }
-				}, frontier, async (sent, batch) => {
-					if (sent !== null) session.commit(sent);
-					if (batch.ackMode === "cursor" && batch.messages.length > 0) session.setPending(batch.cursor);
-					session.markDirty();
-					await session.save();
-				});
-			})(),
+			check: (request = {}) => checkWithState(request, frontier),
+			commit: (target) => commitInbox(target),
+			drain: (request = {}) => drainWithState(request, frontier),
 			list: (request) => listInbox(api, request)
 		},
 		messages: {
-			read: (request) => withState(async () => {
-				const outcome = await readHistory(api, request, frontier);
-				if (outcome.ok) session.markDirty();
-				return outcome;
-			}),
-			send: (request) => sendWithState(request),
+			read: (request) => readWithState(request, frontier),
+			send: (request) => sendWithState(request, frontier),
 			reply: (message, request) => sendWithState({
 				...request,
 				target: message.target
-			}),
+			}, frontier),
 			search: (request) => searchMessages(api, request),
 			resolve: (request) => resolveMessage(api, request),
 			react: (request) => reactToMessage(api, request, "add"),
@@ -14186,6 +15389,7 @@ function createRaft(options) {
 			create: (request) => createTasks(api, request),
 			unclaim: (request) => unclaimTask(api, request),
 			assign: (request) => assignTask(api, request),
+			unassign: (request) => unassignTask(api, request),
 			updateStatus: (request) => updateTaskStatus(api, request),
 			amend: (request) => amendTask(api, request),
 			history: (request) => taskHistory(api, request),
@@ -14220,33 +15424,173 @@ function createRaft(options) {
 		},
 		routes
 	};
+	const handlers = {
+		"identity.whoami": async () => whoamiOutcome(await raft.identity.whoami()),
+		"inbox.check": (args, call) => checkWithState(args, call.seen),
+		"inbox.drain": async (args, call) => {
+			const drain = drainWithState(args, call.seen);
+			const batches = [];
+			for (let step = await drain.next();; step = await drain.next()) {
+				if (step.done) return drainedInboxOutcome(batches, step.value);
+				batches.push(step.value);
+			}
+		},
+		"inbox.commit": async (args) => {
+			const result = await commitInbox(args.cursor === void 0 ? void 0 : { cursor: args.cursor });
+			return {
+				ok: true,
+				state: result.cursor === null ? "nothing" : "committed",
+				data: result,
+				next: null,
+				text: result.cursor === null ? "Nothing to commit." : `Committed inbox cursor ${result.cursor}; the next inbox check acknowledges it.${result.saved ? "" : " Saving the state failed; the batch may be delivered again."}`
+			};
+		},
+		"inbox.list": (args) => raft.inbox.list(args),
+		"messages.read": (args, call) => call.origin === "code" ? readWithState({
+			...args,
+			consume: false
+		}, void 0) : readWithState(args, call.seen),
+		"messages.send": (args, call) => sendWithState(args, call.seen),
+		"messages.reply": ({ message, ...request }, call) => sendWithState({
+			...request,
+			target: message.target
+		}, call.seen),
+		"messages.search": (args) => raft.messages.search(args),
+		"messages.resolve": (args) => raft.messages.resolve(args),
+		"messages.react": (args) => raft.messages.react(args),
+		"messages.unreact": (args) => raft.messages.unreact(args),
+		"attachments.comments": (args) => raft.attachments.comments(args),
+		"mentions.pending": (args) => raft.mentions.pending(args),
+		"mentions.execute": (args) => raft.mentions.execute(args),
+		"mentions.deliveries": (args) => raft.mentions.deliveries(args),
+		"actions.prepare": (args) => raft.actions.prepare(args),
+		"manual.get": (args) => raft.manual.get(args),
+		"manual.search": (args) => raft.manual.search(args),
+		"tasks.claim": (args) => raft.tasks.claim(args),
+		"tasks.list": (args) => raft.tasks.list(args),
+		"tasks.create": (args) => raft.tasks.create(args),
+		"tasks.unclaim": (args) => raft.tasks.unclaim(args),
+		"tasks.assign": (args) => raft.tasks.assign(args),
+		"tasks.unassign": (args) => raft.tasks.unassign(args),
+		"tasks.updateStatus": (args) => raft.tasks.updateStatus(args),
+		"tasks.amend": (args) => raft.tasks.amend(args),
+		"tasks.history": (args) => raft.tasks.history(args),
+		"tasks.convert": (args) => raft.tasks.convert(args),
+		"tasks.delete": (args) => raft.tasks.delete(args),
+		"channels.join": (args) => raft.channels.join(args),
+		"channels.leave": (args) => raft.channels.leave(args),
+		"channels.mute": (args) => raft.channels.mute(args),
+		"channels.unmute": (args) => raft.channels.unmute(args),
+		"channels.members": (args) => raft.channels.members(args),
+		"threads.list": () => raft.threads.list(),
+		"threads.unfollow": (args) => raft.threads.unfollow(args),
+		"server.info": (args) => raft.server.info(args),
+		"profile.show": (args) => raft.profile.show(args),
+		"profile.update": (args) => raft.profile.update(args)
+	};
+	const invoke = async (name, args, caller = {}) => {
+		const found = typeof name === "string" ? lookupRaftOperation(name) : void 0;
+		if (!found || !Object.hasOwn(handlers, name)) return failureOutcome(opError("INVALID_REQUEST", {
+			message: `Unknown operation${typeof name === "string" && /^[A-Za-z0-9_.]{1,64}$/.test(name) ? ` "${name}"` : ""}; nothing was sent.`,
+			nextAction: "Use a name from RAFT_OPERATIONS (for example \"messages.send\")."
+		}));
+		const origin = caller?.origin ?? "model";
+		if (origin !== "model" && origin !== "code" || caller?.contextId !== void 0 && typeof caller.contextId !== "string") return failureOutcome(opError("INVALID_REQUEST", { message: "caller.origin must be \"model\" or \"code\", and caller.contextId a string; nothing was sent." }));
+		const input = args === void 0 ? {} : args;
+		const invalid = validateOpRequest(found.schema, input);
+		if (invalid) return invalid;
+		if (origin === "code" && found.spec.modelOnly) return failureOutcome(opError("MODEL_ONLY", { message: `${found.spec.name} only counts when the model sees its result, so it cannot be run from code; nothing was sent.` }));
+		const handler = handlers[name];
+		return handler(input, {
+			seen: frontier.inContext(caller?.contextId),
+			origin
+		});
+	};
+	return {
+		...raft,
+		invoke
+	};
+}
+/** `identity.whoami` as an outcome (for `invoke`). */
+function whoamiOutcome(result) {
+	if (!result.ok) return failureOutcome(opError(result.error.code, {
+		message: result.error.message,
+		...result.status === void 0 ? {} : { status: result.status }
+	}));
+	const { agent, server, capabilities, guide } = result.data;
+	const head = `You are @${agent.name}${agent.displayName ? ` (${agent.displayName})` : ""} on ${server.name}. Credential capabilities: ${capabilities.join(", ") || "none"}.`;
+	return {
+		ok: true,
+		state: "identity",
+		data: result.data,
+		next: null,
+		text: guide ? `${head}\n\n${guide}` : head
+	};
 }
 //#endregion
 exports.RAFT_INBOX_NOTICE_SCHEMA = RAFT_INBOX_NOTICE_SCHEMA;
+exports.RAFT_JSON_SCHEMA_KEYWORDS = RAFT_JSON_SCHEMA_KEYWORDS;
 exports.RAFT_NOTICE_DELIVERY_ID_HEADER = RAFT_NOTICE_DELIVERY_ID_HEADER;
 exports.RAFT_NOTICE_SIGNATURE_HEADER = RAFT_NOTICE_SIGNATURE_HEADER;
+exports.RAFT_OPERATIONS = RAFT_OPERATIONS;
+exports.RAFT_OPERATIONS_SCHEMA = RAFT_OPERATIONS_SCHEMA;
+exports.RAFT_OPERATIONS_VERSION = RAFT_OPERATIONS_VERSION;
 exports.RAFT_STATE_CONTINUATIONS_PER_TARGET = RAFT_STATE_CONTINUATIONS_PER_TARGET;
 exports.RAFT_STATE_CONTINUATIONS_TOTAL = RAFT_STATE_CONTINUATIONS_TOTAL;
 exports.RAFT_STATE_SCHEMA = RAFT_STATE_SCHEMA;
 exports.RaftCredentialError = RaftCredentialError;
 exports.RaftSdkConfigurationError = RaftSdkConfigurationError;
 exports.SeenFrontier = SeenFrontier;
+exports.amendTaskRequestSchema = amendTaskRequestSchema;
+exports.assignTaskRequestSchema = assignTaskRequestSchema;
+exports.attachmentCommentsRequestSchema = attachmentCommentsRequestSchema;
 exports.bootstrapRaftCredential = bootstrapRaftCredential;
+exports.channelMembersRequestSchema = channelMembersRequestSchema;
+exports.channelTargetRequestSchema = channelTargetRequestSchema;
+exports.checkInboxRequestSchema = checkInboxRequestSchema;
+exports.claimTasksRequestSchema = claimTasksRequestSchema;
+exports.commitInboxRequestSchema = commitInboxRequestSchema;
+exports.convertMessageToTaskRequestSchema = convertMessageToTaskRequestSchema;
 exports.createFileCredentialStore = createFileCredentialStore;
 exports.createRaft = createRaft;
 exports.createRaftClient = createRaftClient;
 exports.createRaftClientFromStore = createRaftClientFromStore;
 exports.createRaftRoutes = createRaftRoutes;
+exports.createTasksRequestSchema = createTasksRequestSchema;
 exports.describeRaftRoute = describeRaftRoute;
+exports.drainInboxRequestSchema = drainInboxRequestSchema;
+exports.executeMentionActionRequestSchema = executeMentionActionRequestSchema;
+exports.getManualTopicRequestSchema = getManualTopicRequestSchema;
 exports.hasAgentMessageIdentity = hasAgentMessageIdentity;
 exports.hashRaftSendContent = hashRaftSendContent;
 exports.inferAttachmentMimeType = inferAttachmentMimeType;
 exports.isInterrupted = isInterrupted;
 exports.joinRaftChannelByTarget = joinRaftChannelByTarget;
+exports.listInboxRequestSchema = listInboxRequestSchema;
 exports.listRaftRoutes = listRaftRoutes;
+exports.listTasksRequestSchema = listTasksRequestSchema;
+exports.listThreadsRequestSchema = listThreadsRequestSchema;
 exports.parseRaftRegularChannelTarget = parseRaftRegularChannelTarget;
 exports.parseRaftState = parseRaftState;
+exports.pendingMentionActionsRequestSchema = pendingMentionActionsRequestSchema;
+exports.prepareActionCardRequestSchema = prepareActionCardRequestSchema;
 exports.projectRaftMessage = projectRaftMessage;
 exports.projectRaftMessages = projectRaftMessages;
+exports.raftToolNameFor = raftToolNameFor;
+exports.reactRequestSchema = reactRequestSchema;
+exports.readHistoryRequestSchema = readHistoryRequestSchema;
 exports.readLatestReadThread = readLatestReadThread;
+exports.replyToRequestSchema = replyToRequestSchema;
+exports.resolveMessageRequestSchema = resolveMessageRequestSchema;
+exports.searchManualRequestSchema = searchManualRequestSchema;
+exports.searchMessagesRequestSchema = searchMessagesRequestSchema;
+exports.sendMessageRequestSchema = sendMessageRequestSchema;
+exports.senderMentionDeliveriesRequestSchema = senderMentionDeliveriesRequestSchema;
+exports.serverInfoRequestSchema = serverInfoRequestSchema;
+exports.showProfileRequestSchema = showProfileRequestSchema;
+exports.taskRefSchema = taskRefSchema;
+exports.unfollowThreadRequestSchema = unfollowThreadRequestSchema;
+exports.updateProfileRequestSchema = updateProfileRequestSchema;
+exports.updateTaskStatusRequestSchema = updateTaskStatusRequestSchema;
 exports.verifyInboxNotice = verifyInboxNotice;
+exports.whoamiRequestSchema = whoamiRequestSchema;