@botiverse/raft-sdk 0.6.0 → 0.8.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();
@@ -11710,9 +12079,39 @@ function formatAgentTaskHistory(data) {
 		return `seq=${event.seq} time=${event.createdAt} actor=${actor} type=${event.eventType}\n  ${JSON.stringify(event.payload)}`;
 	}).join("\n")}`;
 }
+/**
+* `raft task show`: one task's current title and description (moved verbatim
+* from the CLI's commands/task/show.ts). Labels match the agent delivery
+* surface (`Current title:` / `Current description:`). `description` has three
+* states that must not collapse: a string, an explicit null, and a field the
+* envelope omitted.
+*/
+function formatAgentTaskShow(target, task) {
+	const descriptionLine = typeof task.description === "string" ? `Current description: ${task.description}` : task.description === null ? "Current description: (none set)" : "Current description: (not returned by this surface)";
+	return [
+		`#${task.taskNumber} [${task.status ?? "unknown"}] in ${target}`,
+		`Current title: ${task.title ?? "(none set)"}`,
+		descriptionLine,
+		""
+	].join("\n");
+}
 //#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 +12160,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 +12213,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 +12261,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 +12300,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 +12327,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 +12356,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 +12405,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 +12425,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 +12443,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 +12484,45 @@ async function taskHistory(client, request) {
 		text: formatAgentTaskHistory(result.data)
 	};
 }
+/**
+* `raft task show`: one task's current title and description. Reads the
+* channel's whole board (`status: "all"`, so done and closed tasks are found)
+* and picks the task; a miss says whether the Server asserted the list is
+* complete, exactly as the CLI does.
+*/
+async function showTask(client, request) {
+	const invalid = requireTaskRef(request);
+	if (invalid) return invalid;
+	const { target, taskNumber } = request;
+	const result = await client.tasks.list({
+		channel: target,
+		status: "all"
+	});
+	if (!result.ok) return failureFromClientResult(result);
+	const tasks = result.data.tasks ?? [];
+	const task = tasks.find((candidate) => candidate.taskNumber === taskNumber);
+	if (!task) return failureOutcome(opError("NOT_FOUND", {
+		message: result.data.pagination?.mode === "complete" && result.data.pagination.truncated === false ? `task #${taskNumber} not found in ${target} (searched ${tasks.length} task(s), status=all; server asserts this list is complete)` : tasks.length === 0 ? `task #${taskNumber} not found in ${target}: the server returned 0 tasks and did not assert the list is complete. That can mean the channel has no tasks, or that the server failed to read them (it currently reports some read errors as an empty list), and this command cannot tell which — so this is not evidence that task #${taskNumber} does not exist` : `task #${taskNumber} not found in ${target} (searched ${tasks.length} task(s), status=all; this surface does NOT assert completeness — so this is "absent from what was returned", not "does not exist")`,
+		nextAction: `Check the number with \`raft task list --target "${target}" --status all\`.`
+	}));
+	return {
+		ok: true,
+		state: "task",
+		data: {
+			target,
+			task
+		},
+		next: null,
+		text: formatAgentTaskShow(target, task)
+	};
+}
+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,
@@ -12332,6 +12844,30 @@ function formatPageFooter(page) {
 	if (page.nextCommand && end < page.total) lines.push(`More: ${page.nextCommand}`);
 	return `${lines.join("\n")}\n`;
 }
+/** Single channel detail block. */
+function formatAgentChannelInfo(channel, memberCounts) {
+	const lines = ["## Channel", ""];
+	lines.push(`Channel: ${agentChannelRef(channel.name, channel.type)}`);
+	if (channel.id) lines.push(`ID: ${channel.id}`);
+	lines.push(`Visibility: ${channelVisibility(channel)}`);
+	lines.push(`Joined: ${channel.joined ? "yes" : "no"}`);
+	if (channel.channelRole) lines.push(`Channel role: ${channel.channelRole}`);
+	if (channel.channelAdminBasis) lines.push(`Channel admin basis: ${channel.channelAdminBasis}`);
+	const callableCapabilities = Object.entries(channel.channelCapabilities ?? {}).filter(([, allowed]) => allowed).map(([capability]) => capability);
+	if (callableCapabilities.length > 0) lines.push(`Channel capabilities: ${callableCapabilities.join(", ")}`);
+	const muted = channelMuted(channel);
+	if (muted !== void 0) lines.push(`Muted: ${muted ? "yes" : "no"}`);
+	if (typeof channel.archived === "boolean") lines.push(`Archived: ${channel.archived ? "yes" : "no"}`);
+	lines.push(`Description: ${channel.description?.trim() || "(none)"}`);
+	if (memberCounts) {
+		const agents = memberCounts.agents ?? 0;
+		const humans = memberCounts.humans ?? 0;
+		lines.push(`Members: ${agents + humans} (${agents} agents, ${humans} humans)`);
+	}
+	lines.push("");
+	lines.push(`More: raft channel members "${agentChannelRef(channel.name, channel.type)}"`);
+	return `${lines.join("\n")}\n`;
+}
 /** Compact server summary. */
 function formatAgentServerSummary(data) {
 	const channels = data.channels ?? [];
@@ -12398,6 +12934,23 @@ function formatAgentServerHumans(humans, page) {
 	}
 	return `${lines.join("\n")}${formatPageFooter(page)}`;
 }
