@botiverse/raft-sdk 0.3.0 → 1.0.0-alpha.1

package/dist/cjs/index.cjs

@@ -7390,13 +7390,8 @@ function encodeQuery(routeKey, query) {
 	return params;
 }
 function parseBody(routeKey, body) {
+	if (body === void 0) return void 0;
 	const route = agentApiContract[routeKey];
-	if (body === void 0) {
-		if (!("body" in route.request)) return void 0;
-		const schema = route.request.body;
-		if (schema.safeParse(void 0).success || schema.safeParse({}).success) return void 0;
-		return failure$3(routeKey, "request_contract_mismatch", `Agent API ${route.key} requires a request body`);
-	}
 	try {
 		return "body" in route.request ? route.request.body.parse(body) : void 0;
 	} catch (cause) {
@@ -7501,19 +7496,7 @@ function createAgentApiRawClient(transport, options = {}) {
 		const routeKey = route.key;
 		const { resource, method } = route.client;
 		const resourceClient = client[resource] ??= {};
-		const expectedArgs = [
-			"params",
-			"query",
-			"body"
-		].filter((part) => part in route.request).length;
-		resourceClient[method] = (...args) => {
-			if (args.length > expectedArgs) return Promise.resolve(failure$3(routeKey, "request_contract_mismatch", `Agent API ${route.key} takes ${expectedArgs} argument${expectedArgs === 1 ? "" : "s"} (${[
-				"params",
-				"query",
-				"body"
-			].filter((part) => part in route.request).join(", ") || "none"}); got ${args.length}`));
-			return requestAgentApiRawRoute(transport, routeKey, requestOptionsFromMethodArgs(routeKey, pathPrefix, args));
-		};
+		resourceClient[method] = (...args) => requestAgentApiRawRoute(transport, routeKey, requestOptionsFromMethodArgs(routeKey, pathPrefix, args));
 	}
 	return client;
 }
@@ -9904,7 +9887,7 @@ function clampAttempts(value) {
 * The split is decided per route from `AGENT_API_ROUTE_META`, never by the
 * caller and never by the HTTP method.
 */
-function createRaftRouteClient(options) {
+function createRaftRoutes(options) {
 	const base = {
 		baseUrl: options.serverUrl,
 		fetch: options.fetch,
@@ -9931,61 +9914,12 @@ function createRaftRouteClient(options) {
 		...merged,
 		request: (routeKey, requestOptions) => {
 			return (ROUTE_INFO[routeKey].retryPolicy === "retry" ? retrying : single).request(routeKey, requestOptions);
-		}
-	};
-}
-const ROUTE_PARTS = [
-	"params",
-	"query",
-	"body"
-];
-function inputMismatch(routeKey, message) {
-	return Promise.resolve({
-		ok: false,
-		routeKey,
-		error: {
-			kind: "validation",
-			reason: "request_contract_mismatch",
-			message: `Agent API ${routeKey} ${message}`
-		}
-	});
-}
-/**
-* The public routes layer: one named-object call shape for every route,
-* `routes.<resource>.<method>({ params, query, body })`. The types reject a
-* missing required part or a part the route does not have; for callers
-* without type checking, the same rules are enforced at runtime and nothing
-* is sent on a mismatch.
-*/
-function raftRoutesFromClient(client) {
-	const call = (routeKey, args) => {
-		if (args.length > 1) return inputMismatch(routeKey, `takes one { params, query, body } object; got ${args.length} arguments`);
-		const input = args[0];
-		if (input !== void 0 && (input === null || typeof input !== "object" || Array.isArray(input))) return inputMismatch(routeKey, "takes one { params, query, body } object");
-		const route = agentApiContract[routeKey];
-		const declared = ROUTE_PARTS.filter((part) => part in route.request);
-		const unknown = (input === void 0 ? [] : Object.keys(input)).filter((key) => !declared.includes(key));
-		if (unknown.length > 0) return inputMismatch(routeKey, `has no ${unknown.join(", ")} (it takes ${declared.join(", ") || "no input"})`);
-		return client.request(routeKey, input ?? {});
-	};
-	const methods = {};
-	for (const route of Object.values(agentApiContract)) {
-		const key = route.key;
-		methods[route.client.resource] ??= {};
-		methods[route.client.resource][route.client.method] = (...args) => call(key, args);
-	}
-	return {
-		...methods,
-		request: (routeKey, ...rest) => call(routeKey, rest),
+		},
 		manifestVersion: AGENT_API_MANIFEST_VERSION,
 		describe: describeRaftRoute,
 		list: listRaftRoutes
 	};
 }
-/** Build the public routes layer directly (convenience over createRaftRouteClient + raftRoutesFromClient). */
-function createRaftRoutes(options) {
-	return raftRoutesFromClient(createRaftRouteClient(options));
-}
 //#endregion
 //#region src/context.ts
 const projection = object({
@@ -11110,17 +11044,13 @@ var SeenFrontier = class SeenFrontier {
 	aliases = /* @__PURE__ */ new Map();
 	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). */
-	absorb(snapshot) {
-		if (!snapshot || snapshot.version !== 1) return;
-		for (const [alias, canonical] of Object.entries(snapshot.aliases ?? {})) this.recordAlias(alias, canonical);
+		if (!snapshot || snapshot.version !== 1) return frontier;
 		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)) frontier.recordUpTo(target, state.upTo);
+			if (Array.isArray(state.exact)) frontier.recordExact(target, state.exact);
 		}
+		for (const [alias, canonical] of Object.entries(snapshot.aliases ?? {})) frontier.recordAlias(alias, canonical);
+		return frontier;
 	}
 	/** Remember that the Server resolved `requested` to `canonical` (a thread spelling, a `~agent` suffix, …). */
 	recordAlias(requested, canonical) {
@@ -11267,7 +11197,7 @@ async function checkInbox(client, request = {}, frontier) {
 * return value summarises the drain; the batch that ends the iteration is
 * acknowledged only by the caller's next pull (`summary.cursor`).
 */
-async function* drainInbox(client, request = {}, frontier, onPull) {
+async function* drainInbox(client, request = {}, frontier) {
 	const ack = request.ack ?? "cursor";
 	let cursor = request.since ?? null;
 	let ackMode = ack;
@@ -11290,7 +11220,6 @@ async function* drainInbox(client, request = {}, frontier, onPull) {
 			error: round
 		};
 		const batch = round.data;
-		await onPull?.(sent, batch);
 		ackMode = batch.ackMode;
 		stillUnread = batch.stillUnreadConversations;
 		if (batch.messages.length > 0) {
@@ -11599,173 +11528,12 @@ async function sendMessage(client, request, frontier, internal = {}) {
 	if (data.state === "sent") return sentOutcome(request.target, data);
 	return failureOutcome(opError("INVALID_RESPONSE", { message: `Unexpected send state "${data.state}".` }));
 }
-function taskTimestamps(t) {
-	return `${t.createdAt ? ` created=${formatUtcTimestamp(t.createdAt)}` : ""}${t.updatedAt ? ` updated=${formatUtcTimestamp(t.updatedAt)}` : ""}`;
-}
-const TASK_STATUS_ORDER = [
-	"todo",
-	"in_progress",
-	"in_review",
-	"done",
-	"closed"
-];
-function oneLineTaskTitle(title) {
-	return (title ?? "").replace(/\s+/g, " ").trim();
-}
-/** Channel task board listing. */
-function formatAgentTaskList(channel, data, statusFilter) {
-	if (!data.tasks || data.tasks.length === 0) return `No${statusFilter && statusFilter !== "all" ? ` ${statusFilter}` : ""} tasks in ${channel}.`;
-	const formatted = data.tasks.map((t) => {
-		const assignee = t.claimedById ? ` → ${t.claimedByName ? `@${t.claimedByName}` : "<unresolved>"}` : "";
-		const departedCreator = t.createdByMembershipStatus === "left" || t.createdByMembershipStatus === "removed";
-		const creator = t.createdByName ? ` (by @${t.createdByName}${departedCreator ? " [departed]" : ""})` : "";
-		const msgId = t.messageId ? ` msg=${t.messageId.slice(0, 8)}` : "";
-		const revision = Number.isInteger(t.revision) ? ` rev=${t.revision}` : "";
-		const legacy = t.isLegacy ? " [LEGACY — read-only]" : "";
-		const resourceReceipt = t.requiresResourceReceipt ? ` resource-receipt=${t.resourceReceiptRecordedAt ? "recorded" : "pending"}` : "";
-		const details = t.description ? `\n  Current description: ${t.description.replace(/\n/g, `\n${" ".repeat(23)}`)}` : "";
-		return `#${t.taskNumber} [${t.status}]${assignee}${creator}${msgId}${revision}${resourceReceipt}${taskTimestamps(t)}${legacy} Current title: ${oneLineTaskTitle(t.title)}${details}`;
-	}).join("\n");
-	return `## Task Board for ${channel} (${data.tasks.length} tasks)\n\n${formatted}`;
-}
-/** Cross-channel --mine task listing with coverage notes. */
-function formatAgentMyTaskList(data, statusFilter) {
-	const tasks = data.tasks ?? [];
-	const visibleTypes = data.coverage?.visibleChannelTypes?.join("|") ?? "unknown";
-	const archived = data.coverage?.includesArchived ? "included" : "not included";
-	const coverage = [
-		`Coverage: ${data.coverage?.status ?? "unknown"}`,
-		`visible types=${visibleTypes}`,
-		`archived=${archived}`,
-		`inaccessible scope=${data.coverage?.inaccessibleScope ?? "unknown"}`
-	].join(" · ");
-	const output = `Output: showing ${tasks.length} of ${tasks.length} visible matches · mode=${data.pagination?.mode ?? "unknown"} · truncated=${String(data.pagination?.truncated ?? "unknown")}`;
-	const title = `## My assigned tasks on this server${statusFilter ? ` (status=${statusFilter})` : " (unfinished)"}`;
-	if (tasks.length === 0) return [
-		title,
-		"",
-		coverage,
-		output,
-		"",
-		"No tasks matched in the covered visible scope."
-	].join("\n");
-	const grouped = /* @__PURE__ */ new Map();
-	for (const task of tasks) {
-		const status = task.status ?? "unknown";
-		const bucket = grouped.get(status) ?? [];
-		bucket.push(task);
-		grouped.set(status, bucket);
-	}
-	return [
-		title,
-		"",
-		coverage,
-		output,
-		"",
-		...[...TASK_STATUS_ORDER.filter((status) => grouped.has(status)), ...[...grouped.keys()].filter((status) => !TASK_STATUS_ORDER.includes(status)).sort()].map((status) => {
-			const rows = grouped.get(status);
-			const rendered = rows.map((task) => {
-				const channelRef = task.channelRef ?? "<unresolved-visible-target>";
-				const taskNumber = task.taskNumber ?? "?";
-				const departedCreator = task.createdByMembershipStatus === "left" || task.createdByMembershipStatus === "removed";
-				const creator = task.createdByName ? ` by=@${task.createdByName}${departedCreator ? " creator=departed" : ""}` : "";
-				const message = task.messageId ? ` msg=${task.messageId.slice(0, 8)}` : "";
-				const legacy = task.isLegacy ? " legacy=read-only" : "";
-				return `- ${channelRef} task #${taskNumber} [${status}]${creator}${message}${task.requiresResourceReceipt ? ` resource-receipt=${task.resourceReceiptRecordedAt ? "recorded" : "pending"}` : ""}${taskTimestamps(task)}${legacy} Current title: ${oneLineTaskTitle(task.title)}`.trimEnd();
-			});
-			return [`### ${status} (${rows.length})`, ...rendered].join("\n");
-		})
-	].join("\n");
-}
-/** Receipt for task create. */
-function formatAgentTasksCreated(channel, data) {
-	const created = data.tasks.map((t) => {
-		const assignee = t.claimedById ? t.claimedByName ? `@${t.claimedByName}` : "<unresolved>" : "unassigned";
-		const resourceReceipt = t.requiresResourceReceipt ? " resource-receipt=pending" : "";
-		return `#${t.taskNumber} [${t.status}] assignee=${assignee} claimedAt=${t.claimedAt ?? "null"} msg=${t.messageId.slice(0, 8)}${resourceReceipt} "${t.title}"`;
-	}).join("\n");
-	const threadHints = data.tasks.map((t) => `#${t.taskNumber} → raft message send --target "${channel}:${t.messageId.slice(0, 8)}"`).join("\n");
-	const receipt = data.assignmentReceipt ? `\n\nAssignment receipt (msg=${data.assignmentReceipt.messageId.slice(0, 8)}):\n${data.assignmentReceipt.content}` : "";
-	return `Created ${data.tasks.length} task(s) in ${channel}:\n${created}${receipt}\n\nTo follow up in each task's thread:\n${threadHints}`;
-}
-const BLOCKED_ACTION_COPY = { start_conflicting_execution: "starting conflicting implementation/change work" };
-function formatClaimConflict(label, conflict) {
-	const holder = conflict.currentAssignee?.name ? `@${conflict.currentAssignee.name}` : "another actor";
-	const blocked = conflict.blockedActions.map((action) => BLOCKED_ACTION_COPY[action] ?? action).join("; ");
-	const examples = conflict.unblockedActionExamples.join(" · ");
-	return [
-		`${label}: Claim failed — ${holder} currently holds the implementation lock (assignment state as of ${conflict.observedAt}).`,
-		`  Blocked: ${blocked}.`,
-		`  Not blocked by this claim conflict (each still subject to its own authority/policy): ${examples}.`,
-		`  This is not a ruling on who owns or leads this lane. If you are its canonical owner or believe it is misrouted: correct the routing in the original thread, or file request_reassign (a request — it does not itself reassign).`
-	].join("\n");
-}
-function canonicalAgentTaskTarget(target) {
-	return target.replace(/^dm:user:/i, "dm:@");
-}
-function agentTaskThreadTarget(target, messageId) {
-	return `${canonicalAgentTaskTarget(target)}:${messageId.slice(0, 8)}`;
-}
-/** Claim results incl. concurrency-lock guidance on failed claims. */
-function formatAgentClaimResults(channel, data) {
-	const lines = data.results.map((r) => {
-		const label = r.taskNumber ? `#${r.taskNumber}` : `msg:${r.messageId}`;
-		if (r.success) return `${label} (msg:${r.messageId ? r.messageId.slice(0, 8) : ""}): claimed`;
-		if (r.reason === "already claimed by you") return `${label}: already claimed by you.`;
-		if (r.conflict?.kind === "claim_conflict") return formatClaimConflict(label, r.conflict);
-		return `${label}: FAILED — ${r.reason || "already claimed"}. Do not start conflicting execution on this task or take over its scope without a redirect; a failed claim is a concurrency lock, not a ruling on lane ownership.`;
-	});
-	const succeeded = data.results.filter((r) => r.success).length;
-	const failed = data.results.length - succeeded;
-	let summary = `${succeeded} claimed`;
-	if (failed > 0) summary += `, ${failed} failed`;
-	const claimedMsgs = data.results.filter((r) => r.success && r.messageId).map((r) => `#${r.taskNumber} → raft message send --target "${agentTaskThreadTarget(channel, r.messageId)}"`).join("\n");
-	const threadHint = claimedMsgs ? `\n\nFollow up in each task's thread:\n${claimedMsgs}` : "";
-	return `Claim results (${summary}):\n${lines.join("\n")}${threadHint}`;
-}
-function formatAgentTaskUnclaimed(taskNumber) {
-	return `#${taskNumber} unclaimed — now open.`;
-}
-function formatAgentTaskAssigned(taskNumber, assignee) {
-	return assignee ? `#${taskNumber} assigned to ${assignee}.` : `#${taskNumber} unassigned — now open.`;
-}
-function formatAgentTaskStatusUpdated(taskNumber, status) {
-	return `#${taskNumber} moved to ${status}.`;
-}
-function formatAgentTaskDeleted(taskNumber) {
-	return `#${taskNumber} deleted.`;
-}
-/** Message→task conversion receipt. */
-function formatAgentTaskConverted(channel, task) {
-	const target = `${canonicalAgentTaskTarget(channel)}:${task.messageId.slice(0, 8)}`;
-	return [
-		`Converted msg=${task.messageId.slice(0, 8)} to task #${task.taskNumber} [${task.status}] assignee=unassigned "${task.title}"`,
-		"",
-		`To follow up in the task's thread:`,
-		`raft message send --target "${target}"`
-	].join("\n");
-}
-function formatAgentTaskAmended(data) {
-	const details = data.task.description === null ? "details: <none>" : `details:\n${data.task.description.split("\n").map((line) => `  ${line}`).join("\n")}`;
-	return [
-		`#${data.task.taskNumber} amended — revision ${data.task.revision}, event seq ${data.event.seq}.`,
-		`title: ${data.task.title}`,
-		details
-	].join("\n");
-}
-function formatAgentTaskHistory(data) {
-	const description = data.task.description === null ? "(none set)" : data.task.description.replace(/\n/g, `\n${" ".repeat(21)}`);
-	const header = [
-		`## Task #${data.task.taskNumber} history — revision ${data.task.revision}`,
-		"",
-		`Current title: ${data.task.title.replace(/\s+/g, " ").trim()}`,
-		`Current description: ${description}`
-	].join("\n");
-	if (data.events.length === 0) return `${header}\n\nNo recorded events.`;
-	return `${header}\n\n${data.events.map((event) => {
-		const actor = event.actorType === "system" ? "@system" : event.actorName ? `@${event.actorName}` : "<unresolved>";
-		return `seq=${event.seq} time=${event.createdAt} actor=${actor} type=${event.eventType}\n  ${JSON.stringify(event.payload)}`;
-	}).join("\n")}`;
+/** Reply where a received message came from. */
+function replyTo(client, message, request, frontier) {
+	return sendMessage(client, {
+		...request,
+		target: message.target
+	}, frontier);
 }
 //#endregion
 //#region ../shared/src/agentOps/tasks.ts
@@ -11779,12 +11547,12 @@ function rowState(result) {
 function claimNext(claim) {
 	const first = claim.rows.find((row) => row.mayWork);
 	if (first) {
-		const thread = first.messageId ? agentTaskThreadTarget(claim.target, first.messageId) : null;
+		const suffix = first.messageId ? first.messageId.slice(0, 8) : null;
 		return {
 			kind: "start_work",
-			...thread ? {
-				command: `raft message send --target "${thread}"`,
-				args: { thread }
+			...suffix ? {
+				command: `raft message send --target "${claim.target}:${suffix}"`,
+				args: { thread: `${claim.target}:${suffix}` }
 			} : {},
 			why: "The claim is yours; post progress in the task's thread."
 		};
@@ -11795,7 +11563,20 @@ function claimNext(claim) {
 	};
 }
 function claimText(claim) {
-	return formatAgentClaimResults(claim.target, { results: claim.rows.map((row) => row.raw) });
+	const lines = claim.rows.map((row) => {
+		const label = row.taskNumber ? `#${row.taskNumber}` : `msg:${row.ref}`;
+		if (row.state === "claimed") return `${label}: claimed`;
+		if (row.state === "already_yours") return `${label}: already claimed by you`;
+		if (row.state === "conflict") return `${label}: held by ${row.holder?.name ? `@${row.holder.name}` : "another assignee"}`;
+		return `${label}: refused${row.reason ? ` (${row.reason})` : ""}`;
+	});
+	const head = `Claim results (${claim.rows.filter((row) => row.mayWork).length} of ${claim.rows.length} authorise work):`;
+	const next = claimNext(claim);
+	return [
+		head,
+		...lines,
+		next?.command ? `Follow up in the task's thread: ${next.command}` : next?.why ?? ""
+	].filter(Boolean).join("\n");
 }
 async function claimTasks(client, request) {
 	const numbers = (request.taskNumbers ?? []).filter((n) => Number.isInteger(n) && n > 0);
@@ -11839,8 +11620,7 @@ async function claimTasks(client, request) {
 			mayWork: state === "claimed" || state === "already_yours",
 			reason: row.reason ?? null,
 			holder: row.conflict?.currentAssignee ?? null,
-			conflict: row.conflict ?? null,
-			raw: row
+			conflict: row.conflict ?? null
 		};
 	});
 	const claim = {
@@ -11856,235 +11636,6 @@ async function claimTasks(client, request) {
 		text: claimText(claim)
 	};
 }
-async function listTasks(client, request) {
-	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({
-		...mine ? { mine: "true" } : { channel: request.target },
-		...request.status ? { status: request.status } : {}
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	const data = result.data;
-	const board = {
-		scope: mine ? "mine" : "channel",
-		target: mine ? null : request.target,
-		tasks: data.tasks,
-		coverage: data.coverage ?? null
-	};
-	const text = mine ? formatAgentMyTaskList(data, request.status) : formatAgentTaskList(request.target, data, request.status);
-	const open = board.tasks.find((t) => t.status === "todo" && !t.claimedByName);
-	const next = open?.taskNumber && board.target ? {
-		kind: "claim_task",
-		command: `raft task claim --target "${board.target}" --number ${open.taskNumber}`,
-		args: {
-			target: board.target,
-			taskNumbers: [open.taskNumber]
-		},
-		why: "An unassigned todo task is open; claim it before working on it."
-	} : null;
-	return {
-		ok: true,
-		state: board.tasks.length > 0 ? "board" : "empty",
-		data: board,
-		next,
-		text
-	};
-}
-async function createTasks(client, request) {
-	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,
-		tasks: request.tasks.map((t) => ({
-			title: t.title,
-			...t.createsResource ? { creates_resource: true } : {}
-		})),
-		...request.assignee ? { assignee: request.assignee } : {}
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	const data = result.data;
-	const first = data.tasks[0];
-	return {
-		ok: true,
-		state: "created",
-		data: {
-			...data,
-			target: request.target
-		},
-		next: first ? {
-			kind: "post_in_task_thread",
-			command: `raft message send --target "${agentTaskThreadTarget(request.target, first.messageId)}"`,
-			args: { thread: agentTaskThreadTarget(request.target, first.messageId) },
-			why: "Follow up in each task's thread."
-		} : null,
-		text: formatAgentTasksCreated(request.target, data)
-	};
-}
-function requireTaskRef(request) {
-	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;
-}
-async function unclaimTask(client, request) {
-	const invalid = requireTaskRef(request);
-	if (invalid) return invalid;
-	const result = await client.tasks.unclaim({
-		channel: request.target,
-		task_number: request.taskNumber
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	return {
-		ok: true,
-		state: "unclaimed",
-		data: request,
-		next: null,
-		text: formatAgentTaskUnclaimed(request.taskNumber)
-	};
-}
-async function assignTask(client, request) {
-	const invalid = requireTaskRef(request);
-	if (invalid) return invalid;
-	const result = await client.tasks.assign({
-		channel: request.target,
-		task_number: request.taskNumber,
-		assignee: request.assignee,
-		...request.expectedRevision === void 0 ? {} : { expected_revision: request.expectedRevision }
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	const assignee = result.data.assignee;
-	return {
-		ok: true,
-		state: assignee ? "assigned" : "unassigned",
-		data: {
-			target: request.target,
-			taskNumber: request.taskNumber,
-			assignee,
-			revision: result.data.revision
-		},
-		next: null,
-		text: formatAgentTaskAssigned(request.taskNumber, assignee)
-	};
-}
-function heldTaskWrite(request, data, action, kind) {
-	const { idempotencyKey: _k, continuation: _c, ...base } = projectHeld(request.target, data, "");
-	const held = {
-		...base,
-		request
-	};
-	return {
-		ok: true,
-		state: "held",
-		data: held,
-		next: {
-			kind,
-			command: `raft message read --target "${request.target}"`,
-			args: { ...request },
-			why: `Unread messages in this channel may change the task; read them (frontier.recordHeld(held) once the model saw them), then repeat with these args if it is still right.`
-		},
-		text: `Held — ${held.newMessageCount} unread ${held.newMessageCount === 1 ? "message" : "messages"} in ${request.target}. ${action}\nRead them with: raft message read --target "${request.target}"\nAfter reviewing, repeat the operation if it is still correct.`
-	};
-}
-async function updateTaskStatus(client, request) {
-	const invalid = requireTaskRef(request);
-	if (invalid) return invalid;
-	const result = await client.tasks.updateStatus({
-		channel: request.target,
-		task_number: request.taskNumber,
-		status: request.status
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	if (isHeldResponse(result.data)) return heldTaskWrite(request, result.data, "The status change was not applied.", "retry_update_status");
-	return {
-		ok: true,
-		state: "updated",
-		data: request,
-		next: request.status === "in_review" ? {
-			kind: "await_review",
-			why: "A human validates the work; set done after approval."
-		} : null,
-		text: formatAgentTaskStatusUpdated(request.taskNumber, request.status)
-	};
-}
-async function amendTask(client, request) {
-	const invalid = requireTaskRef(request);
-	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({
-		channel: request.target,
-		task_number: request.taskNumber,
-		...request.title === void 0 ? {} : { title: request.title },
-		...request.description === void 0 ? {} : { description: request.description }
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	if (isHeldResponse(result.data)) return heldTaskWrite(request, result.data, "The amendment was not applied.", "retry_amend");
-	return {
-		ok: true,
-		state: "amended",
-		data: {
-			...result.data,
-			target: request.target
-		},
-		next: null,
-		text: formatAgentTaskAmended(result.data)
-	};
-}
-async function taskHistory(client, request) {
-	const invalid = requireTaskRef(request);
-	if (invalid) return invalid;
-	const result = await client.tasks.history({
-		channel: request.target,
-		task_number: request.taskNumber
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	return {
-		ok: true,
-		state: "history",
-		data: {
-			...result.data,
-			target: request.target
-		},
-		next: null,
-		text: formatAgentTaskHistory(result.data)
-	};
-}
-async function convertMessageToTask(client, request) {
-	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,
-		message_id: request.messageId
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	const task = result.data.task;
-	return {
-		ok: true,
-		state: "converted",
-		data: {
-			target: request.target,
-			task
-		},
-		next: {
-			kind: "post_in_task_thread",
-			command: `raft message send --target "${agentTaskThreadTarget(request.target, task.messageId)}"`,
-			args: { thread: agentTaskThreadTarget(request.target, task.messageId) },
-			why: "Follow up in the task's thread; it is unassigned until someone claims it."
-		},
-		text: formatAgentTaskConverted(request.target, task)
-	};
-}
-async function deleteTask(client, request) {
-	const invalid = requireTaskRef(request);
-	if (invalid) return invalid;
-	const result = await client.tasks.delete({
-		channel: request.target,
-		task_number: request.taskNumber
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	return {
-		ok: true,
-		state: "deleted",
-		data: request,
-		next: null,
-		text: formatAgentTaskDeleted(request.taskNumber)
-	};
-}
 //#endregion
 //#region ../shared/src/agentOps/wake.ts
 const RAFT_INBOX_NOTICE_SCHEMA = "raft-agent-inbox-notice.v1";
@@ -12252,1859 +11803,53 @@ async function unregisterWebhook(client) {
 	};
 }
 //#endregion
-//#region ../shared/src/agentText/server.ts
-function formatRuntimeContext(ctx) {
-	if (!ctx) return "";
-	const lines = ["### Current Runtime", "Authoritative context for this agent process. Do not infer computer identity from hostname or cwd when this section is present."];
-	if (ctx.agentId) lines.push(`- Agent ID: ${ctx.agentId}`);
-	if (ctx.runtime) lines.push(`- Runtime: ${ctx.runtime}`);
-	if (ctx.model) lines.push(`- Model: ${ctx.model}`);
-	if (ctx.reasoningEffort) lines.push(`- Reasoning: ${ctx.reasoningEffort}`);
-	if (ctx.serverId) lines.push(`- Server ID: ${ctx.serverId}`);
-	if (ctx.machineName || ctx.machineId) {
-		const label = ctx.machineName && ctx.machineId ? `${ctx.machineName} (${ctx.machineId})` : ctx.machineName || ctx.machineId;
-		lines.push(`- Computer: ${label}`);
-	}
-	if (ctx.machineDescription) lines.push(`- Computer Description: ${ctx.machineDescription}`);
-	if (ctx.machineHostname) lines.push(`- Hostname: ${ctx.machineHostname}`);
-	if (ctx.machineOs) lines.push(`- OS: ${ctx.machineOs}`);
-	if (ctx.daemonVersion) lines.push(`- Daemon: v${ctx.daemonVersion}`);
-	if (ctx.workspacePath) lines.push(`- Workspace: ${ctx.workspacePath}`);
-	return lines.length > 2 ? `${lines.join("\n")}\n\n` : "";
-}
-function roleLabel(role) {
-	return role && role !== "member" ? ` (${role})` : "";
-}
-function channelMemberRoleDetail(member) {
-	const details = [];
-	if (member.serverRole) details.push(`server role=${member.serverRole}`);
-	if (member.channelRole) details.push(`channel role=${member.channelRole}`);
-	if (member.channelAdminBasis) details.push(`admin via=${member.channelAdminBasis}`);
-	return details.length > 0 ? ` [${details.join(", ")}]` : "";
-}
-function agentStatusLabel(agent) {
-	const lifecycle = agent.status?.trim() || "unknown";
-	const activity = agent.activity?.trim();
-	if (!activity) return lifecycle;
-	const activityWithDetail = agent.activityDetail?.trim() ? `${activity}: ${agent.activityDetail.trim()}` : activity;
-	return activity === lifecycle ? lifecycle : `${lifecycle}; ${activityWithDetail}`;
-}
-function formatCurrentAgent(data) {
-	if (!data.serverRole) return "";
-	const lines = ["### Current Agent"];
-	lines.push(`- Role: ${data.serverRole}`);
-	return `${lines.join("\n")}\n\n`;
-}
-/** Server overview: runtime context, channels, agents, humans. */
-function formatAgentServerInfo(data) {
-	let text = "## Server\n\n";
-	const channels = data.channels ?? [];
-	const agents = data.agents ?? [];
-	const humans = data.humans ?? [];
-	text += formatRuntimeContext(data.runtimeContext);
-	text += formatCurrentAgent(data);
-	text += "### Channels\n";
-	text += "Visible public channels may appear even when `joined=false`. Private channels are shown only when you are a member; do not disclose private-channel names, membership, or content outside that channel. Use channel attention commands (`raft channel join`, `leave`, `mute`, `unmute`; `raft thread unfollow`) for your own delivery state. Existing channel management commands (`raft channel create`, `update`, `archive`, `unarchive`, `add-member`, `remove-member`) are authorized per channel; a channel-admin role never grants delete, visibility, federation, or server-profile actions. There is no Agent command for changing channel roles. Run any subcommand with `--help` for syntax.\n";
-	text += "Server-profile changes still use raft server update and remain server-role gated.\n";
-	text += "Mute state is shown when the server provides it; otherwise it is omitted.\n";
-	if (channels.length > 0) for (const t of channels) {
-		const statusParts = [t.type === "private" || t.type === "dm" ? "private" : "public", t.joined ? "joined" : "not joined"];
-		if (t.channelRole) statusParts.push(`channel role=${t.channelRole}`);
-		if (t.channelAdminBasis) statusParts.push(`admin via=${t.channelAdminBasis}`);
-		const muted = channelMuted(t);
-		if (muted !== void 0) statusParts.push(muted ? "muted" : "not muted");
-		const status = statusParts.join(", ");
-		const ref = agentChannelRef(t.name, t.type);
-		text += t.description ? `  - ${ref} [${status}] — ${t.description}\n` : `  - ${ref} [${status}]\n`;
-	}
-	else text += "  (none)\n";
-	text += "\n### Agents\n";
-	text += "Other AI agents in this server.\n";
-	text += "Role labels show server-level owner/admin authority; no role label means ordinary member.\n";
-	if (agents.length > 0) for (const a of agents) {
-		const role = roleLabel(a.role);
-		const status = agentStatusLabel(a);
-		text += a.description ? `  - @${a.name} (${status})${role} — ${a.description}\n` : `  - @${a.name} (${status})${role}\n`;
-	}
-	else text += "  (none)\n";
-	text += "\n### Humans\n";
-	text += "To start a new DM: raft message send --target \"dm:@name\" <<'RAFTMSG' followed by the message body and RAFTMSG. To reply in an existing DM: reuse the target from received messages.\n";
-	text += "Role labels show server-level owner/admin authority; no role label means ordinary member.\n";
-	if (humans.length > 0) for (const u of humans) {
-		const role = roleLabel(u.role);
-		text += u.description ? `  - @${u.name}${role} — ${u.description}\n` : `  - @${u.name}${role}\n`;
-	}
-	else text += "  (none)\n";
-	return text;
-}
-function agentChannelRef(name, type) {
-	if (type === "dm") return `dm:@${name}`;
-	return name.startsWith("#") ? name : `#${name}`;
-}
-function channelVisibility(channel) {
-	const type = channel.type?.trim();
-	return type === "private" || type === "dm" ? "private" : "public";
-}
-function channelMuted(channel) {
-	if (typeof channel.muted === "boolean") return channel.muted;
-	if (typeof channel.activityMuted === "boolean") return channel.activityMuted;
-}
-function channelStatus(channel) {
-	const parts = [channelVisibility(channel), channel.joined ? "joined" : "not joined"];
-	const muted = channelMuted(channel);
-	if (channel.channelRole) parts.push(`channel role=${channel.channelRole}`);
-	if (channel.channelAdminBasis) parts.push(`admin via=${channel.channelAdminBasis}`);
-	if (muted !== void 0) parts.push(muted ? "muted" : "not muted");
-	if (typeof channel.archived === "boolean") parts.push(channel.archived ? "archived" : "not archived");
-	return parts.join(", ");
-}
-function formatPageFooter(page) {
-	if (!page) return "";
-	const start = page.total === 0 ? 0 : Math.min(page.offset + 1, page.total);
-	const end = Math.min(page.offset + page.limit, page.total);
-	const lines = [`\nShowing ${start}-${end} of ${page.total}.`];
-	if (page.nextCommand && end < page.total) lines.push(`More: ${page.nextCommand}`);
-	return `${lines.join("\n")}\n`;
-}
-/** Compact server summary. */
-function formatAgentServerSummary(data) {
-	const channels = data.channels ?? [];
-	const agents = data.agents ?? [];
-	const humans = data.humans ?? [];
-	const joined = channels.filter((channel) => channel.joined).length;
-	return `${[
-		"## Server",
-		"",
-		`Channels: ${channels.length} visible (${joined} joined)`,
-		`Agents: ${agents.length}`,
-		`Humans: ${humans.length}`,
-		"",
-		"Narrow queries:",
-		"- raft server info --channels",
-		"- raft server info --agents",
-		"- raft server info --humans",
-		"- raft channel info <name>",
-		"- raft user info <name>",
-		"",
-		"Full dump: raft server info --full"
-	].join("\n")}\n`;
-}
-/** Channel listing page. */
-function formatAgentServerChannels(channels, page) {
-	const lines = [
-		"## Server Channels",
-		"",
-		"Private channels are shown only when this agent is a member. Do not disclose private-channel names or metadata outside that channel."
-	];
-	if (channels.length === 0) lines.push("(none)");
-	else for (const channel of channels) {
-		const description = channel.description?.trim();
-		lines.push(description ? `${agentChannelRef(channel.name, channel.type)} [${channelStatus(channel)}] — ${description}` : `${agentChannelRef(channel.name, channel.type)} [${channelStatus(channel)}]`);
-	}
-	return `${lines.join("\n")}${formatPageFooter(page)}`;
-}
-/** Agent listing page. */
-function formatAgentServerAgents(agents, page) {
-	const lines = [
-		"## Server Agents",
-		"",
-		"Role labels show server-level owner/admin authority; no role label means ordinary member."
-	];
-	if (agents.length === 0) lines.push("(none)");
-	else for (const agent of agents) {
-		const role = roleLabel(agent.role);
-		const status = agentStatusLabel(agent);
-		lines.push(agent.description ? `@${agent.name} (${status})${role} — ${agent.description}` : `@${agent.name} (${status})${role}`);
-	}
-	return `${lines.join("\n")}${formatPageFooter(page)}`;
-}
-/** Human listing page. */
-function formatAgentServerHumans(humans, page) {
-	const lines = [
-		"## Server Humans",
-		"",
-		"Role labels show server-level owner/admin authority; no role label means ordinary member."
-	];
-	if (humans.length === 0) lines.push("(none)");
-	else for (const human of humans) {
-		const role = roleLabel(human.role);
-		lines.push(human.description ? `@${human.name}${role} — ${human.description}` : `@${human.name}${role}`);
-	}
-	return `${lines.join("\n")}${formatPageFooter(page)}`;
-}
-/** Channel membership with server-role labels. */
-function formatAgentChannelMembers(data) {
-	let text = "## Channel Members\n\n";
-	const ref = data.channel?.ref ?? "(unknown)";
-	const type = data.channel?.type ? ` (${data.channel.type})` : "";
-	const agents = data.agents ?? [];
-	const humans = data.humans ?? [];
-	text += `Channel: ${ref}${type}\n`;
-	text += "Members means join/post authority for this surface.\n\n";
-	text += "### Agents\n";
-	text += "Server and stored channel roles are shown separately when available.\n";
-	if (agents.length > 0) for (const a of agents) {
-		const role = roleLabel(a.role);
-		const channelRole = channelMemberRoleDetail(a);
-		const status = agentStatusLabel(a);
-		text += a.description ? `  - @${a.name} (${status})${role}${channelRole} — ${a.description}\n` : `  - @${a.name} (${status})${role}${channelRole}\n`;
-	}
-	else text += "  (none)\n";
-	text += "\n### Humans\n";
-	text += "Server and stored channel roles are shown separately when available.\n";
-	if (humans.length > 0) for (const u of humans) {
-		const role = roleLabel(u.role);
-		const channelRole = channelMemberRoleDetail(u);
-		text += u.description ? `  - @${u.name}${role}${channelRole} — ${u.description}\n` : `  - @${u.name}${role}${channelRole}\n`;
-	}
-	else text += "  (none)\n";
-	return text;
-}
-//#endregion
-//#region ../shared/src/runtimeCatalog.ts
-const EXTERNAL_AGENT_RUNTIME_ID = "external";
-const EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
-function isExternalAgentRuntime(runtime) {
-	return runtime === EXTERNAL_AGENT_RUNTIME_ID;
-}
-const RUNTIMES = [
-	{
-		id: "claude",
-		displayName: "Claude Code",
-		abbreviation: "CC",
-		binary: "claude",
-		supported: true
-	},
-	{
-		id: "codex",
-		displayName: "Codex CLI",
-		abbreviation: "CX",
-		binary: "codex",
-		supported: true
-	},
-	{
-		id: "grok",
-		displayName: "Grok Build",
-		abbreviation: "GK",
-		binary: "grok",
-		supported: true
-	},
-	{
-		id: "builtin",
-		displayName: "Built-in Pi",
-		abbreviation: "BP",
-		binary: "",
-		supported: true
-	},
-	{
-		id: "antigravity",
-		displayName: "Antigravity CLI",
-		abbreviation: "AG",
-		binary: "agy",
-		supported: true,
-		deprecated: true
-	},
-	{
-		id: "kimi-sdk",
-		displayName: "Kimi Code",
-		abbreviation: "KC",
-		binary: "",
-		supported: true
-	},
-	{
-		id: "kimi",
-		displayName: "Kimi CLI",
-		abbreviation: "KL",
-		binary: "kimi",
-		supported: true,
-		deprecated: true
-	},
-	{
-		id: "copilot",
-		displayName: "Copilot CLI",
-		abbreviation: "CP",
-		binary: "copilot",
-		supported: true
-	},
-	{
-		id: "cursor",
-		displayName: "Cursor CLI",
-		abbreviation: "CU",
-		binary: "cursor-agent",
-		supported: true
-	},
-	{
-		id: "gemini",
-		displayName: "Gemini CLI",
-		abbreviation: "GM",
-		binary: "gemini",
-		supported: true,
-		deprecated: true
-	},
-	{
-		id: "opencode",
-		displayName: "OpenCode",
-		abbreviation: "OC",
-		binary: "opencode",
-		supported: true
-	},
-	{
-		id: "pi",
-		displayName: "Pi",
-		abbreviation: "PI",
-		binary: "pi",
-		supported: true
-	}
-];
-function isRuntimeDeprecated(runtimeId) {
-	return RUNTIMES.some((runtime) => runtime.id === runtimeId && Boolean(runtime.deprecated));
-}
-/** Map runtime ID → display name. Falls back to the ID itself. */
-function getRuntimeDisplayName(id) {
-	if (isExternalAgentRuntime(id)) return EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME;
-	return RUNTIMES.find((r) => r.id === id)?.displayName ?? id;
-}
-//#endregion
-//#region ../shared/src/agentText/threadsProfile.ts
-/**
-* Runtime label for identity display in agent-facing output: product name plus
-* lifecycle status. Agent-facing text is English-only, so the suffix is literal
-* here; the web surface renders the same status from the i18n catalog.
-*/
-function agentRuntimeLabelWithStatus(runtimeId) {
-	const name = getRuntimeDisplayName(runtimeId);
-	return isRuntimeDeprecated(runtimeId) ? `${name} (deprecated)` : name;
-}
-function formatDoneSuffix(thread) {
-	return thread.doneAt ? `, doneAt=${thread.doneAt}` : "";
-}
-/** Followed thread list for the bound agent, including exact thread targets. */
-function formatAgentThreadList(threads) {
-	if (threads.length === 0) return "No followed threads.";
-	return [`Followed threads (${threads.length}):`, ...threads.map((thread) => `- ${thread.target} (${thread.threadChannelId}, parent=${thread.parentChannelRef}, followedAt=${thread.followedAt}, reason=${thread.reason}${formatDoneSuffix(thread)})`)].join("\n");
-}
-function formatCreatedAgents(createdAgents, runtimeLabel) {
-	if (createdAgents.length === 0) return ["- Created Agents: none"];
-	return [`- Created Agents (${createdAgents.length}):`, ...createdAgents.map((createdAgent) => `  - @${createdAgent.name} (${runtimeLabel(createdAgent.runtime)}, ${createdAgent.status})`)];
-}
-function formatHumanProfile(profile, runtimeLabel) {
-	const lines = [
-		"## Profile",
-		"",
-		"- Type: human",
-		`- Handle: @${profile.name}`,
-		`- Display Name: ${profile.displayName ?? "(none)"}`,
-		`- Description: ${profile.description ?? "(none)"}`,
-		`- Membership: ${profile.membershipStatus}`
-	];
-	if (profile.role) lines.push(`- Role: ${profile.role}`);
-	if (profile.joinedAt) lines.push(`- Joined: ${profile.joinedAt}`);
-	if (profile.email) lines.push(`- Email: ${profile.email}`);
-	return [...lines, ...formatCreatedAgents(profile.createdAgents, runtimeLabel)].join("\n");
-}
-function formatCreator(profile) {
-	if (!profile.creator) return null;
-	return profile.creator.displayName ? `${profile.creator.displayName} (@${profile.creator.name})` : `@${profile.creator.name}`;
-}
-function formatAgentProfileCard(profile, runtimeLabel) {
-	const lines = [
-		"## Profile",
-		"",
-		"- Type: agent",
-		`- Handle: @${profile.name}`,
-		`- Display Name: ${profile.displayName ?? "(none)"}`,
-		`- Description: ${profile.description ?? "(none)"}`,
-		`- Status: ${profile.status}`,
-		`- Role: ${profile.serverRole}`,
-		`- Runtime: ${runtimeLabel(profile.runtime)}`,
-		`- Model: ${profile.model}`,
-		`- Reasoning: ${profile.reasoningEffort ?? "medium"}`
-	];
-	if (profile.executionMode) lines.push(`- Execution: ${profile.executionMode}`);
-	if (profile.computerName || profile.computerId) {
-		const label = profile.computerName && profile.computerId ? `${profile.computerName} (${profile.computerId})` : profile.computerName ?? profile.computerId;
-		lines.push(`- Computer: ${label}`);
-	}
-	if (profile.computerHostname) lines.push(`- Hostname: ${profile.computerHostname}`);
-	if (profile.daemonVersion) lines.push(`- Daemon: v${profile.daemonVersion}`);
-	lines.push(`- Created: ${profile.createdAt}`);
-	if (profile.deletedAt) lines.push(`- Deleted At: ${profile.deletedAt}`);
-	const creator = formatCreator(profile);
-	if (creator) lines.push(`- Creator: ${creator}`);
-	return [...lines, ...formatCreatedAgents(profile.createdAgents, runtimeLabel)].join("\n");
-}
-/** Agent/human profile card. */
-function formatAgentProfile(profile, options = {}) {
-	const runtimeLabel = options.runtimeLabel ?? agentRuntimeLabelWithStatus;
-	return profile.kind === "human" ? formatHumanProfile(profile, runtimeLabel) : formatAgentProfileCard(profile, runtimeLabel);
-}
-//#endregion
-//#region ../shared/src/agentOps/channels.ts
-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 ?? "");
-	if (!name) return failureOutcome(opError("INVALID_REQUEST", { message: INVALID_CHANNEL_TARGET }));
-	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: ${target}`,
-		nextAction: "List visible channels with `raft server info --channels`; private channels need a human to add you."
-	}));
-	return {
-		id: channel.id,
-		name: channel.name,
-		joined: channel.joined
-	};
-}
-async function joinChannel(client, request) {
-	const result = await joinRaftChannelByTarget$1(client, { target: request.target });
-	if (!result.ok) {
-		const error = result.error;
-		if (error.kind === "validation") return error.reason === "target_not_found" ? failureOutcome(opError("NOT_FOUND", {
-			message: error.message,
-			nextAction: "Only visible public channels can be joined; private and joint channels need an invitation."
-		})) : failureOutcome(opError("INVALID_REQUEST", { message: error.message }));
-		if (error.kind === "http") return failureOutcome(opError("HTTP_ERROR", {
-			message: error.message,
-			status: error.status,
-			...error.errorCode ? { serverCode: error.errorCode } : {},
-			...error.suggestedNextAction ? { nextAction: error.suggestedNextAction } : {}
-		}));
-		return failureOutcome(opError("TRANSPORT_ERROR", { message: error.message }));
-	}
-	const state = result.data.state;
+//#region src/raft.ts
+function createRaft(options) {
+	const serverUrl = requireServerUrl(options.serverUrl);
+	const authorization = `Bearer ${requireAgentCredential(options.credential)}`;
+	const frontier = SeenFrontier.fromSnapshot(options.frontier);
+	const routes = createRaftRoutes({
+		serverUrl,
+		fetch: options.fetch,
+		headers: options.headers,
+		authorization,
+		readAttempts: options.retry?.attempts,
+		beforeRequest: options.throttle?.beforeRequest
+	});
+	const inboxApi = createAgentApiClient({ fetch: {
+		baseUrl: serverUrl,
+		fetch: (input, init) => (options.fetch ?? fetch)(input, {
+			...init,
+			cache: "no-store",
+			redirect: "error"
+		}),
+		headers: Object.fromEntries(new Headers(options.headers)),
+		retry: { attempts: 1 },
+		throttle: options.throttle,
+		auth: { authorization }
+	} });
 	return {
-		ok: true,
-		state,
-		data: {
-			target: result.data.target,
-			channelId: result.data.channelId
-		},
-		next: {
-			kind: "read_target",
-			command: `raft message read --target "${result.data.target}"`,
-			args: { target: result.data.target },
-			why: "Read the channel before posting."
-		},
-		text: state === "joined" ? `Joined ${result.data.target}.` : `Already a member of ${result.data.target}.`
-	};
-}
-async function leaveChannel(client, request) {
-	const channel = await resolveRegularChannel(client, request.target);
-	if ("ok" in channel) return channel;
-	if (!channel.joined) return {
-		ok: true,
-		state: "not_joined",
-		data: {
-			target: request.target,
-			channelId: channel.id
+		identity: { whoami: () => getRaftContext(routes) },
+		wake: {
+			verifyNotice: (input) => verifyInboxNotice(input),
+			webhook: {
+				status: () => webhookStatus(routes),
+				register: (request) => registerWebhook(routes, request),
+				unregister: () => unregisterWebhook(routes)
+			}
 		},
-		next: null,
-		text: `You are not a member of ${request.target}; nothing to leave.`
-	};
-	const result = await client.channels.leave({ channelId: channel.id });
-	if (!result.ok) return failureFromClientResult(result);
-	const lines = [`Left ${request.target}. You can still inspect visible public channel history there, but you can no longer send or receive ordinary channel delivery until you join the public channel again or a human re-adds you to a private channel.`];
-	const attention = result.data.attention;
-	if (attention?.ordinaryActivity) lines.push(attention.ordinaryActivity);
-	return {
-		ok: true,
-		state: "left",
-		data: {
-			target: request.target,
-			channelId: channel.id
+		inbox: {
+			check: (request) => checkInbox(inboxApi, request, frontier),
+			drain: (request) => drainInbox(inboxApi, request, frontier),
+			list: (request) => listInbox(routes, request)
 		},
-		next: null,
-		text: lines.join("\n")
-	};
-}
-function formatSeq(value) {
-	return value == null ? "none" : String(value);
-}
-async function setChannelMute(client, request, action) {
-	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 });
-	if (!result.ok) return failureFromClientResult(result);
-	const data = result.data;
-	const lines = [
-		`${data.activityMuted ? "Muted" : "Unmuted"} ${request.target}.`,
-		`Activity muted: ${data.activityMuted ? "yes" : "no"}`,
-		`Mute from seq: ${formatSeq(data.muteFromSeq)}`
-	];
-	if (data.attention?.ordinaryActivity) lines.push(data.attention.ordinaryActivity);
-	if (data.attention?.stillArrives?.length) {
-		lines.push("Still arrives:");
-		for (const item of data.attention.stillArrives) lines.push(`- ${item}`);
-	}
-	if (data.attention?.threadBoundary) lines.push(data.attention.threadBoundary);
-	if (data.attention?.catchUp) lines.push(data.attention.catchUp);
-	if (data.attention?.unmuteCommand) lines.push(`To unmute: ${data.attention.unmuteCommand}`);
-	if (data.attention?.unmuteApi) lines.push(`Agent API: ${data.attention.unmuteApi}`);
-	if (data.attention?.muteCommand) lines.push(`To mute: ${data.attention.muteCommand}`);
-	if (data.attention?.muteApi) lines.push(`Agent API: ${data.attention.muteApi}`);
-	return {
-		ok: true,
-		state: data.activityMuted ? "muted" : "unmuted",
-		data: {
-			target: request.target,
-			channelId: channel.id,
-			activityMuted: data.activityMuted === true,
-			muteFromSeq: data.muteFromSeq ?? null,
-			stillArrives: data.attention?.stillArrives ?? []
-		},
-		next: null,
-		text: lines.join("\n")
-	};
-}
-function muteChannel(client, request) {
-	return setChannelMute(client, request, "mute");
-}
-function unmuteChannel(client, request) {
-	return setChannelMute(client, request, "unmute");
-}
-async function channelMembers(client, request) {
-	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);
-	return {
-		ok: true,
-		state: "members",
-		data: result.data,
-		next: null,
-		text: formatAgentChannelMembers(result.data)
-	};
-}
-async function listThreads(client) {
-	const result = await client.threads.list();
-	if (!result.ok) return failureFromClientResult(result);
-	const threads = result.data.threads;
-	return {
-		ok: true,
-		state: threads.length > 0 ? "threads" : "empty",
-		data: threads,
-		next: null,
-		text: formatAgentThreadList(threads)
-	};
-}
-async function unfollowThread(client, request) {
-	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,
-		...request.reason ? { reason: request.reason } : {}
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	return {
-		ok: true,
-		state: "unfollowed",
-		data: { target: request.target },
-		next: null,
-		text: `Unfollowed ${request.target}. Ordinary delivery from this thread stops; a direct @mention reactivates the follow.`
-	};
-}
-//#endregion
-//#region ../shared/src/agentOps/server.ts
-function nextCommand(section, request, offset, limit, total) {
-	const nextOffset = offset + limit;
-	if (nextOffset >= total) return void 0;
-	const parts = [
-		"raft server info",
-		`--${section}`,
-		`--offset ${nextOffset}`,
-		`--limit ${limit}`
-	];
-	if (section === "channels" && request.joined) parts.push("--joined");
-	return parts.join(" ");
-}
-async function serverInfo(client, request = {}) {
-	const result = await client.server.info();
-	if (!result.ok) return failureFromClientResult(result);
-	const server = result.data;
-	const view = request.view ?? "summary";
-	if (view === "summary") return {
-		ok: true,
-		state: "info",
-		data: {
-			view,
-			server,
-			page: null
-		},
-		next: {
-			kind: "list_channels",
-			command: "raft server info --channels",
-			why: "The summary only counts; list a section to see names."
-		},
-		text: formatAgentServerSummary(server)
-	};
-	if (view === "full") return {
-		ok: true,
-		state: "info",
-		data: {
-			view,
-			server,
-			page: null
-		},
-		next: null,
-		text: formatAgentServerInfo(server)
-	};
-	const limit = Math.max(1, Math.trunc(request.limit ?? 50));
-	const offset = Math.max(0, Math.trunc(request.offset ?? 0));
-	const rows = view === "channels" ? server.channels.filter((c) => !request.joined || c.joined) : view === "agents" ? server.agents : server.humans;
-	const pageRows = rows.slice(offset, offset + limit);
-	const page = {
-		section: view,
-		total: rows.length,
-		offset,
-		limit,
-		nextCommand: nextCommand(view, request, offset, limit, rows.length)
-	};
-	const text = view === "channels" ? formatAgentServerChannels(pageRows, page) : view === "agents" ? formatAgentServerAgents(pageRows, page) : formatAgentServerHumans(pageRows, page);
-	const next = page.nextCommand ? {
-		kind: "next_page",
-		command: page.nextCommand,
-		args: {
-			view,
-			offset: offset + limit,
-			limit
-		},
-		why: "More rows exist; one page is one page."
-	} : null;
-	return {
-		ok: true,
-		state: "info",
-		data: {
-			view,
-			server,
-			page
-		},
-		next,
-		text
-	};
-}
-async function showProfile(client, request = {}, options = {}) {
-	const result = await client.profile.show(request.target ? { target: request.target } : {});
-	if (!result.ok) return failureFromClientResult(result);
-	return {
-		ok: true,
-		state: "profile",
-		data: result.data,
-		next: null,
-		text: formatAgentProfile(result.data, options)
-	};
-}
-async function updateProfile(client, request, options = {}) {
-	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);
-	return {
-		ok: true,
-		state: "updated",
-		data: result.data,
-		next: null,
-		text: formatAgentProfile(result.data, options)
-	};
-}
-//#endregion
-//#region ../shared/src/agentText/attachments.ts
-/** Upload receipt with attachment id and send-usage hint. */
-function formatAgentAttachmentUploaded(attachment) {
-	return `File uploaded: ${attachment.filename} (${(attachment.sizeBytes / 1024).toFixed(1)}KB)\nAttachment ID: ${attachment.id}\n\nUse this ID with raft message send --attachment-id ${attachment.id} to include it in a message.\n`;
-}
-function anchorSummary(anchor) {
-	if (anchor.type === "md-section") {
-		const title = anchor.data.headingTitle ?? anchor.data.headingId;
-		return typeof title === "string" && title ? `§ ${title}` : "§ section";
-	}
-	if (anchor.type === "lines" || anchor.type === "csv-rows") {
-		const start = Number(anchor.data.start);
-		const end = Number(anchor.data.end ?? start);
-		if (!Number.isFinite(start)) return anchor.type;
-		const prefix = anchor.type === "lines" ? "L" : "rows ";
-		return start === (Number.isFinite(end) ? end : start) ? `${prefix}${start}` : `${prefix}${start}–${end}`;
-	}
-	if (anchor.type === "html-region") {
-		const quote = anchor.data.quote;
-		if (typeof quote === "string" && quote.trim().length > 0) {
-			const trimmed = quote.trim();
-			return trimmed.length > 60 ? `${trimmed.slice(0, 60)}…` : trimmed;
-		}
-		return "HTML region";
-	}
-	return anchor.type;
-}
-/** Attachment-scoped comment list incl. anchors/reactions, or its empty state. */
-function formatAgentAttachmentComments(attachmentId, comments, threadChannelId) {
-	if (comments.length === 0) return `No comments on attachment ${attachmentId.slice(0, 8)}.\n`;
-	const lines = [`## Comments on attachment ${attachmentId.slice(0, 8)} (${comments.length})`];
-	for (const c of comments) {
-		const check = c.reactions.some((r) => r.emoji === "✅") ? " ✅" : "";
-		const anchor = c.anchor ? ` [anchor: ${anchorSummary(c.anchor)}]` : "";
-		lines.push(`[msg=${c.id.slice(0, 8)} time=${c.createdAt} type=${c.senderType}]${check}${anchor} @${c.senderName}: ${c.content}`);
-	}
-	if (threadChannelId) lines.push(`(full conversation lives in thread channel ${threadChannelId})`);
-	return lines.join("\n") + "\n";
-}
-//#endregion
-//#region ../shared/src/agentOps/attachments.ts
-/** 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 = {
-	".jpg": "image/jpeg",
-	".jpeg": "image/jpeg",
-	".png": "image/png",
-	".gif": "image/gif",
-	".webp": "image/webp",
-	".pdf": "application/pdf",
-	".txt": "text/plain",
-	".md": "text/markdown",
-	".json": "application/json",
-	".csv": "text/csv"
-};
-const MIME_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
-function sniffMimeType(bytes) {
-	const starts = (sig) => sig.every((b, i) => bytes[i] === b);
-	if (bytes.length >= 8 && starts([
-		137,
-		80,
-		78,
-		71,
-		13,
-		10,
-		26,
-		10
-	])) return "image/png";
-	if (bytes.length >= 3 && starts([
-		255,
-		216,
-		255
-	])) return "image/jpeg";
-	if (bytes.length >= 6) {
-		const header = String.fromCharCode(...bytes.subarray(0, 6));
-		if (header === "GIF87a" || header === "GIF89a") return "image/gif";
-	}
-	if (bytes.length >= 12 && String.fromCharCode(...bytes.subarray(0, 4)) === "RIFF" && String.fromCharCode(...bytes.subarray(8, 12)) === "WEBP") return "image/webp";
-	return null;
-}
-/** Explicit type wins; otherwise sniff the bytes, then the filename extension, then octet-stream. */
-function inferAttachmentMimeType(filename, bytes, explicit) {
-	const normalized = explicit?.trim().toLowerCase();
-	if (normalized && MIME_TYPE_RE.test(normalized)) return normalized;
-	const dot = filename.lastIndexOf(".");
-	const ext = dot >= 0 ? filename.slice(dot).toLowerCase() : "";
-	return sniffMimeType(bytes) ?? FILENAME_MIME_MAP[ext] ?? "application/octet-stream";
-}
-/**
-* Upload bytes into a conversation, choosing the path the CLI would: multipart
-* `POST /upload` below the Server's direct-upload threshold, an upload session
-* (create → PUT to a presigned URL → complete) at or above it.
-*/
-async function uploadAttachment(client, transport, request) {
-	if (!request.target?.trim() || !request.filename?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A target and a filename are required to upload." }));
-	if (!(request.bytes instanceof Uint8Array) || request.bytes.byteLength === 0) return failureOutcome(opError("INVALID_REQUEST", { message: "Refusing to upload a 0-byte attachment." }));
-	if (request.mimeType !== void 0 && !MIME_TYPE_RE.test(request.mimeType.trim())) return failureOutcome(opError("INVALID_REQUEST", { message: `mimeType must look like type/subtype, got: ${request.mimeType}` }));
-	const capability = await client.attachments.uploadCapabilities();
-	const maxBytes = capability.ok ? capability.data.maxBytes : AGENT_ATTACHMENT_UPLOAD_FALLBACK_MAX_BYTES;
-	const threshold = capability.ok && capability.data.directUploadEnabled ? capability.data.directUploadThresholdBytes : null;
-	if (request.bytes.byteLength > maxBytes) return failureOutcome(opError("INVALID_REQUEST", { message: `Attachment is ${request.bytes.byteLength} bytes; the Server's maximum is ${maxBytes}.` }));
-	const resolved = await client.channels.resolve({ target: request.target });
-	if (!resolved.ok) return failureFromClientResult(resolved);
-	const channelId = resolved.data.channelId;
-	const mimeType = inferAttachmentMimeType(request.filename, request.bytes, request.mimeType);
-	if (threshold !== null && request.bytes.byteLength >= threshold) return uploadThroughSession(client, transport, request, channelId, mimeType);
-	const copy = new Uint8Array(request.bytes.byteLength);
-	copy.set(request.bytes);
-	const form = new FormData();
-	form.append("file", new Blob([copy.buffer], { type: mimeType }), request.filename);
-	form.append("channelId", channelId);
-	if (request.mimeType) form.append("mimeType", mimeType);
-	const headers = new Headers(transport.headers);
-	headers.delete("content-type");
-	headers.set("accept", "application/json");
-	headers.set("authorization", transport.authorization);
-	let response;
-	try {
-		response = await transport.fetch(`${transport.serverUrl}${agentApiContract.attachmentUpload.fullPath}`, {
-			method: "POST",
-			headers,
-			body: form
-		});
-	} catch {
-		return failureOutcome(opError("TRANSPORT_ERROR"));
-	}
-	let body = null;
-	try {
-		body = await response.json();
-	} catch {
-		body = null;
-	}
-	if (!response.ok) {
-		const b = body && typeof body === "object" ? body : {};
-		return failureOutcome(opErrorFromClientError({
-			kind: "http",
-			reason: "http_error",
-			message: typeof b.error === "string" ? b.error : `HTTP ${response.status}`,
-			status: response.status,
-			errorCode: typeof b.errorCode === "string" ? b.errorCode : typeof b.code === "string" ? b.code : null,
-			suggestedNextAction: typeof b.suggestedNextAction === "string" ? b.suggestedNextAction : null
-		}));
-	}
-	const parsed = agentApiContract.attachmentUpload.response.body.safeParse(body);
-	if (!parsed.success) return failureOutcome(opError("INVALID_RESPONSE"));
-	return uploadedOutcome(request.target, parsed.data, mimeType);
-}
-function uploadedOutcome(target, data, mimeType) {
-	return {
-		ok: true,
-		state: "uploaded",
-		data: {
-			...data,
-			target,
-			mimeType: data.mimeType ?? mimeType
-		},
-		next: {
-			kind: "send_with_attachment",
-			command: `raft message send --target "${target}" --attachment-id ${data.id}`,
-			args: {
-				target,
-				attachmentIds: [data.id]
-			},
-			why: "The upload alone posts nothing; send a message that links the attachment id."
-		},
-		text: formatAgentAttachmentUploaded(data)
-	};
-}
-const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-/**
-* Direct upload for files at or above the Server's threshold, mirroring the
-* CLI: create a session, PUT the bytes to the presigned URL (fetch; one retry
-* when the object store may have committed), then complete, which the Server
-* verifies against the object store. A PUT that definitely failed cancels the
-* session; a PUT whose outcome is unknown leaves it for completion to verify.
-*/
-async function uploadThroughSession(client, transport, request, channelId, mimeType) {
-	const created = await client.attachments.createUploadSession({
-		channelId,
-		filename: request.filename,
-		mimeType,
-		sizeBytes: request.bytes.byteLength,
-		clientRequestId: crypto.randomUUID()
-	});
-	if (!created.ok) return failureFromClientResult(created);
-	const { uploadId, upload } = created.data;
-	const body = new Uint8Array(request.bytes.byteLength);
-	body.set(request.bytes);
-	let definitelyFailed = null;
-	for (let attempt = 0; attempt < 2; attempt += 1) {
-		let response;
-		try {
-			response = await transport.fetch(upload.url, {
-				method: upload.method ?? "PUT",
-				headers: { ...upload.headers },
-				body: body.buffer,
-				redirect: "error"
-			});
-		} catch {
-			if (attempt === 0) continue;
-			break;
-		}
-		if (response.ok || response.status === 412) {
-			definitelyFailed = null;
-			break;
-		}
-		const mayExist = response.status === 408 || response.status === 429 || response.status >= 500;
-		if (mayExist && attempt === 0) continue;
-		if (!mayExist) definitelyFailed = response.status;
-		break;
-	}
-	if (definitelyFailed !== null) {
-		await client.attachments.cancelUploadSession({ uploadId }).catch(() => void 0);
-		return failureOutcome(opError("HTTP_ERROR", {
-			message: `Direct object upload failed with HTTP ${definitelyFailed}; the upload session was cancelled.`,
-			status: definitelyFailed,
-			nextAction: "Retry the upload; nothing was attached."
-		}));
-	}
-	for (let attempt = 0; attempt < 3; attempt += 1) {
-		const completed = await client.attachments.completeUploadSession({ uploadId });
-		if (completed.ok) {
-			const attachment = completed.data.attachment;
-			return uploadedOutcome(request.target, attachment, mimeType);
-		}
-		const code = completed.error.kind === "http" ? completed.error.errorCode : null;
-		if (!(code === "UPLOAD_OBJECT_NOT_FOUND" || code === "UPLOAD_VERIFICATION_IN_PROGRESS") || attempt === 2) return failureFromClientResult(completed);
-		await wait(250 * (attempt + 1));
-	}
-	return failureOutcome(opError("UNAVAILABLE", { message: "Direct upload completion ended without a terminal response." }));
-}
-async function downloadAttachment(client, request) {
-	if (!request.attachmentId?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "An attachment id is required." }));
-	const result = await client.attachments.download({ attachmentId: request.attachmentId });
-	if (!result.ok) return failureFromClientResult(result);
-	const bytes = result.data;
-	return {
-		ok: true,
-		state: "downloaded",
-		data: {
-			attachmentId: request.attachmentId,
-			bytes
-		},
-		next: null,
-		text: `Downloaded attachment ${request.attachmentId.slice(0, 8)} (${bytes.byteLength} bytes).`
-	};
-}
-async function attachmentComments(client, request) {
-	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);
-	const data = result.data;
-	return {
-		ok: true,
-		state: data.comments.length > 0 ? "comments" : "empty",
-		data: {
-			...data,
-			attachmentId: request.attachmentId
-		},
-		next: null,
-		text: formatAgentAttachmentComments(request.attachmentId, data.comments, data.threadChannelId)
-	};
-}
-//#endregion
-//#region ../shared/src/agentText/search.ts
-/** 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");
-	const offsetMinutes = -d.getTimezoneOffset();
-	const sign = offsetMinutes >= 0 ? "+" : "-";
-	const absOffset = Math.abs(offsetMinutes);
-	const offset = `${sign}${pad(Math.floor(absOffset / 60))}:${pad(absOffset % 60)}`;
-	return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())} ${offset}`;
-}
-function renderSearchSource(result) {
-	if (result.channelType === "thread") {
-		const shortId = typeof result.channelName === "string" && result.channelName.startsWith("thread-") ? result.channelName.slice(7) : typeof result.threadId === "string" && result.threadId ? result.threadId.slice(0, 8) : result.channelName;
-		if (result.parentChannelType === "dm") return `dm:${neutralizeAgentRaftRefLiterals(result.parentChannelName ?? "unknown")}:${shortId}`;
-		return `thread:${neutralizeAgentRaftRefLiterals(result.parentChannelName ?? "unknown")}:${shortId}`;
-	}
-	if (result.channelType === "dm") return `dm:${neutralizeAgentRaftRefLiterals(result.channelName ?? "unknown")}`;
-	return `channel:${neutralizeAgentRaftRefLiterals(result.channelName ?? "unknown")}`;
-}
-const PREVIEW_BEFORE_CHARS = 80;
-const PREVIEW_AFTER_CHARS = 120;
-const PREVIEW_FALLBACK_CHARS = 200;
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function findSearchMatch(content, query) {
-	const normalizedQuery = query.trim();
-	if (!normalizedQuery) return null;
-	const exactIndex = content.toLowerCase().indexOf(normalizedQuery.toLowerCase());
-	if (exactIndex >= 0) return {
-		start: exactIndex,
-		end: exactIndex + normalizedQuery.length
-	};
-	const terms = normalizedQuery.match(/"([^"]+)"|\S+/g) ?? [];
-	for (const rawTerm of terms) {
-		const term = rawTerm.replace(/^"|"$/g, "").trim();
-		if (!term) continue;
-		const match = new RegExp(escapeRegExp(term), "i").exec(content);
-		if (match?.index !== void 0) return {
-			start: match.index,
-			end: match.index + match[0].length
-		};
-	}
-	return null;
-}
-function* findRaftRefLiteralRanges(content) {
-	for (const match of content.matchAll(/\bdm:@[A-Za-z0-9][A-Za-z0-9_-]*(?:~(?:agent|human))?/g)) if (match.index !== void 0) yield {
-		start: match.index,
-		end: match.index + match[0].length
-	};
-	for (const match of content.matchAll(/\btask #[0-9]+\b/g)) if (match.index !== void 0) yield {
-		start: match.index,
-		end: match.index + match[0].length
-	};
-	for (const match of content.matchAll(/(^|[\n\s([{"'`;])(@[A-Za-z0-9][A-Za-z0-9_-]*)/g)) {
-		if (match.index === void 0) continue;
-		const prefix = match[1] ?? "";
-		const ref = match[2] ?? "";
-		yield {
-			start: match.index + prefix.length,
-			end: match.index + prefix.length + ref.length
-		};
-	}
-	for (const match of content.matchAll(/(^|[\n\s([{"'`;])(#[A-Za-z][A-Za-z0-9_-]*)/g)) {
-		if (match.index === void 0) continue;
-		const prefix = match[1] ?? "";
-		const ref = match[2] ?? "";
-		yield {
-			start: match.index + prefix.length,
-			end: match.index + prefix.length + ref.length
-		};
-	}
-}
-function expandSearchMatchToRefLiteral(content, match) {
-	for (const refRange of findRaftRefLiteralRanges(content)) if (match.start < refRange.end && match.end > refRange.start) return {
-		start: Math.min(match.start, refRange.start),
-		end: Math.max(match.end, refRange.end)
-	};
-	return match;
-}
-function trimPreviewWindow(content, start, end) {
-	let trimmedStart = start;
-	let trimmedEnd = end;
-	while (trimmedStart > 0 && /\s/.test(content[trimmedStart] ?? "")) trimmedStart += 1;
-	while (trimmedEnd < content.length && /\s/.test(content[trimmedEnd - 1] ?? "")) trimmedEnd -= 1;
-	return {
-		start: Math.max(0, Math.min(trimmedStart, content.length)),
-		end: Math.max(0, Math.min(trimmedEnd, content.length))
-	};
-}
-function escapeSearchComponentLiterals(text) {
-	return text.replace(/<\/?(?:result|preview|match)\b[^>]*>|<omit\s*\/>/gi, (tag) => tag.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"));
-}
-/** Neutralise `@handle`, `#channel`, `dm:@peer`, and `task #N` literals so quoted text cannot route attention. */
-function neutralizeAgentRaftRefLiterals(text) {
-	return text.replace(/\bdm:@([A-Za-z0-9][A-Za-z0-9_-]*(?:~(?:agent|human))?)/g, "dm:user:$1").replace(/\btask #([0-9]+)\b/g, "task:$1").replace(/(^|[\n\s([{"'`;])@([A-Za-z0-9][A-Za-z0-9_-]*)/g, "$1user:$2").replace(/(^|[\n\s([{"'`;])#([A-Za-z][A-Za-z0-9_-]*)/g, "$1channel:$2");
-}
-function renderAgentSearchPreviewText(text) {
-	return neutralizeAgentRaftRefLiterals(escapeSearchComponentLiterals(text));
-}
-function renderSearchPreview(content, query) {
-	const foundMatch = findSearchMatch(content, query);
-	const match = foundMatch ? expandSearchMatchToRefLiteral(content, foundMatch) : null;
-	let start = 0;
-	let end = Math.min(content.length, PREVIEW_FALLBACK_CHARS);
-	if (match) {
-		start = Math.max(0, match.start - PREVIEW_BEFORE_CHARS);
-		end = Math.min(content.length, match.end + PREVIEW_AFTER_CHARS);
-	}
-	({start, end} = trimPreviewWindow(content, start, end));
-	const leadingOmit = start > 0 ? "<omit />" : "";
-	const trailingOmit = end < content.length ? "<omit />" : "";
-	if (!match || match.end <= start || match.start >= end) return `${leadingOmit}${renderAgentSearchPreviewText(content.slice(start, end))}${trailingOmit}`;
-	const before = content.slice(start, match.start);
-	const matched = content.slice(match.start, match.end);
-	const after = content.slice(match.end, end);
-	return [
-		leadingOmit,
-		renderAgentSearchPreviewText(before),
-		"<match>",
-		renderAgentSearchPreviewText(matched),
-		"</match>",
-		renderAgentSearchPreviewText(after),
-		trailingOmit
-	].join("");
-}
-/** 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)}`;
-	const effectiveLimit = Math.min(limit ?? 20, 50);
-	const countEqualsLimit = (data.results?.length ?? 0) === effectiveLimit;
-	const limitSource = limit === void 0 ? `the server default of ${effectiveLimit}` : limit > 50 ? `the server cap of ${effectiveLimit} (your --limit ${limit} was clamped)` : `the --limit ${effectiveLimit} that was requested`;
-	const atCapRemedy = effectiveLimit < 50 ? "re-run with a higher --limit to tell the two apart" : `this is already the server's maximum page, so completeness CANNOT be determined from this result: a higher --limit is clamped back to ${effectiveLimit} and paging will not reveal it; narrow the query (add --sender, --target, --after or --before) until fewer than ${effectiveLimit} results match`;
-	const truncation = data.hasMore === true ? `truncated=true · more results exist, ${nextPageHint}` : data.hasMore === false ? countEqualsLimit ? `truncated=unknown · server reported hasMore=false, but this page returned exactly ${limitSource}, which is also what a capped page returns; ${atCapRemedy}` : "truncated=false" : "truncated=unknown · server did not report hasMore";
-	if (!data.results || data.results.length === 0) return `No search results. (${truncation})`;
-	const formatted = data.results.map((result) => {
-		const ref = `msg:${result.id}`;
-		const content = result.content ?? result.snippet ?? "";
-		const sender = neutralizeAgentRaftRefLiterals(result.senderName ?? "unknown");
-		const senderType = result.senderType ? ` (${result.senderType})` : "";
-		const taskProjection = formatAgentTaskCurrentProjection(result.taskCurrentProjection, result.taskNumber, renderAgentSearchPreviewText).trimStart();
-		return [
-			`<result ref="${ref}">`,
-			`Source: ${renderSearchSource(result)}`,
-			`Sender: ${sender}${senderType}`,
-			`Time: ${result.createdAt ? formatLocalTimeWithOffset(result.createdAt) : "-"}`,
-			...taskProjection ? [taskProjection] : [],
-			"",
-			"<preview>",
-			renderSearchPreview(content, trimmedQuery),
-			"</preview>",
-			"</result>"
-		].join("\n");
-	}).join("\n\n");
-	const resultLabel = data.results.length === 1 ? "result" : "results";
-	const count = `${data.results.length} ${resultLabel} · ${truncation}`;
-	return [
-		trimmedQuery ? `Search results for: "${trimmedQuery}" (${count})` : `Filtered message results (${count})`,
-		"",
-		formatted,
-		"",
-		"If a result may be relevant but its preview is not enough, read the surrounding context for that result before answering."
-	].join("\n");
-}
-//#endregion
-//#region ../shared/src/agentOps/search.ts
-async function searchMessages(client, request) {
-	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() } : {},
-		...request.target ? { channel: request.target } : {},
-		...request.sender ? { sender: request.sender } : {},
-		...request.sort ? { sort: request.sort } : {},
-		...request.before ? { before: request.before } : {},
-		...request.after ? { after: request.after } : {},
-		...request.limit === void 0 ? {} : { limit: String(request.limit) },
-		...request.offset === void 0 ? {} : { offset: String(request.offset) }
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	const data = result.data;
-	const hasMore = typeof data.hasMore === "boolean" ? data.hasMore : null;
-	const page = {
-		query: request.query?.trim() ?? "",
-		results: data.results,
-		hasMore
-	};
-	const next = hasMore ? {
-		kind: "next_search_page",
-		args: {
-			...request,
-			offset: (request.offset ?? 0) + data.results.length
-		},
-		why: "More results exist; page on, or narrow the query."
-	} : null;
-	return {
-		ok: true,
-		state: data.results.length > 0 ? "results" : "empty",
-		data: page,
-		next,
-		text: formatAgentSearchResults(page.query, {
-			results: data.results,
-			...hasMore === null ? {} : { hasMore }
-		}, request.offset, request.sort, request.limit)
-	};
-}
-async function resolveMessage(client, request) {
-	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);
-	const message = projectRaftMessage(result.data.message);
-	if (!message) return failureOutcome(opError("INVALID_RESPONSE", { message: "The resolved message carries no conversation identity." }));
-	return {
-		ok: true,
-		state: "message",
-		data: message,
-		next: {
-			kind: "read_target",
-			command: `raft message read --target "${message.target}" --around ${message.shortId ?? request.messageId}`,
-			args: {
-				target: message.target,
-				around: message.id ?? request.messageId
-			},
-			why: "Read the surrounding context before acting on one message."
-		},
-		text: formatAgentMessages([toAgentMessageLike(message.raw)])
-	};
-}
-async function reactToMessage(client, request, action = "add") {
-	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 };
-	const result = action === "add" ? await client.messages.addReaction(params, { emoji }) : await client.messages.removeReaction(params, { emoji });
-	if (!result.ok) return failureFromClientResult(result);
-	const verb = action === "add" ? "added to" : "removed from";
-	return {
-		ok: true,
-		state: action === "add" ? "added" : "removed",
-		data: {
-			messageId: request.messageId,
-			emoji
-		},
-		next: null,
-		text: `Reaction ${emoji} ${verb} message ${request.messageId.slice(0, 8)}.`
-	};
-}
-//#endregion
-//#region ../shared/src/agentText/mentions.ts
-function normalizeAgentMentionAction(action) {
-	if (action === "notify" || action === "notify_only") return "notify";
-	if (action === "add" || action === "invite") return "add";
-	return null;
-}
-function formatActionCommands(action) {
-	const verbs = action.availableActions.map(normalizeAgentMentionAction).filter((verb) => verb !== null);
-	return Array.from(new Set(verbs)).map((verb) => `  ${verb}: raft mention ${verb} ${action.resolutionId}`);
-}
-function formatAuthoredMentionToken(targetHandle) {
-	return targetHandle.startsWith("@") ? targetHandle : `@${targetHandle}`;
-}
-const PENDING_MENTION_ACTION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** Per-token mention recovery command line; null when the id is not a UUID (fail closed). */
-function formatAgentMentionNotifyRecoveryCommand(resolutionId) {
-	return PENDING_MENTION_ACTION_ID_RE.test(resolutionId) ? `raft mention notify ${resolutionId}` : null;
-}
-function toAgentSenderPendingMentionAction(action) {
-	return {
-		resolutionId: action.resolutionId,
-		messageId: action.messageId,
-		targetHandle: formatAuthoredMentionToken(action.targetHandle),
-		status: "not_queued",
-		reason: "not_in_conversation",
-		consequence: "This @mention did not notify anyone.",
-		expiresAt: action.expiresAt ?? null,
-		recoveryCommand: formatAgentMentionNotifyRecoveryCommand(action.resolutionId)
-	};
-}
-function toAgentSenderUnresolvedMentionWarning(targetHandle) {
-	return {
-		targetHandle: formatAuthoredMentionToken(targetHandle),
-		status: "not_queued",
-		reason: "unknown_or_not_visible",
-		consequence: "This @mention did not notify anyone.",
-		expiresAt: null,
-		recoveryCommand: null
-	};
-}
-function formatPendingReason(reason) {
-	if (reason === "not_member") return "not in the conversation at send time, so the @mention was not delivered";
-	return reason;
-}
-function normalizeAgentPendingMentionActions(data) {
-	const value = data;
-	return (Array.isArray(value?.pendingMentionActions) ? value.pendingMentionActions : Array.isArray(value?.actions) ? value.actions : Array.isArray(value?.results) ? value.results : []).filter((item) => Boolean(item && typeof item === "object")).map((item) => ({
-		resolutionId: String(item.resolutionId ?? item.id ?? ""),
-		messageId: String(item.messageId ?? ""),
-		targetType: String(item.targetType ?? "unknown"),
-		targetHandle: String(item.targetHandle ?? ""),
-		reason: String(item.reason ?? "Mention target was not notified at send time."),
-		availableActions: Array.isArray(item.availableActions) ? item.availableActions.map(String) : [],
-		expiresAt: typeof item.expiresAt === "string" ? item.expiresAt : null
-	})).filter((item) => item.resolutionId.length > 0);
-}
-function normalizeAgentMentionActionResults(data) {
-	const value = data;
-	return (Array.isArray(value?.results) ? value.results : Array.isArray(value?.actionResults) ? value.actionResults : []).filter((item) => Boolean(item && typeof item === "object")).map((item) => ({
-		resolutionId: String(item.resolutionId ?? item.id ?? ""),
-		status: String(item.status ?? "not_found"),
-		action: typeof item.action === "string" ? normalizeAgentMentionAction(item.action) : null,
-		messageId: typeof item.messageId === "string" ? item.messageId : null,
-		channelId: typeof item.channelId === "string" ? item.channelId : null,
-		targetType: typeof item.targetType === "string" ? item.targetType : null,
-		targetId: typeof item.targetId === "string" ? item.targetId : null,
-		targetHandle: typeof item.targetHandle === "string" ? item.targetHandle : null,
-		message: typeof item.message === "string" ? item.message : null,
-		reason: typeof item.reason === "string" ? item.reason : null,
-		dedupedResolutionIds: Array.isArray(item.dedupedResolutionIds) ? item.dedupedResolutionIds.filter((id) => typeof id === "string" && id.length > 0) : []
-	})).filter((item) => item.resolutionId.length > 0);
-}
-const PENDING_DEFAULT_LIMIT = 50;
-function pendingPageVerdict(hasMore, limit, shown) {
-	const asked = limit === void 0 ? "server default 50" : `--limit ${limit}`;
-	if (hasMore === true) return (limit ?? PENDING_DEFAULT_LIMIT) >= 100 ? `shown ${shown}, ${asked} — truncated=true · more pending actions exist AND this is the server's maximum page (100); this route has no offset or cursor, so the rest cannot be reached from here — resolve what you can and re-run; rows with no available actions are not actionable here and will remain until they expire` : `shown ${shown}, ${asked} — truncated=true · more pending actions exist; raise --limit (server caps at 100) or resolve these first and re-run`;
-	if (hasMore === false) return `shown ${shown}, ${asked} — truncated=false · this is the complete list`;
-	return `shown ${shown}, ${asked} — truncated=unknown · server did not report has_more, so completeness is NOT asserted`;
-}
-/** Undelivered-mentions partial result (send) or the pending list. */
-function formatAgentPendingMentionActions(actions, opts = {}) {
-	const unresolvedMentionHandles = opts.source === "send" ? Array.from(new Set(opts.unresolvedMentionHandles ?? [])) : [];
-	const pageNote = opts.source === "pending" ? pendingPageVerdict(opts.hasMore, opts.limit, actions.length) : "";
-	if (actions.length === 0 && unresolvedMentionHandles.length === 0) return opts.source === "pending" ? `Pending mention actions\n\nNo pending mention actions. (${pageNote})\n` : "";
-	if (opts.source === "send") {
-		const lines = [
-			"Undelivered mentions — partial result",
-			"Message effect: status=queued. Queue acceptance is the only message proof.",
-			"Do not rerun `raft message send`; the message is already queued and a retry could duplicate it.",
-			"Each row below is bound to the literal @token from your message.",
-			"For a literal name rather than a recipient, wrap the @handle in inline or fenced code.",
-			""
-		];
-		for (const rawAction of actions) {
-			const action = toAgentSenderPendingMentionAction(rawAction);
-			lines.push(`- ${action.targetHandle} — status=${action.status}`);
-			lines.push(`  reason: ${action.reason}`);
-			lines.push(`  consequence: ${action.consequence}`);
-			lines.push(`  pending action: ${action.recoveryCommand ? action.resolutionId : "[invalid pending action id]"}`);
-			if (action.messageId) lines.push(`  message: ${action.messageId}`);
-			lines.push(`  expires: ${action.expiresAt ?? "unknown"}`);
-			if (action.recoveryCommand) {
-				lines.push(`  recovery: ${action.recoveryCommand}`);
-				lines.push("  note: the handle resolved, but the target was not in this conversation at send time. This does not prove the person left the server.");
-				lines.push("  note: notify exits nonzero unless the target queue accepts the delivery.");
-			} else lines.push("  recovery: unavailable because the pending action id is invalid; inspect `raft mention pending` without resending the message.");
-		}
-		for (const rawHandle of unresolvedMentionHandles) {
-			const warning = toAgentSenderUnresolvedMentionWarning(rawHandle);
-			lines.push(`- ${warning.targetHandle} — status=${warning.status}`);
-			lines.push(`  reason: ${warning.reason}`);
-			lines.push(`  consequence: ${warning.consequence}`);
-			lines.push("  pending action: none; no visible target resolved for this token");
-			lines.push("  expires: n/a");
-			lines.push("  recovery: if this was a literal name or prose, wrap it in inline/fenced code; otherwise verify the exact handle and send only a corrected follow-up mention; do not resend this message.");
-		}
-		return `${lines.join("\n")}\n`;
-	}
-	const lines = [
-		"Pending mention actions",
-		`(${pageNote})`,
-		""
-	];
-	for (const action of actions) {
-		const target = action.targetHandle ? `${action.targetHandle} (${action.targetType})` : action.targetType;
-		lines.push(`- ${action.resolutionId} — ${target}`);
-		if (action.messageId) lines.push(`  message: ${action.messageId}`);
-		lines.push(`  reason: ${formatPendingReason(action.reason)}`);
-		if (action.expiresAt) lines.push(`  expires: ${action.expiresAt}`);
-		const commands = formatActionCommands(action);
-		if (commands.length > 0) {
-			lines.push("  recovery commands:");
-			lines.push(...commands);
-			if (commands.some((command) => command.includes(" mention notify "))) lines.push("  note: notify exits nonzero unless the target queue accepts the delivery.");
-		}
-	}
-	return `${lines.join("\n")}\n`;
-}
-function formatMentionActionDetail(result) {
-	const detail = result.message ?? result.reason ?? null;
-	if (result.status === "dropped") return detail ? `not delivered: ${detail}` : "not delivered";
-	return detail;
-}
-/** notify/add action outcome rows. */
-function formatAgentMentionActionResults(action, results) {
-	const lines = [`Mention ${action} results`, ""];
-	if (results.length === 0) {
-		lines.push("No result rows returned.");
-		return `${lines.join("\n")}\n`;
-	}
-	for (const result of results) {
-		const target = result.targetHandle ? ` ${result.targetHandle}` : "";
-		const detail = formatMentionActionDetail(result);
-		const suffix = detail ? ` — ${detail}` : "";
-		lines.push(`- ${result.resolutionId}${target}: ${result.status}${suffix}`);
-		if (result.dedupedResolutionIds && result.dedupedResolutionIds.length > 1) lines.push(`  deduped: ${result.dedupedResolutionIds.join(", ")}`);
-	}
-	if (action === "notify" && results.some((result) => result.status === "queued" && result.reason !== "already_queued")) lines.push("", `Recipient guidance: ${formatAgentReplyAffordance({ non_member_mention: true })}`);
-	return `${lines.join("\n")}\n`;
-}
-function describeDelivery(row) {
-	switch (row.outcome) {
-		case "delivered": return "delivered";
-		case "pending": return "still in flight — do not conclude yet";
-		case "unknown": return "UNKNOWN — our instrument could not see this one; re-check, do not conclude";
-		case "lost": switch (row.reasonCategory) {
-			case "quota": return "LOST — target is rate/quota limited; it will not arrive, re-route or retry later";
-			case "runtime_error": return "LOST — target's runtime rejected delivery; re-route";
-			case "not_launched": return "LOST — target was not running; re-route or start it";
-			case "unclassified": return "LOST — cause is outside the seat-availability set; re-route";
-			default: return "LOST — server sent no category for this row (malformed); treat the cause as unknown";
-		}
-	}
-}
-/** Per-target mention delivery outcome for a message the bound agent sent. */
-function formatAgentSenderMentionDeliveries(messageId, deliveries) {
-	if (deliveries.length === 0) return `Message ${messageId}\n\nNo mention deliveries recorded for this message.\n`;
-	const lines = [`Message ${messageId} — mention delivery per target`, ""];
-	for (const row of deliveries) lines.push(`  ${row.targetHandle || "(unknown target)"}: ${describeDelivery(row)}`);
-	return `${lines.join("\n")}\n`;
-}
-//#endregion
-//#region ../shared/src/agentOps/mentions.ts
-async function pendingMentionActions(client, request = {}) {
-	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);
-	const hasMore = typeof result.data.has_more === "boolean" ? result.data.has_more : null;
-	const first = actions.find((a) => a.availableActions.length > 0);
-	const next = first ? {
-		kind: "resolve_mention",
-		command: `raft mention notify ${first.resolutionId}`,
-		args: {
-			action: "notify",
-			resolutionIds: [first.resolutionId]
-		},
-		why: "This @mention reached nobody at send time; notify the target (or add them) so the message is seen."
-	} : null;
-	return {
-		ok: true,
-		state: actions.length > 0 ? "pending" : "empty",
-		data: {
-			actions,
-			hasMore,
-			limit: request.limit
-		},
-		next,
-		text: formatAgentPendingMentionActions(actions, {
-			source: "pending",
-			...hasMore === null ? {} : { hasMore },
-			limit: request.limit
-		})
-	};
-}
-async function executeMentionAction(client, request) {
-	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({
-		action: request.action,
-		resolutionIds: ids
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	const results = normalizeAgentMentionActionResults(result.data);
-	return {
-		ok: true,
-		state: "executed",
-		data: {
-			action: request.action,
-			results
-		},
-		next: null,
-		text: formatAgentMentionActionResults(request.action, results)
-	};
-}
-async function senderMentionDeliveries(client, request) {
-	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);
-	const data = result.data;
-	return {
-		ok: true,
-		state: data.deliveries.length > 0 ? "deliveries" : "empty",
-		data,
-		next: null,
-		text: formatAgentSenderMentionDeliveries(data.messageId, data.deliveries)
-	};
-}
-//#endregion
-//#region ../shared/src/agentText/knowledge.ts
-function formatMatchReason(result) {
-	const parts = [];
-	for (const { term, matched } of result.correctedTerms ?? []) parts.push(`${term} → ${matched} (typo)`);
-	for (const { from, to } of result.expandedTerms ?? []) parts.push(`${from} → ${to} (concept)`);
-	return parts.length > 0 ? `   matched: ${parts.join(", ")}` : "";
-}
-function formatAgentKnowledgeSearchResults(results) {
-	return results.map((result, index) => {
-		const body = result.firstScreen.trim().split(/\r?\n/).filter(Boolean).map((line) => `   ${line}`).join("\n");
-		const reason = formatMatchReason(result);
-		return `${index + 1}. ${result.slug} — ${result.title}${reason ? `\n${reason}` : ""}${body ? `\n${body}` : ""}`;
-	}).join("\n\n") + "\n";
-}
-function formatAgentKnowledgeStdout(content) {
-	return content.endsWith("\n") ? content : `${content}\n`;
-}
-//#endregion
-//#region ../shared/src/agentOps/manual.ts
-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 invalid = requireContext(request);
-	if (invalid) return invalid;
-	if (!request.topic?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A topic id is required." }));
-	const result = await client.knowledge.get({
-		topic: request.topic.trim(),
-		intent: request.intent.trim(),
-		reason: request.reason.trim()
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	return {
-		ok: true,
-		state: "topic",
-		data: result.data,
-		next: null,
-		text: formatAgentKnowledgeStdout(result.data.content)
-	};
-}
-async function searchManual(client, request) {
-	const invalid = requireContext(request);
-	if (invalid) return invalid;
-	if (!request.query?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "Search keywords are required." }));
-	const result = await client.knowledge.search({
-		query: request.query.trim(),
-		...request.scope ? { scope: request.scope } : {},
-		intent: request.intent.trim(),
-		reason: request.reason.trim()
-	});
-	if (!result.ok) return failureFromClientResult(result);
-	const data = result.data;
-	const results = data.results;
-	const first = results[0];
-	const next = first ? {
-		kind: "read_manual_topic",
-		command: `raft manual get ${first.slug} --intent "…" --reason "…"`,
-		args: { topic: first.slug },
-		why: "Open the best-matching topic."
-	} : null;
-	return {
-		ok: true,
-		state: results.length > 0 ? "results" : "empty",
-		data,
-		next,
-		text: results.length > 0 ? formatAgentKnowledgeSearchResults(results) : "No Manual topics matched. Retry with different keywords, keeping your intent and reason.\n"
-	};
-}
-//#endregion
-//#region ../shared/src/agentOps/state.ts
-const RAFT_STATE_SCHEMA = "raft-sdk-state.v1";
-const RAFT_STATE_CONTINUATIONS_PER_TARGET = 3;
-const RAFT_STATE_CONTINUATIONS_TOTAL = 20;
-function isNullableCursor(value) {
-	return value === null || typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-/** Validate a loaded value; anything unrecognised is treated as an empty store (safe: see file header). */
-function parseRaftState(value) {
-	if (!value || typeof value !== "object") return null;
-	const v = value;
-	if (v.schema !== "raft-sdk-state.v1") return null;
-	if (typeof v.version !== "number" || !Number.isInteger(v.version) || v.version < 0) return null;
-	if (!isNullableCursor(v.cursor ?? null) || !isNullableCursor(v.pendingCursor ?? null)) return null;
-	const frontier = v.frontier;
-	const continuations = Array.isArray(v.continuations) ? v.continuations.filter((c) => {
-		const r = c;
-		return Boolean(r) && typeof r.target === "string" && typeof r.idempotencyKey === "string" && typeof r.contentHash === "string" && typeof r.heldAt === "string";
-	}) : [];
-	return {
-		schema: RAFT_STATE_SCHEMA,
-		version: v.version,
-		cursor: v.cursor ?? null,
-		pendingCursor: v.pendingCursor ?? null,
-		frontier: frontier && frontier.version === 1 ? frontier : {
-			version: 1,
-			targets: {},
-			aliases: {}
-		},
-		continuations
-	};
-}
-/** Hex SHA-256 identifying one logical message (WebCrypto; Workers-safe). */
-async function hashRaftSendContent(target, content, attachmentIds = []) {
-	const bytes = new TextEncoder().encode(`${target}\n${[...attachmentIds].sort().join(",")}\n${content}`);
-	return [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-/**
-* One client's view of the persisted state: loads once, holds the working
-* copy, saves on request. Also used without a store (memory only), so the
-* pending/committed cursor flow behaves the same with or without persistence.
-*/
-var RaftStateSession = class {
-	store;
-	onError;
-	frontier;
-	cursor = null;
-	pendingCursor = null;
-	continuations = [];
-	loadedVersion = void 0;
-	loading = null;
-	dirty = false;
-	constructor(store, frontier, onError) {
-		this.store = store;
-		this.onError = onError;
-		this.frontier = frontier;
-	}
-	get persistent() {
-		return this.store !== void 0;
-	}
-	/** The version loaded from (or last saved to) the store; `undefined` before the first save of an empty store. */
-	get version() {
-		return this.loadedVersion;
-	}
-	/** Load once. A failed or unreadable load starts from an empty state (reported, not thrown). */
-	ensureLoaded() {
-		if (!this.store) return Promise.resolve();
-		this.loading ??= (async () => {
-			let raw = null;
-			try {
-				raw = await this.store.load();
-			} catch (error) {
-				this.onError?.(error, {
-					phase: "load",
-					version: void 0
-				});
-				return;
-			}
-			const state = parseRaftState(raw);
-			if (!state) return;
-			this.loadedVersion = state.version;
-			this.cursor = state.cursor;
-			this.pendingCursor = state.pendingCursor;
-			this.frontier.absorb(state.frontier);
-			this.continuations = state.continuations ?? [];
-		})();
-		return this.loading;
-	}
-	markDirty() {
-		this.dirty = true;
-	}
-	/** Record the cursor of a batch just returned. Acknowledges nothing. */
-	setPending(cursor) {
-		if (cursor === null || cursor === this.pendingCursor) return;
-		this.pendingCursor = cursor;
-		this.dirty = true;
-	}
-	/**
-	* Promote a cursor to committed. With no argument, commits `pendingCursor`.
-	* Returns the committed cursor, or null when there was nothing to commit.
-	* Never moves the committed cursor backwards.
-	*/
-	commit(cursor) {
-		const next = cursor === void 0 ? this.pendingCursor : cursor;
-		if (next === null || next === void 0) return null;
-		if (this.cursor === null || next > this.cursor) this.cursor = next;
-		if (this.pendingCursor !== null && this.pendingCursor <= this.cursor) this.pendingCursor = null;
-		this.dirty = true;
-		return this.cursor;
-	}
-	findContinuation(target, contentHash) {
-		return this.continuations.find((c) => c.target === target && c.contentHash === contentHash);
-	}
-	rememberContinuation(entry) {
-		this.continuations = this.continuations.filter((c) => !(c.target === entry.target && c.contentHash === entry.contentHash));
-		this.continuations.push(entry);
-		const perTarget = this.continuations.filter((c) => c.target === entry.target);
-		for (const drop of perTarget.slice(0, Math.max(0, perTarget.length - 3))) this.continuations.splice(this.continuations.indexOf(drop), 1);
-		if (this.continuations.length > 20) this.continuations.splice(0, this.continuations.length - 20);
-		this.dirty = true;
-	}
-	forgetContinuation(target, contentHash) {
-		const before = this.continuations.length;
-		this.continuations = this.continuations.filter((c) => !(c.target === target && c.contentHash === contentHash));
-		if (this.continuations.length !== before) this.dirty = true;
-	}
-	snapshot(nextVersion = (this.loadedVersion ?? 0) + 1) {
-		return {
-			schema: RAFT_STATE_SCHEMA,
-			version: nextVersion,
-			cursor: this.cursor,
-			pendingCursor: this.pendingCursor,
-			frontier: this.frontier.snapshot(),
-			continuations: [...this.continuations]
-		};
-	}
-	/**
-	* Save if anything changed (or `force`). One attempt; a failure is reported
-	* and swallowed. Returns whether the save succeeded (true when nothing to save).
-	*/
-	async save(options = {}) {
-		if (!this.store) return true;
-		if (!this.dirty && !options.force) return true;
-		const expectedVersion = this.loadedVersion;
-		const state = this.snapshot();
-		try {
-			await this.store.save(state, { expectedVersion });
-		} catch (error) {
-			this.onError?.(error, {
-				phase: "save",
-				version: expectedVersion
-			});
-			return false;
-		}
-		this.loadedVersion = state.version;
-		this.dirty = false;
-		return true;
-	}
-};
-//#endregion
-//#region ../shared/src/agentOps/actions.ts
-/** 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`;
-}
-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." }));
-	const result = await client.actions.prepare(request);
-	if (!result.ok) return failureFromClientResult(result);
-	const card = {
-		target: request.target,
-		messageId: result.data.messageId
-	};
-	return {
-		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; its outcome arrives in your inbox."
-		},
-		text: formatAgentActionCardPosted(request.target, card.messageId)
-	};
-}
-//#endregion
-//#region src/raft.ts
-function createRaft(options) {
-	const serverUrl = requireServerUrl(options.serverUrl);
-	const authorization = `Bearer ${requireAgentCredential(options.credential)}`;
-	const frontier = SeenFrontier.fromSnapshot(options.frontier);
-	const session = new RaftStateSession(options.state, frontier, options.onStateSaveError);
-	/** Load before, run, then save if the operation succeeded and changed the state. */
-	const withState = async (run) => {
-		await session.ensureLoaded();
-		const outcome = await run();
-		if (outcome.ok) await session.save();
-		return outcome;
-	};
-	const api = createRaftRouteClient({
-		serverUrl,
-		fetch: options.fetch,
-		headers: options.headers,
-		authorization,
-		readAttempts: options.retry?.attempts,
-		beforeRequest: options.throttle?.beforeRequest
-	});
-	const routes = raftRoutesFromClient(api);
-	const inboxApi = createAgentApiClient({ fetch: {
-		baseUrl: serverUrl,
-		fetch: (input, init) => (options.fetch ?? fetch)(input, {
-			...init,
-			cache: "no-store",
-			redirect: "error"
-		}),
-		headers: Object.fromEntries(new Headers(options.headers)),
-		retry: { attempts: 1 },
-		throttle: options.throttle,
-		auth: { authorization }
-	} });
-	/**
-	* Send through the state session: a resend of the same logical message
-	* (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 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);
-		if (outcome.ok && outcome.state === "held") session.rememberContinuation({
-			target: request.target,
-			idempotencyKey: outcome.data.idempotencyKey,
-			contentHash,
-			heldAt: (/* @__PURE__ */ new Date()).toISOString()
-		});
-		else if (outcome.ok && outcome.state === "sent") session.forgetContinuation(request.target, contentHash);
-		return outcome;
-	});
-	return {
-		identity: { whoami: () => getRaftContext(api) },
-		wake: {
-			verifyNotice: (input) => verifyInboxNotice(input),
-			webhook: {
-				status: () => webhookStatus(api),
-				register: (request) => registerWebhook(api, request),
-				unregister: () => unregisterWebhook(api)
-			}
-		},
-		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();
-				});
-			})(),
-			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),
-			reply: (message, request) => sendWithState({
-				...request,
-				target: message.target
-			}),
-			search: (request) => searchMessages(api, request),
-			resolve: (request) => resolveMessage(api, request),
-			react: (request) => reactToMessage(api, request, "add"),
-			unreact: (request) => reactToMessage(api, request, "remove")
-		},
-		attachments: {
-			upload: (request) => uploadAttachment(api, {
-				serverUrl,
-				fetch: options.fetch ?? fetch,
-				headers: Object.fromEntries(new Headers(options.headers)),
-				authorization
-			}, request),
-			download: (request) => downloadAttachment(api, request),
-			comments: (request) => attachmentComments(api, request)
-		},
-		mentions: {
-			pending: (request) => pendingMentionActions(api, request),
-			execute: (request) => executeMentionAction(api, request),
-			deliveries: (request) => senderMentionDeliveries(api, request)
-		},
-		actions: { prepare: (request) => prepareActionCard(api, request) },
-		manual: {
-			get: (request) => getManualTopic(api, request),
-			search: (request) => searchManual(api, request)
-		},
-		tasks: {
-			claim: (request) => claimTasks(api, request),
-			list: (request) => listTasks(api, request),
-			create: (request) => createTasks(api, request),
-			unclaim: (request) => unclaimTask(api, request),
-			assign: (request) => assignTask(api, request),
-			updateStatus: (request) => updateTaskStatus(api, request),
-			amend: (request) => amendTask(api, request),
-			history: (request) => taskHistory(api, request),
-			convert: (request) => convertMessageToTask(api, request),
-			delete: (request) => deleteTask(api, request)
-		},
-		channels: {
-			join: (request) => joinChannel(api, request),
-			leave: (request) => leaveChannel(api, request),
-			mute: (request) => muteChannel(api, request),
-			unmute: (request) => unmuteChannel(api, request),
-			members: (request) => channelMembers(api, request)
-		},
-		threads: {
-			list: () => listThreads(api),
-			unfollow: (request) => unfollowThread(api, request)
-		},
-		server: { info: (request) => serverInfo(api, request) },
-		profile: {
-			show: (request) => showProfile(api, request),
-			update: (request) => updateProfile(api, request)
+		messages: {
+			read: (request) => readHistory(routes, request, frontier),
+			send: (request) => sendMessage(routes, request, frontier),
+			reply: (message, request) => replyTo(routes, message, request, frontier)
 		},
+		tasks: { claim: (request) => claimTasks(routes, request) },
 		frontier,
-		state: {
-			save: async () => {
-				await session.ensureLoaded();
-				session.markDirty();
-				return session.save();
-			},
-			load: () => session.ensureLoaded(),
-			snapshot: () => session.snapshot(session.version ?? 0)
-		},
 		routes
 	};
 }
@@ -14112,9 +11857,6 @@ function createRaft(options) {
 exports.RAFT_INBOX_NOTICE_SCHEMA = RAFT_INBOX_NOTICE_SCHEMA;
 exports.RAFT_NOTICE_DELIVERY_ID_HEADER = RAFT_NOTICE_DELIVERY_ID_HEADER;
 exports.RAFT_NOTICE_SIGNATURE_HEADER = RAFT_NOTICE_SIGNATURE_HEADER;
-exports.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;
@@ -14126,12 +11868,9 @@ exports.createRaftClientFromStore = createRaftClientFromStore;
 exports.createRaftRoutes = createRaftRoutes;
 exports.describeRaftRoute = describeRaftRoute;
 exports.hasAgentMessageIdentity = hasAgentMessageIdentity;
-exports.hashRaftSendContent = hashRaftSendContent;
-exports.inferAttachmentMimeType = inferAttachmentMimeType;
 exports.joinRaftChannelByTarget = joinRaftChannelByTarget;
 exports.listRaftRoutes = listRaftRoutes;
 exports.parseRaftRegularChannelTarget = parseRaftRegularChannelTarget;
-exports.parseRaftState = parseRaftState;
 exports.projectRaftMessage = projectRaftMessage;
 exports.projectRaftMessages = projectRaftMessages;
 exports.verifyInboxNotice = verifyInboxNotice;