+/** Narrow visible facts for one user/agent. */
+function formatAgentUserInfo(user, memberships, page, skippedChannels = 0) {
+	const name = user.value.name;
+	const role = roleLabel(user.value.role);
+	const lines = ["## User", ""];
+	lines.push(`User: @${name}`);
+	lines.push(`Kind: ${user.kind}`);
+	if (user.kind === "agent") lines.push(`Status: ${agentStatusLabel(user.value)}`);
+	if (role) lines.push(`Role: ${role.slice(2, -1)}`);
+	if (user.value.description) lines.push(`Description: ${user.value.description}`);
+	lines.push("");
+	lines.push("### Visible Channel Memberships");
+	if (memberships.length === 0) lines.push("(none found in inspected visible channels)");
+	else for (const channel of memberships) lines.push(`${agentChannelRef(channel.name, channel.type)} [${channelStatus(channel)}]`);
+	if (skippedChannels > 0) lines.push(`Skipped ${skippedChannels} visible channel roster checks because the server rejected them.`);
+	return `${lines.join("\n")}${formatPageFooter(page)}`;
+}
 /** Channel membership with server-role labels. */
 function formatAgentChannelMembers(data) {
 	let text = "## Channel Members\n\n";
@@ -12606,6 +13159,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 +13186,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 +13221,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 +13255,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 +13299,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 +13325,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,
@@ -12769,8 +13341,58 @@ async function unfollowThread(client, request) {
 		text: `Unfollowed ${request.target}. Ordinary delivery from this thread stops; a direct @mention reactivates the follow.`
 	};
 }
+const channelInfoRequestSchema = requestSchema()(object({ target: string().describe("A regular channel, `#channel-name` (the `#` may be omitted). DMs and threads are not accepted.") }));
+/**
+* `raft channel info <target>`: the channel's facts from `server.info`, plus
+* member counts from its roster when the Server shows it.
+*/
+async function channelInfo(client, request) {
+	const invalid = validateOpRequest(channelInfoRequestSchema, request);
+	if (invalid) return invalid;
+	const trimmed = request.target.trim();
+	const input = trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+	const name = parseRaftRegularChannelTarget$1(input);
+	if (!name) return failureOutcome(opError("INVALID_REQUEST", { message: "Target must be a regular channel name, e.g. '#engineering' or 'engineering'. DMs and thread targets are not supported." }));
+	const info = await client.server.info();
+	if (!info.ok) return failureFromClientResult(info);
+	const channel = info.data.channels.find((candidate) => candidate.name === name);
+	if (!channel) return failureOutcome(opError("NOT_FOUND", {
+		message: `Channel not found or not visible: ${input}`,
+		nextAction: "Run `raft server info --channels --query <name>` to inspect visible channels, or ask a channel member to add you if this is private."
+	}));
+	const members = await client.channels.members({ channel: `#${name}` });
+	const memberCounts = members.ok ? {
+		agents: members.data.agents?.length ?? 0,
+		humans: members.data.humans?.length ?? 0
+	} : null;
+	return {
+		ok: true,
+		state: "info",
+		data: {
+			channel,
+			memberCounts
+		},
+		next: null,
+		text: formatAgentChannelInfo(channel, memberCounts)
+	};
+}
 //#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 +13406,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 +13473,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 +13486,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);
@@ -12871,6 +13499,85 @@ async function updateProfile(client, request, options = {}) {
 		text: formatAgentProfile(result.data, options)
 	};
 }
+const userInfoRequestSchema = requestSchema()(object({
+	name: string().describe("The human or agent, `@handle` (or the bare handle)."),
+	offset: number$1().int().nonnegative().optional().describe("Membership paging: visible channels to skip before inspecting (default 0)."),
+	limit: number$1().int().positive().optional().describe("Membership paging: visible channels to inspect (default 50).")
+}));
+/**
+* `raft user info <name>`: the user's visible facts from `server.info`, and
+* their memberships among one page of the visible channels, checked one
+* channel roster at a time (a rejected roster is skipped and counted).
+*/
+async function userInfo(client, request) {
+	const invalid = validateOpRequest(userInfoRequestSchema, request);
+	if (invalid) return invalid;
+	const trimmed = request.name.trim();
+	const name = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+	if (!name) return failureOutcome(opError("INVALID_REQUEST", { message: "user name is required" }));
+	const limit = request.limit ?? 50;
+	const offset = request.offset ?? 0;
+	const info = await client.server.info();
+	if (!info.ok) return failureFromClientResult(info);
+	const agent = info.data.agents.find((candidate) => candidate.name === name);
+	const human = info.data.humans.find((candidate) => candidate.name === name);
+	const user = agent ? {
+		kind: "agent",
+		value: agent
+	} : human ? {
+		kind: "human",
+		value: human
+	} : null;
+	if (!user) return failureOutcome(opError("NOT_FOUND", {
+		message: `User not found or not visible: @${name}`,
+		nextAction: "Run `raft server info --agents --query <name>` or `raft server info --humans --query <name>` to inspect visible users."
+	}));
+	const visibleChannels = info.data.channels;
+	const memberships = [];
+	let skippedChannels = 0;
+	for (const channel of visibleChannels.slice(offset, offset + limit)) {
+		const members = await client.channels.members({ channel: `#${channel.name}` });
+		if (!members.ok) {
+			skippedChannels += 1;
+			continue;
+		}
+		if ((user.kind === "agent" ? members.data.agents ?? [] : members.data.humans ?? []).some((candidate) => candidate.name === name)) memberships.push({
+			...channel,
+			joined: true,
+			muted: void 0,
+			activityMuted: void 0
+		});
+	}
+	const nextOffset = offset + limit;
+	const page = {
+		total: visibleChannels.length,
+		offset,
+		limit,
+		nextCommand: nextOffset < visibleChannels.length ? `raft user info @${name} --offset ${nextOffset} --limit ${limit}` : void 0
+	};
+	const next = page.nextCommand ? {
+		kind: "next_page",
+		command: page.nextCommand,
+		args: {
+			name: `@${name}`,
+			offset: nextOffset,
+			limit
+		},
+		why: "Only one page of visible channels was inspected for memberships."
+	} : null;
+	return {
+		ok: true,
+		state: "info",
+		data: {
+			user,
+			memberships,
+			skippedChannels,
+			page
+		},
+		next,
+		text: formatAgentUserInfo(user, memberships, page, skippedChannels)
+	};
+}
 //#endregion
 //#region ../shared/src/agentText/attachments.ts
 /** Upload receipt with attachment id and send-usage hint. */
@@ -12913,6 +13620,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 +13831,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 +13849,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 +13977,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 +13998,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 +14019,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 +14076,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 +14100,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 +14303,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 +14343,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 +14365,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 +14399,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 +14437,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 +14627,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 +14694,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 +14754,725 @@ 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.show",
+		description: "One task's current status, title, and description. Finds done and closed tasks too.",
+		schema: taskRefSchema,
+		routes: ["taskList"],
+		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: "channels.info",
+		description: "A regular channel's facts: visibility, whether you joined it, your role and mute state, description, and member counts.",
+		schema: channelInfoRequestSchema,
+		routes: ["serverInfo", "channelMembers"],
+		consumes: nothing,
+		output: small
+	},
+	{
+		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: "users.info",
+		description: "A human's or agent's visible facts (kind, status, role, description) and which visible channels they are in. Memberships are checked over one page of visible channels; page with offset and limit.",
+		schema: userInfoRequestSchema,
+		routes: ["serverInfo", "channelMembers"],
+		consumes: nothing,
+		output: {
+			mayBeLarge: true,
+			boundBy: ["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 +15512,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 +15528,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 +15579,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,9 +15622,11 @@ 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),
+			show: (request) => showTask(api, request),
 			convert: (request) => convertMessageToTask(api, request),
 			delete: (request) => deleteTask(api, request)
 		},
@@ -14197,13 +15635,15 @@ function createRaft(options) {
 			leave: (request) => leaveChannel(api, request),
 			mute: (request) => muteChannel(api, request),
 			unmute: (request) => unmuteChannel(api, request),
-			members: (request) => channelMembers(api, request)
+			members: (request) => channelMembers(api, request),
+			info: (request) => channelInfo(api, request)
 		},
 		threads: {
 			list: () => listThreads(api),
 			unfollow: (request) => unfollowThread(api, request)
 		},
 		server: { info: (request) => serverInfo(api, request) },
+		users: { info: (request) => userInfo(api, request) },
 		profile: {
 			show: (request) => showProfile(api, request),
 			update: (request) => updateProfile(api, request)
@@ -14220,33 +15660,178 @@ 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.show": (args) => raft.tasks.show(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),
+		"channels.info": (args) => raft.channels.info(args),
+		"threads.list": () => raft.threads.list(),
+		"threads.unfollow": (args) => raft.threads.unfollow(args),
+		"server.info": (args) => raft.server.info(args),
+		"users.info": (args) => raft.users.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.channelInfoRequestSchema = channelInfoRequestSchema;
+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.userInfoRequestSchema = userInfoRequestSchema;
 exports.verifyInboxNotice = verifyInboxNotice;
+exports.whoamiRequestSchema = whoamiRequestSchema;