@usecontextlayer/ctxs 0.5.14 → 0.5.16

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1fde104d-ada4-505b-9cff-03f35e9d5ed1")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3bf0713e-bd74-5249-b278-e30de2c2d243")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as Sentry from "@sentry/node";
 import * as fs$2 from "node:fs/promises";
@@ -499,6 +499,59 @@ function formatError$2(error, mapper = (issue) => issue.message) {
 	processError(error);
 	return fieldErrors;
 }
+/** Format a ZodError as a human-readable string in the following form.
+*
+* From
+*
+* ```ts
+* ZodError {
+*   issues: [
+*     {
+*       expected: 'string',
+*       code: 'invalid_type',
+*       path: [ 'username' ],
+*       message: 'Invalid input: expected string'
+*     },
+*     {
+*       expected: 'number',
+*       code: 'invalid_type',
+*       path: [ 'favoriteNumbers', 1 ],
+*       message: 'Invalid input: expected number'
+*     }
+*   ];
+* }
+* ```
+*
+* to
+*
+* ```
+* username
+*   ✖ Expected number, received string at "username
+* favoriteNumbers[0]
+*   ✖ Invalid input: expected number
+* ```
+*/
+function toDotPath(_path) {
+	const segs = [];
+	const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+	for (const seg of path) if (typeof seg === "number") segs.push(`[${seg}]`);
+	else if (typeof seg === "symbol") segs.push(`[${JSON.stringify(String(seg))}]`);
+	else if (/[^\w$]/.test(seg)) segs.push(`[${JSON.stringify(seg)}]`);
+	else {
+		if (segs.length) segs.push(".");
+		segs.push(seg);
+	}
+	return segs.join("");
+}
+function prettifyError(error) {
+	const lines = [];
+	const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+	for (const issue of issues) {
+		lines.push(`✖ ${issue.message}`);
+		if (issue.path?.length) lines.push(`  → at ${toDotPath(issue.path)}`);
+	}
+	return lines.join("\n");
+}
 
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/parse.js
@@ -4722,7 +4775,7 @@ function normalizedKey(event) {
 
 //#endregion
 //#region package.json
-var version$1 = "0.5.14";
+var version$1 = "0.5.16";
 
 //#endregion
 //#region sentry.ts
@@ -5088,8 +5141,10 @@ async function cloneRepo(repo) {
 	], { auth: repo.remote });
 }
 /**
-* Snapshot the working dir to pggit: `add -A` -> commit -> plain `push`. A no-op if
-* nothing changed (a snapshot may find no new bytes under eventual consistency).
+* Snapshot the working dir to pggit: `add -A` -> optional commit -> plain `push`. When
+* nothing changed, no commit is created, but an existing HEAD is still pushed. That
+* retries a prior commit whose push failed without moving the retry outside the caller's
+* serialization boundary.
 * Excludes come from a `.gitignore` the caller commits and owns (ClaudeRepo's
 * CLAUDE_HOME_GITIGNORE is the claude-home one), not from this function.
 * Self-initializes a fresh dir, so it works for both the
@@ -5110,8 +5165,9 @@ async function pushSnapshot(repo, opts) {
 		"diff",
 		"--cached",
 		"--name-only"
-	], { cwd: repo.hostDir })).stdout.trim() === "") return;
-	await runGit([
+	], { cwd: repo.hostDir })).stdout.trim() === "") {
+		if (await localHead(repo) === null) return;
+	} else await runGit([
 		"commit",
 		"-m",
 		opts.message
@@ -5122,6 +5178,9 @@ async function pushSnapshot(repo, opts) {
 			name: CAPTURE_AUTHOR_NAME
 		}
 	});
+	await pushHead(repo);
+}
+async function pushHead(repo) {
 	await runGit([
 		"push",
 		"origin",
@@ -5275,13 +5334,29 @@ async function createIndex(claudeRootDir) {
 async function sessionExists(claudeRootDir, sessionId) {
 	return (await findSessionFiles(claudeRootDir)).some((file) => path.basename(file, ".jsonl") === sessionId);
 }
+/**
+* The absolute path of `sessionId`'s transcript, or null when this home holds none. Same
+* glob as `sessionExists`, but removal needs the path, not the yes/no.
+*
+* Deliberately STRICTER than `sessionExists`, and only here: two matching transcripts in
+* one home make the path ambiguous, and a removal that silently picked one would leave the
+* other behind and still report success. Boot stays lenient because its answer picks a
+* FLAG, never a file to mutate — ambiguity costs it nothing, and throwing there would fail
+* the whole chat over a condition that path can survive.
+*/
+async function findSessionFile(claudeRootDir, sessionId) {
+	const matches = (await findSessionFiles(claudeRootDir)).filter((file) => path.basename(file, ".jsonl") === sessionId);
+	if (matches.length > 1) throw new Error(`claude home ${claudeRootDir}: session ${sessionId} matched ${matches.length} transcripts (expected at most one)`);
+	return matches[0] ?? null;
+}
 async function findSessionFiles(claudeRootDir) {
 	const projects = path.join(claudeRootDir, "projects");
 	let projectDirs;
 	try {
 		projectDirs = await readdir(projects);
-	} catch {
-		return [];
+	} catch (err) {
+		if (isNodeError(err) && err.code === "ENOENT") return [];
+		throw err;
 	}
 	const limit = pLimit(READ_CONCURRENCY);
 	return (await Promise.all(projectDirs.map((dir) => limit(async () => {
@@ -5289,8 +5364,9 @@ async function findSessionFiles(claudeRootDir) {
 		let entries;
 		try {
 			entries = await readdir(full);
-		} catch {
-			return [];
+		} catch (err) {
+			if (isNodeError(err) && (err.code === "ENOENT" || err.code === "ENOTDIR")) return [];
+			throw err;
 		}
 		return entries.filter((e) => e.endsWith(".jsonl")).map((e) => path.join(full, e));
 	})))).flat();
@@ -5408,13 +5484,46 @@ const INDEX_FILENAME = ".ctx-sessions.json";
 * policy in home-watch-plan.ts) plus the caller's teardown pass — one-sandbox-per-session,
 * and the session index (rebuilt whole each capture).
 *
-* Writes do NOT go through ClaudeRepo — claude writes the mounted dir directly, the
-* filesystem is live truth, and ClaudeRepo periodically snapshots it (eventual
-* consistency). A snapshot may capture MID-WRITE state — a pushed transcript can end in
-* a torn half-line — so raw-home readers must tolerate partial tails (the index reader
-* does). Correctness rests on one repoId ↔ one owning process ↔ this one singleton,
-* so the only concurrency it must handle is one user's multiple sessions, which the
-* mutex serializes.
+* Claude's live transcript writes do NOT go through ClaudeRepo — claude writes the mounted
+* dir directly, the filesystem is live truth, and ClaudeRepo periodically snapshots it
+* (eventual consistency). A snapshot may capture MID-WRITE state — a pushed transcript can
+* end in a torn half-line — so raw-home readers must tolerate partial tails (the index
+* reader does).
+*
+* ## SINGLE-WRITER IS A DEPLOYMENT CONSTRAINT, NOT AN INTERNAL DETAIL
+*
+* **One claude home has exactly ONE owning process at a time. ONE container, ONE bridge
+* process for that process lifetime. Concurrent processes serving the same repoId are a
+* DATA-LOSS BUG, not a scaling knob.** Everything below rests on it, and nothing in this
+* class can detect its violation.
+*
+* This class is WRITE-ONLY against the remote after its single clone: `restore()` clones
+* once and memoizes that forever, and `capture()` only ever pushes. There is NO fetch, no
+* pull, no merge, no fast-forward — deliberately, and unlike the multi-writer workspace
+* repo, whose `ensureWorkspaceCheckout` runs the full landlord ladder (clone-if-absent,
+* else compare heads and fast-forward) precisely because it has more than one writer. The
+* asymmetry is the design, not an omission.
+*
+* Two consequences a reader must hold:
+*
+* 1. **The host dir is authoritative for reads only while no other writer advances the
+*    remote after this process clones it.** Anything that asks "does this home contain
+*    X?" — `hasSession`, `removeTranscript` — answers from this process's working copy.
+*    A second writer can make that checkout stale and every such read silently wrong.
+* 2. **A second writer breaks periodic persistence outside the request path.** Pushes are
+*    non-force, so the loser's `capture()` rejects non-fast-forward. The convergence
+*    watcher and connection teardown catch and log that rejection, so chats stop saving
+*    without failing a request. Removal deliberately propagates it to the request.
+*
+* What the premise forbids, concretely: a second bridge replica; two containers sharing a
+* host-dir volume; any out-of-band writer pushing to a `claude/slate/…` repo. The
+* deployment-level ownership contract lives in `ARCHITECTURE.md`.
+*
+* **Before adding a replica, a persistent host-dir volume, or any second writer, this
+* class must first learn to read** — clone-or-fast-forward on entry, and a real answer for
+* "the remote moved under me". Adding only the clone-if-absent guard is the specific trap:
+* it suppresses `git clone`'s LOUD non-empty-destination failure and permits a silent read
+* of a stale working copy. See `restore()`, where that guard would go.
 */
 var ClaudeRepo = class ClaudeRepo {
 	static registry = /* @__PURE__ */ new Map();
@@ -5437,6 +5546,7 @@ var ClaudeRepo = class ClaudeRepo {
 	repo;
 	config;
 	activeSessions = /* @__PURE__ */ new Set();
+	pendingRemovalSessionIds = /* @__PURE__ */ new Set();
 	captureChain = Promise.resolve();
 	restorePromise = null;
 	watchState = INITIAL_WATCH_STATE;
@@ -5497,6 +5607,21 @@ var ClaudeRepo = class ClaudeRepo {
 	* Every success — fresh clone or memoized warm reconnect — arms the watcher when a
 	* session is live: the watcher stops with the last release, so a reconnect to the
 	* kept-warm singleton must re-arm here or the whole session runs unconverged.
+	*
+	* ⚠️ THE UNCONDITIONAL `cloneRepo` IS LOAD-BEARING. DO NOT ADD AN `isCloned` GUARD.
+	* `git clone` refuses a non-empty destination, so a process that starts over a host dir
+	* some earlier process left behind fails HERE, loudly, and blocks the connection. That
+	* throw is the only thing standing between us and a silent stale read: the memo lives in
+	* memory while the dir lives on disk, so a warm dir + a cold registry is exactly the
+	* state where the local copy may no longer match the remote, and every host-dir read
+	* (`hasSession`, `removeTranscript`) would quietly answer from a stale tree. Guarding
+	* the clone trades that loud failure for a wrong answer nobody sees.
+	*
+	* Reusing a warm dir safely needs clone-OR-fast-forward — `ensureWorkspaceCheckout`'s
+	* ladder — which makes this class a READER of its remote and retires the single-writer
+	* premise the class doc sets out. That is a real change with its own decision, not a guard.
+	* (The guard is pinned by the prior-clone case in
+	* packages/slate-bridge/tests/chat-session-delete-cold-home.node.integration.test.ts.)
 	*/
 	async restore() {
 		if (!this.config.restore) return;
@@ -5518,37 +5643,89 @@ var ClaudeRepo = class ClaudeRepo {
 	* The home snapshot (fired by the convergence watcher and the caller's teardown
 	* pass): serialized by the mutex — rebuild the index from the live
 	* home (when maintaining it), then push the whole dir (non-force; a home is
-	* single-writer so the push always fast-forwards). Capture failure is caught +
-	* logged **loud**, never propagated — the bytes are already on disk and the next snapshot
-	* pushes the cumulative state. The one non-self-healing case is an expired token's 401:
-	* the push auth is the connection's upgrade-time user token (real mint TTL: 15 minutes),
-	* so every capture in a chat older than that fails until the user reconnects — and the
-	* turns since the last good push are LOST outright if this host dir dies first. Accepted
-	* for day one (user, 2026-07-09); problem + required outcome tracked in the internal
-	* planned note "chat session token expiry" (2026-07-09).
+	* single-writer so the push always fast-forwards).
+	*
+	* **This PROPAGATES.** Whether a failed snapshot matters is the caller's question, and the
+	* two answers genuinely differ. The periodic pushes — the convergence watcher and the
+	* teardown `(final)` pass — swallow it explicitly at their own call sites, because the
+	* bytes are already on disk and the next snapshot pushes the cumulative state. A REMOVAL
+	* cannot borrow that argument: its only pending change IS the push that just failed, so
+	* there is no later snapshot guaranteed to carry it, and a caller is waiting on the answer.
+	* `removeTranscript` therefore lets the failure through.
+	*
+	* The push auth is the connection's upgrade-time user token. If it expires, snapshots
+	* fail until another connection refreshes this repo's token; unpushed turns are then
+	* vulnerable to loss if the host dir disappears first. Token lifetime is owned by web,
+	* not this repository.
+	*
+	* The mutex chain deliberately does NOT inherit this run's rejection. A chain parked in a
+	* rejected state would fail every snapshot that later queues behind it, turning one bad
+	* push into a permanently dead home — and would make `settle()` reject, which its callers
+	* (teardown paths) rely on never happening. The chain carries ordering only; the failure
+	* goes to whoever called.
 	*/
 	async capture(opts) {
 		const run = this.captureChain.then(async () => {
-			try {
-				await this.ensureGitignore();
-				if (this.config.maintainIndex) await this.writeSessionIndex();
-				await pushSnapshot(this.repo, { message: opts.message });
-			} catch (err) {
-				console.error(`[ClaudeRepo] capture failed (${this.repo.remote.repoId}):`, err);
-			}
+			await this.ensureGitignore();
+			if (this.config.maintainIndex) await this.writeSessionIndex();
+			await pushSnapshot(this.repo, { message: opts.message });
 		});
-		this.captureChain = run;
+		this.captureChain = run.then(() => void 0, () => void 0);
 		return run;
 	}
 	/**
 	* Await the capture chain's quiescence — the shutdown flush. Captures are fired
 	* fire-and-forget by the watcher and the caller's teardown pass; the scope that
 	* fired them awaits this before tearing anything down, so no snapshot outlives
-	* its host dir. Never rejects (capture already contains its own failures).
+	* its host dir. Never rejects — it awaits the ordering chain, which `capture` keeps
+	* rejection-free on purpose, not the snapshot promises themselves.
 	*/
 	async settle() {
 		await this.captureChain;
 	}
+	/**
+	* Remove one session's transcript from the home and snapshot the removal — the GIT half
+	* of deleting a chat, and the only half this class owns. Returns false when the home
+	* holds no such transcript: the chat id is minted client-side and navigated to before
+	* the first turn persists, so deleting a never-used chat is a legitimate no-op.
+	*
+	* The index needs no separate edit — `capture` rebuilds it whole from whatever
+	* transcripts remain, which is why removal costs no index-maintenance code.
+	*
+	* THROWS when removing or snapshotting fails, and that is the point: a failure does not
+	* prove the remote deletion. Once `rm` succeeds, the local state depends on which git step
+	* failed — the deletion may be unstaged, staged, committed, or already accepted remotely.
+	* A retry whose file is already absent re-runs the serialized snapshot, which always
+	* pushes an existing HEAD even when it finds no new diff. Failures before or after commit
+	* therefore cannot turn into a false 204.
+	*
+	* PRECONDITION, the caller's alone: no writer for this session's transcript may remain.
+	* A live guest re-creates the file it is appending to, and its connection's teardown
+	* capture pushes whatever it left behind — silently undoing the removal. This class
+	* holds session IDENTITY, never a handle to the compute, so it cannot check that itself;
+	* whoever owns the sandbox lifecycle must stop and join every connection serving this
+	* session, then `settle()` the shared repo's already-queued captures first.
+	*
+	* Do NOT source existence from the remote instead (the `repo_file` query the read plane
+	* uses). It would make the ANSWER survive a stale working copy but not the OPERATION —
+	* a removal still cannot delete what its working copy does not contain — so it buys a
+	* loud wrong answer in place of a quiet one, and puts two sources of truth inside one
+	* operation.
+	*/
+	async removeTranscript(sessionId) {
+		const file = await findSessionFile(this.repo.hostDir, sessionId);
+		if (file === null) {
+			if (!this.pendingRemovalSessionIds.has(sessionId)) return false;
+			await this.capture({ message: `chat ${this.repo.remote.repoId} (delete ${sessionId})` });
+			this.pendingRemovalSessionIds.delete(sessionId);
+			return false;
+		}
+		this.pendingRemovalSessionIds.add(sessionId);
+		await rm(file);
+		await this.capture({ message: `chat ${this.repo.remote.repoId} (delete ${sessionId})` });
+		this.pendingRemovalSessionIds.delete(sessionId);
+		return true;
+	}
 	async ensureGitignore() {
 		await mkdir(this.repo.hostDir, { recursive: true });
 		const target = path.join(this.repo.hostDir, ".gitignore");
@@ -5589,7 +5766,9 @@ var ClaudeRepo = class ClaudeRepo {
 			dirty: dirty ?? true,
 			now: Date.now()
 		}, config);
-		if (step.push) this.capture({ message: `chat ${this.repo.remote.repoId}` });
+		if (step.push) this.capture({ message: `chat ${this.repo.remote.repoId}` }).catch((err) => {
+			console.error(`[ClaudeRepo] capture failed (${this.repo.remote.repoId}):`, err);
+		});
 		if (this.watchTimer !== null || this.activeSessions.size > 0) this.armWatch(config, step.wakeAfterMs);
 	}
 	async readDirty() {
@@ -10851,7 +11030,7 @@ var JsonError$1 = class JsonError extends Error {
 		this.name = "JsonError";
 	}
 };
-var ParseError$1 = class ParseError extends Error {
+var ParseError$2 = class ParseError extends Error {
 	errors;
 	constructor(errors) {
 		super(errors.map(stringifyValidationError$1).join("; "));
@@ -10869,7 +11048,7 @@ function getSchemaUtils$1(schema) {
 		parseOrThrow: (raw, opts) => {
 			const parsed = schema.parse(raw, opts);
 			if (parsed.ok) return parsed.value;
-			throw new ParseError$1(parsed.errors);
+			throw new ParseError$2(parsed.errors);
 		},
 		jsonOrThrow: (parsed, opts) => {
 			const raw = schema.json(parsed, opts);
@@ -12755,11 +12934,15 @@ const pluginAuthSchema = discriminatedUnion("type", [
 	pluginAuthClientCredentialsSchema,
 	pluginOAuthSchema
 ]).meta({ title: "PluginAuth" });
+const pluginMcpEnabledToolSchema = strictObject({ autoAllow: boolean$1().optional() });
+const pluginMcpEnabledToolsSchema = record$2(string$3().min(1), pluginMcpEnabledToolSchema).refine((tools) => Object.keys(tools).length > 0, { message: "enabledTools must declare at least one tool" }).meta({ title: "PluginMcpEnabledTools" });
 const pluginMcpHttpServerSchema = strictObject({
+	enabledTools: pluginMcpEnabledToolsSchema,
 	type: literal("http"),
 	url: url()
 }).meta({ title: "PluginMcpHttpServer" });
 const pluginMcpModuleServerSchema = strictObject({
+	enabledTools: pluginMcpEnabledToolsSchema,
 	module: string$3().trim().min(1),
 	type: literal("module")
 }).meta({ title: "PluginMcpModuleServer" });
@@ -12864,7 +13047,28 @@ const pluginRegistry = [
 		plugin_id: "linear"
 	},
 	{
-		auth: { type: "client_credentials" },
+		auth: {
+			provider_id: "microsoft",
+			scopes: ["Calendars.ReadWrite"],
+			type: "oauth"
+		},
+		mcpServers: { microsoft_calendar: {
+			enabledTools: {
+				"accept-calendar-event": {},
+				"cancel-calendar-event": {},
+				"create-calendar-event": {},
+				"decline-calendar-event": {},
+				"delete-calendar-event": {},
+				"get-calendar-event": { autoAllow: true },
+				"get-calendar-view": { autoAllow: true },
+				"list-calendar-events": { autoAllow: true },
+				"list-calendars": { autoAllow: true },
+				"tentatively-accept-calendar-event": {},
+				"update-calendar-event": {}
+			},
+			type: "http",
+			url: "https://mcp-microsoft-365.usecontextlayer.com/mcp"
+		} },
 		mode: "dagster",
 		plugin_id: "microsoft_calendar"
 	},
@@ -12875,6 +13079,17 @@ const pluginRegistry = [
 			type: "oauth"
 		},
 		mcpServers: { microsoft_mail: {
+			enabledTools: {
+				"create-draft-email": {},
+				"create-reply-draft": {},
+				"get-mail-message": { autoAllow: true },
+				"list-mail-folder-messages": { autoAllow: true },
+				"list-mail-folders": { autoAllow: true },
+				"list-mail-messages": { autoAllow: true },
+				"reply-mail-message": {},
+				"send-draft-message": {},
+				"send-mail": {}
+			},
 			type: "http",
 			url: "https://mcp-microsoft-365.usecontextlayer.com/mcp"
 		} },
@@ -12888,6 +13103,10 @@ const pluginRegistry = [
 			type: "oauth"
 		},
 		mcpServers: { microsoft_planner_premium: {
+			enabledTools: {
+				submit_operation_set: {},
+				wait_for_operation_set: { autoAllow: true }
+			},
 			module: "@usecontextlayer/mcp-microsoft-planner-premium",
 			type: "module"
 		} },
@@ -12989,6 +13208,13 @@ const providerTokenLeaseSchema = object$4({
 	accessTokenExpiresAt: datetime$2({ offset: true }).transform((value) => new Date(value)).nullable()
 }).meta({ title: "ProviderTokenLease" });
 
+//#endregion
+//#region ../shared/dist/ctx-token-provider.mjs
+function ctxAuthHeaders(tokenProvider) {
+	if (!tokenProvider) return {};
+	return { headers: { Authorization: async () => `Bearer ${await tokenProvider()}` } };
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/jose@6.2.3/node_modules/jose/dist/webapi/lib/buffer_utils.js
 const encoder = new TextEncoder();
@@ -14339,13 +14565,6 @@ function createDevJwtVerifier() {
 	};
 }
 
-//#endregion
-//#region ../shared/dist/index.mjs
-function ctxAuthHeaders(tokenProvider) {
-	if (!tokenProvider) return {};
-	return { headers: { Authorization: async () => `Bearer ${await tokenProvider()}` } };
-}
-
 //#endregion
 //#region ../slate-shared/dist/index.mjs
 const INBOX_DOCS_TREE = {
@@ -20040,7 +20259,7 @@ var require_formdata = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { webidl } = require_webidl();
 	const nodeUtil$2 = __require("node:util");
 	const { runtimeFeatures } = require_runtime_features();
-	const random = runtimeFeatures.has("crypto") ? __require("node:crypto").randomInt : (max) => Math.floor(Math.random() * max);
+	const random$1 = runtimeFeatures.has("crypto") ? __require("node:crypto").randomInt : (max) => Math.floor(Math.random() * max);
 	var FormData = class FormData {
 		#state = [];
 		#boundary = null;
@@ -20140,7 +20359,7 @@ var require_formdata = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		static getFormDataBoundary(formData) {
 			const boundary = formData.#boundary;
 			if (boundary != null) return boundary;
-			return formData.#boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
+			return formData.#boundary = `----formdata-undici-0${`${random$1(1e11)}`.padStart(11, "0")}`;
 		}
 	};
 	const { getFormDataState, setFormDataState, getFormDataBoundary } = FormData;
@@ -38629,7 +38848,7 @@ var JsonError = class JsonError extends Error {
 		this.name = "JsonError";
 	}
 };
-var ParseError = class ParseError extends Error {
+var ParseError$1 = class ParseError extends Error {
 	errors;
 	constructor(errors) {
 		super(errors.map(stringifyValidationError).join("; "));
@@ -38647,7 +38866,7 @@ function getSchemaUtils(schema) {
 		parseOrThrow: (raw, opts) => {
 			const parsed = schema.parse(raw, opts);
 			if (parsed.ok) return parsed.value;
-			throw new ParseError(parsed.errors);
+			throw new ParseError$1(parsed.errors);
 		},
 		jsonOrThrow: (parsed, opts) => {
 			const raw = schema.json(parsed, opts);
@@ -40311,6 +40530,56 @@ const OAuthTokenRevocationRequestSchema = object$4({
 //#region ../../node_modules/.pnpm/pkce-challenge@5.0.1/node_modules/pkce-challenge/dist/index.node.js
 let crypto$2;
 crypto$2 = globalThis.crypto?.webcrypto ?? globalThis.crypto ?? import("node:crypto").then((m) => m.webcrypto);
+/**
+* Creates an array of length `size` of random bytes
+* @param size
+* @returns Array of random ints (0 to 255)
+*/
+async function getRandomValues(size) {
+	return (await crypto$2).getRandomValues(new Uint8Array(size));
+}
+/** Generate cryptographically strong random string
+* @param size The desired length of the string
+* @returns The random string
+*/
+async function random(size) {
+	const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+	const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % 66;
+	let result = "";
+	while (result.length < size) {
+		const randomBytes = await getRandomValues(size - result.length);
+		for (const randomByte of randomBytes) if (randomByte < evenDistCutoff) result += mask[randomByte % 66];
+	}
+	return result;
+}
+/** Generate a PKCE challenge verifier
+* @param length Length of the verifier
+* @returns A random verifier `length` characters long
+*/
+async function generateVerifier(length) {
+	return await random(length);
+}
+/** Generate a PKCE code challenge from a code verifier
+* @param code_verifier
+* @returns The base64 url encoded code challenge
+*/
+async function generateChallenge(code_verifier) {
+	const buffer = await (await crypto$2).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+	return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+}
+/** Generate a PKCE challenge pair
+* @param length Length of the verifer (between 43-128). Defaults to 43.
+* @returns PKCE challenge pair
+*/
+async function pkceChallenge(length) {
+	if (!length) length = 43;
+	if (length < 43 || length > 128) throw `Expected a length between 43 and 128. Received ${length}.`;
+	const verifier = await generateVerifier(length);
+	return {
+		code_verifier: verifier,
+		code_challenge: await generateChallenge(verifier)
+	};
+}
 
 //#endregion
 //#region ../../node_modules/.pnpm/@hono+mcp@0.3.1_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__hono-rate-limiter@0.5.3_hono@4.12.31__hono@4.12.31_zod@4.4.3/node_modules/@hono/mcp/dist/auth.mjs
@@ -40836,6 +41105,7 @@ const InitializedNotificationSchema = NotificationSchema.extend({
 	method: literal("notifications/initialized"),
 	params: NotificationsParamsSchema.optional()
 });
+const isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
 /**
 * A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected.
 */
@@ -54872,6 +55142,1978 @@ var AjvJsonSchemaValidator = class {
 	}
 };
 
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
+/**
+* Experimental client task features for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Experimental task features for MCP clients.
+*
+* Access via `client.experimental.tasks`:
+* ```typescript
+* const stream = client.experimental.tasks.callToolStream({ name: 'tool', arguments: {} });
+* const task = await client.experimental.tasks.getTask(taskId);
+* ```
+*
+* @experimental
+*/
+var ExperimentalClientTasks = class {
+	constructor(_client) {
+		this._client = _client;
+	}
+	/**
+	* Calls a tool and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to tool execution, allowing you to
+	* observe intermediate task status updates for long-running tool calls.
+	* Automatically validates structured output if the tool has an outputSchema.
+	*
+	* @example
+	* ```typescript
+	* const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
+	* for await (const message of stream) {
+	*   switch (message.type) {
+	*     case 'taskCreated':
+	*       console.log('Tool execution started:', message.task.taskId);
+	*       break;
+	*     case 'taskStatus':
+	*       console.log('Tool status:', message.task.status);
+	*       break;
+	*     case 'result':
+	*       console.log('Tool result:', message.result);
+	*       break;
+	*     case 'error':
+	*       console.error('Tool error:', message.error);
+	*       break;
+	*   }
+	* }
+	* ```
+	*
+	* @param params - Tool call parameters (name and arguments)
+	* @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
+		const clientInternal = this._client;
+		const optionsWithTask = {
+			...options,
+			task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
+		};
+		const stream = clientInternal.requestStream({
+			method: "tools/call",
+			params
+		}, resultSchema, optionsWithTask);
+		const validator = clientInternal.getToolOutputValidator(params.name);
+		for await (const message of stream) {
+			if (message.type === "result" && validator) {
+				const result = message.result;
+				if (!result.structuredContent && !result.isError) {
+					yield {
+						type: "error",
+						error: new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
+					};
+					return;
+				}
+				if (result.structuredContent) try {
+					const validationResult = validator(result.structuredContent);
+					if (!validationResult.valid) {
+						yield {
+							type: "error",
+							error: new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
+						};
+						return;
+					}
+				} catch (error) {
+					if (error instanceof McpError) {
+						yield {
+							type: "error",
+							error
+						};
+						return;
+					}
+					yield {
+						type: "error",
+						error: new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`)
+					};
+					return;
+				}
+			}
+			yield message;
+		}
+	}
+	/**
+	* Gets the current status of a task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	* @returns The task status
+	*
+	* @experimental
+	*/
+	async getTask(taskId, options) {
+		return this._client.getTask({ taskId }, options);
+	}
+	/**
+	* Retrieves the result of a completed task.
+	*
+	* @param taskId - The task identifier
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options
+	* @returns The task result
+	*
+	* @experimental
+	*/
+	async getTaskResult(taskId, resultSchema, options) {
+		return this._client.getTaskResult({ taskId }, resultSchema, options);
+	}
+	/**
+	* Lists tasks with optional pagination.
+	*
+	* @param cursor - Optional pagination cursor
+	* @param options - Optional request options
+	* @returns List of tasks with optional next cursor
+	*
+	* @experimental
+	*/
+	async listTasks(cursor, options) {
+		return this._client.listTasks(cursor ? { cursor } : void 0, options);
+	}
+	/**
+	* Cancels a running task.
+	*
+	* @param taskId - The task identifier
+	* @param options - Optional request options
+	*
+	* @experimental
+	*/
+	async cancelTask(taskId, options) {
+		return this._client.cancelTask({ taskId }, options);
+	}
+	/**
+	* Sends a request and returns an AsyncGenerator that yields response messages.
+	* The generator is guaranteed to end with either a 'result' or 'error' message.
+	*
+	* This method provides streaming access to request processing, allowing you to
+	* observe intermediate task status updates for task-augmented requests.
+	*
+	* @param request - The request to send
+	* @param resultSchema - Zod schema for validating the result
+	* @param options - Optional request options (timeout, signal, task creation params, etc.)
+	* @returns AsyncGenerator that yields ResponseMessage objects
+	*
+	* @experimental
+	*/
+	requestStream(request, resultSchema, options) {
+		return this._client.requestStream(request, resultSchema, options);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+/**
+* Experimental task capability assertion helpers.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
+* Asserts that task creation is supported for tools/call.
+* Used by Client.assertTaskCapability and Server.assertTaskHandlerCapability.
+*
+* @param requests - The task requests capability object
+* @param method - The method being checked
+* @param entityName - 'Server' or 'Client' for error messages
+* @throws Error if the capability is not supported
+*
+* @experimental
+*/
+function assertToolsCallTaskCapability(requests, method, entityName) {
+	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
+	switch (method) {
+		case "tools/call":
+			if (!requests.tools?.call) throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+			break;
+		default: break;
+	}
+}
+/**
+* Asserts that task creation is supported for sampling/createMessage or elicitation/create.
+* Used by Server.assertTaskCapability and Client.assertTaskHandlerCapability.
+*
+* @param requests - The task requests capability object
+* @param method - The method being checked
+* @param entityName - 'Server' or 'Client' for error messages
+* @throws Error if the capability is not supported
+*
+* @experimental
+*/
+function assertClientRequestTaskCapability(requests, method, entityName) {
+	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
+	switch (method) {
+		case "sampling/createMessage":
+			if (!requests.sampling?.createMessage) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+			break;
+		case "elicitation/create":
+			if (!requests.elicitation?.create) throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+			break;
+		default: break;
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
+/**
+* Elicitation default application helper. Applies defaults to the data based on the schema.
+*
+* @param schema - The schema to apply defaults to.
+* @param data - The data to apply defaults to.
+*/
+function applyElicitationDefaults(schema, data) {
+	if (!schema || data === null || typeof data !== "object") return;
+	if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
+		const obj = data;
+		const props = schema.properties;
+		for (const key of Object.keys(props)) {
+			const propSchema = props[key];
+			if (obj[key] === void 0 && Object.prototype.hasOwnProperty.call(propSchema, "default")) obj[key] = propSchema.default;
+			if (obj[key] !== void 0) applyElicitationDefaults(propSchema, obj[key]);
+		}
+	}
+	if (Array.isArray(schema.anyOf)) {
+		for (const sub of schema.anyOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
+	}
+	if (Array.isArray(schema.oneOf)) {
+		for (const sub of schema.oneOf) if (typeof sub !== "boolean") applyElicitationDefaults(sub, data);
+	}
+}
+/**
+* Determines which elicitation modes are supported based on declared client capabilities.
+*
+* According to the spec:
+* - An empty elicitation capability object defaults to form mode support (backwards compatibility)
+* - URL mode is only supported if explicitly declared
+*
+* @param capabilities - The client's elicitation capabilities
+* @returns An object indicating which modes are supported
+*/
+function getSupportedElicitationModes(capabilities) {
+	if (!capabilities) return {
+		supportsFormMode: false,
+		supportsUrlMode: false
+	};
+	const hasFormCapability = capabilities.form !== void 0;
+	const hasUrlCapability = capabilities.url !== void 0;
+	return {
+		supportsFormMode: hasFormCapability || !hasFormCapability && !hasUrlCapability,
+		supportsUrlMode: hasUrlCapability
+	};
+}
+/**
+* An MCP client on top of a pluggable transport.
+*
+* The client will automatically begin the initialization flow with the server when connect() is called.
+*
+* To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+*
+* ```typescript
+* // Custom schemas
+* const CustomRequestSchema = RequestSchema.extend({...})
+* const CustomNotificationSchema = NotificationSchema.extend({...})
+* const CustomResultSchema = ResultSchema.extend({...})
+*
+* // Type aliases
+* type CustomRequest = z.infer<typeof CustomRequestSchema>
+* type CustomNotification = z.infer<typeof CustomNotificationSchema>
+* type CustomResult = z.infer<typeof CustomResultSchema>
+*
+* // Create typed client
+* const client = new Client<CustomRequest, CustomNotification, CustomResult>({
+*   name: "CustomClient",
+*   version: "1.0.0"
+* })
+* ```
+*/
+var Client = class extends Protocol {
+	/**
+	* Initializes this client with the given name and version information.
+	*/
+	constructor(_clientInfo, options) {
+		super(options);
+		this._clientInfo = _clientInfo;
+		this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
+		this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
+		this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
+		this._listChangedDebounceTimers = /* @__PURE__ */ new Map();
+		this._capabilities = options?.capabilities ?? {};
+		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+		if (options?.listChanged) this._pendingListChangedConfig = options.listChanged;
+	}
+	/**
+	* Set up handlers for list changed notifications based on config and server capabilities.
+	* This should only be called after initialization when server capabilities are known.
+	* Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
+	* @internal
+	*/
+	_setupListChangedHandlers(config) {
+		if (config.tools && this._serverCapabilities?.tools?.listChanged) this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config.tools, async () => {
+			return (await this.listTools()).tools;
+		});
+		if (config.prompts && this._serverCapabilities?.prompts?.listChanged) this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config.prompts, async () => {
+			return (await this.listPrompts()).prompts;
+		});
+		if (config.resources && this._serverCapabilities?.resources?.listChanged) this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config.resources, async () => {
+			return (await this.listResources()).resources;
+		});
+	}
+	/**
+	* Access experimental features.
+	*
+	* WARNING: These APIs are experimental and may change without notice.
+	*
+	* @experimental
+	*/
+	get experimental() {
+		if (!this._experimental) this._experimental = { tasks: new ExperimentalClientTasks(this) };
+		return this._experimental;
+	}
+	/**
+	* Registers new capabilities. This can only be called before connecting to a transport.
+	*
+	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+	*/
+	registerCapabilities(capabilities) {
+		if (this.transport) throw new Error("Cannot register capabilities after connecting to transport");
+		this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+	}
+	/**
+	* Override request handler registration to enforce client-side validation for elicitation.
+	*/
+	setRequestHandler(requestSchema, handler) {
+		const methodSchema = getObjectShape(requestSchema)?.method;
+		if (!methodSchema) throw new Error("Schema is missing a method literal");
+		let methodValue;
+		if (isZ4Schema(methodSchema)) {
+			const v4Schema = methodSchema;
+			methodValue = (v4Schema._zod?.def)?.value ?? v4Schema.value;
+		} else {
+			const v3Schema = methodSchema;
+			methodValue = v3Schema._def?.value ?? v3Schema.value;
+		}
+		if (typeof methodValue !== "string") throw new Error("Schema method literal must be a string");
+		const method = methodValue;
+		if (method === "elicitation/create") {
+			const wrappedHandler = async (request, extra) => {
+				const validatedRequest = safeParse(ElicitRequestSchema, request);
+				if (!validatedRequest.success) {
+					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
+				}
+				const { params } = validatedRequest.data;
+				params.mode = params.mode ?? "form";
+				const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
+				if (params.mode === "form" && !supportsFormMode) throw new McpError(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
+				if (params.mode === "url" && !supportsUrlMode) throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
+				const result = await Promise.resolve(handler(request, extra));
+				if (params.task) {
+					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+					if (!taskValidationResult.success) {
+						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+					}
+					return taskValidationResult.data;
+				}
+				const validationResult = safeParse(ElicitResultSchema, result);
+				if (!validationResult.success) {
+					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
+				}
+				const validatedResult = validationResult.data;
+				const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
+				if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
+					if (this._capabilities.elicitation?.form?.applyDefaults) try {
+						applyElicitationDefaults(requestedSchema, validatedResult.content);
+					} catch {}
+				}
+				return validatedResult;
+			};
+			return super.setRequestHandler(requestSchema, wrappedHandler);
+		}
+		if (method === "sampling/createMessage") {
+			const wrappedHandler = async (request, extra) => {
+				const validatedRequest = safeParse(CreateMessageRequestSchema, request);
+				if (!validatedRequest.success) {
+					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
+				}
+				const { params } = validatedRequest.data;
+				const result = await Promise.resolve(handler(request, extra));
+				if (params.task) {
+					const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+					if (!taskValidationResult.success) {
+						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+						throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+					}
+					return taskValidationResult.data;
+				}
+				const validationResult = safeParse(params.tools || params.toolChoice ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema, result);
+				if (!validationResult.success) {
+					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+					throw new McpError(ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`);
+				}
+				return validationResult.data;
+			};
+			return super.setRequestHandler(requestSchema, wrappedHandler);
+		}
+		return super.setRequestHandler(requestSchema, handler);
+	}
+	assertCapability(capability, method) {
+		if (!this._serverCapabilities?.[capability]) throw new Error(`Server does not support ${capability} (required for ${method})`);
+	}
+	async connect(transport, options) {
+		await super.connect(transport);
+		if (transport.sessionId !== void 0) return;
+		try {
+			const result = await this.request({
+				method: "initialize",
+				params: {
+					protocolVersion: LATEST_PROTOCOL_VERSION,
+					capabilities: this._capabilities,
+					clientInfo: this._clientInfo
+				}
+			}, InitializeResultSchema, options);
+			if (result === void 0) throw new Error(`Server sent invalid initialize result: ${result}`);
+			if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
+			this._serverCapabilities = result.capabilities;
+			this._serverVersion = result.serverInfo;
+			if (transport.setProtocolVersion) transport.setProtocolVersion(result.protocolVersion);
+			this._instructions = result.instructions;
+			await this.notification({ method: "notifications/initialized" });
+			if (this._pendingListChangedConfig) {
+				this._setupListChangedHandlers(this._pendingListChangedConfig);
+				this._pendingListChangedConfig = void 0;
+			}
+		} catch (error) {
+			this.close();
+			throw error;
+		}
+	}
+	/**
+	* After initialization has completed, this will be populated with the server's reported capabilities.
+	*/
+	getServerCapabilities() {
+		return this._serverCapabilities;
+	}
+	/**
+	* After initialization has completed, this will be populated with information about the server's name and version.
+	*/
+	getServerVersion() {
+		return this._serverVersion;
+	}
+	/**
+	* After initialization has completed, this may be populated with information about the server's instructions.
+	*/
+	getInstructions() {
+		return this._instructions;
+	}
+	assertCapabilityForMethod(method) {
+		switch (method) {
+			case "logging/setLevel":
+				if (!this._serverCapabilities?.logging) throw new Error(`Server does not support logging (required for ${method})`);
+				break;
+			case "prompts/get":
+			case "prompts/list":
+				if (!this._serverCapabilities?.prompts) throw new Error(`Server does not support prompts (required for ${method})`);
+				break;
+			case "resources/list":
+			case "resources/templates/list":
+			case "resources/read":
+			case "resources/subscribe":
+			case "resources/unsubscribe":
+				if (!this._serverCapabilities?.resources) throw new Error(`Server does not support resources (required for ${method})`);
+				if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) throw new Error(`Server does not support resource subscriptions (required for ${method})`);
+				break;
+			case "tools/call":
+			case "tools/list":
+				if (!this._serverCapabilities?.tools) throw new Error(`Server does not support tools (required for ${method})`);
+				break;
+			case "completion/complete":
+				if (!this._serverCapabilities?.completions) throw new Error(`Server does not support completions (required for ${method})`);
+				break;
+			case "initialize": break;
+			case "ping": break;
+		}
+	}
+	assertNotificationCapability(method) {
+		switch (method) {
+			case "notifications/roots/list_changed":
+				if (!this._capabilities.roots?.listChanged) throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
+				break;
+			case "notifications/initialized": break;
+			case "notifications/cancelled": break;
+			case "notifications/progress": break;
+		}
+	}
+	assertRequestHandlerCapability(method) {
+		if (!this._capabilities) return;
+		switch (method) {
+			case "sampling/createMessage":
+				if (!this._capabilities.sampling) throw new Error(`Client does not support sampling capability (required for ${method})`);
+				break;
+			case "elicitation/create":
+				if (!this._capabilities.elicitation) throw new Error(`Client does not support elicitation capability (required for ${method})`);
+				break;
+			case "roots/list":
+				if (!this._capabilities.roots) throw new Error(`Client does not support roots capability (required for ${method})`);
+				break;
+			case "tasks/get":
+			case "tasks/list":
+			case "tasks/result":
+			case "tasks/cancel":
+				if (!this._capabilities.tasks) throw new Error(`Client does not support tasks capability (required for ${method})`);
+				break;
+			case "ping": break;
+		}
+	}
+	assertTaskCapability(method) {
+		assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, "Server");
+	}
+	assertTaskHandlerCapability(method) {
+		if (!this._capabilities) return;
+		assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, "Client");
+	}
+	async ping(options) {
+		return this.request({ method: "ping" }, EmptyResultSchema, options);
+	}
+	async complete(params, options) {
+		return this.request({
+			method: "completion/complete",
+			params
+		}, CompleteResultSchema, options);
+	}
+	async setLoggingLevel(level, options) {
+		return this.request({
+			method: "logging/setLevel",
+			params: { level }
+		}, EmptyResultSchema, options);
+	}
+	async getPrompt(params, options) {
+		return this.request({
+			method: "prompts/get",
+			params
+		}, GetPromptResultSchema, options);
+	}
+	async listPrompts(params, options) {
+		return this.request({
+			method: "prompts/list",
+			params
+		}, ListPromptsResultSchema, options);
+	}
+	async listResources(params, options) {
+		return this.request({
+			method: "resources/list",
+			params
+		}, ListResourcesResultSchema, options);
+	}
+	async listResourceTemplates(params, options) {
+		return this.request({
+			method: "resources/templates/list",
+			params
+		}, ListResourceTemplatesResultSchema, options);
+	}
+	async readResource(params, options) {
+		return this.request({
+			method: "resources/read",
+			params
+		}, ReadResourceResultSchema, options);
+	}
+	async subscribeResource(params, options) {
+		return this.request({
+			method: "resources/subscribe",
+			params
+		}, EmptyResultSchema, options);
+	}
+	async unsubscribeResource(params, options) {
+		return this.request({
+			method: "resources/unsubscribe",
+			params
+		}, EmptyResultSchema, options);
+	}
+	/**
+	* Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema.
+	*
+	* For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead.
+	*/
+	async callTool(params, resultSchema = CallToolResultSchema, options) {
+		if (this.isToolTaskRequired(params.name)) throw new McpError(ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
+		const result = await this.request({
+			method: "tools/call",
+			params
+		}, resultSchema, options);
+		const validator = this.getToolOutputValidator(params.name);
+		if (validator) {
+			if (!result.structuredContent && !result.isError) throw new McpError(ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
+			if (result.structuredContent) try {
+				const validationResult = validator(result.structuredContent);
+				if (!validationResult.valid) throw new McpError(ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
+			} catch (error) {
+				if (error instanceof McpError) throw error;
+				throw new McpError(ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		return result;
+	}
+	isToolTask(toolName) {
+		if (!this._serverCapabilities?.tasks?.requests?.tools?.call) return false;
+		return this._cachedKnownTaskTools.has(toolName);
+	}
+	/**
+	* Check if a tool requires task-based execution.
+	* Unlike isToolTask which includes 'optional' tools, this only checks for 'required'.
+	*/
+	isToolTaskRequired(toolName) {
+		return this._cachedRequiredTaskTools.has(toolName);
+	}
+	/**
+	* Cache validators for tool output schemas.
+	* Called after listTools() to pre-compile validators for better performance.
+	*/
+	cacheToolMetadata(tools) {
+		this._cachedToolOutputValidators.clear();
+		this._cachedKnownTaskTools.clear();
+		this._cachedRequiredTaskTools.clear();
+		for (const tool of tools) {
+			if (tool.outputSchema) {
+				const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
+				this._cachedToolOutputValidators.set(tool.name, toolValidator);
+			}
+			const taskSupport = tool.execution?.taskSupport;
+			if (taskSupport === "required" || taskSupport === "optional") this._cachedKnownTaskTools.add(tool.name);
+			if (taskSupport === "required") this._cachedRequiredTaskTools.add(tool.name);
+		}
+	}
+	/**
+	* Get cached validator for a tool
+	*/
+	getToolOutputValidator(toolName) {
+		return this._cachedToolOutputValidators.get(toolName);
+	}
+	async listTools(params, options) {
+		const result = await this.request({
+			method: "tools/list",
+			params
+		}, ListToolsResultSchema, options);
+		this.cacheToolMetadata(result.tools);
+		return result;
+	}
+	/**
+	* Set up a single list changed handler.
+	* @internal
+	*/
+	_setupListChangedHandler(listType, notificationSchema, options, fetcher) {
+		const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
+		if (!parseResult.success) throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
+		if (typeof options.onChanged !== "function") throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
+		const { autoRefresh, debounceMs } = parseResult.data;
+		const { onChanged } = options;
+		const refresh = async () => {
+			if (!autoRefresh) {
+				onChanged(null, null);
+				return;
+			}
+			try {
+				onChanged(null, await fetcher());
+			} catch (e) {
+				onChanged(e instanceof Error ? e : new Error(String(e)), null);
+			}
+		};
+		const handler = () => {
+			if (debounceMs) {
+				const existingTimer = this._listChangedDebounceTimers.get(listType);
+				if (existingTimer) clearTimeout(existingTimer);
+				const timer = setTimeout(refresh, debounceMs);
+				this._listChangedDebounceTimers.set(listType, timer);
+			} else refresh();
+		};
+		this.setNotificationHandler(notificationSchema, handler);
+	}
+	async sendRootsListChanged() {
+		return this.notification({ method: "notifications/roots/list_changed" });
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js
+/**
+* Normalizes HeadersInit to a plain Record<string, string> for manipulation.
+* Handles Headers objects, arrays of tuples, and plain objects.
+*/
+function normalizeHeaders(headers) {
+	if (!headers) return {};
+	if (headers instanceof Headers) return Object.fromEntries(headers.entries());
+	if (Array.isArray(headers)) return Object.fromEntries(headers);
+	return { ...headers };
+}
+/**
+* Creates a fetch function that includes base RequestInit options.
+* This ensures requests inherit settings like credentials, mode, headers, etc. from the base init.
+*
+* @param baseFetch - The base fetch function to wrap (defaults to global fetch)
+* @param baseInit - The base RequestInit to merge with each request
+* @returns A wrapped fetch function that merges base options with call-specific options
+*/
+function createFetchWithInit(baseFetch = fetch, baseInit) {
+	if (!baseInit) return baseFetch;
+	return async (url, init) => {
+		return baseFetch(url, {
+			...baseInit,
+			...init,
+			headers: init?.headers ? {
+				...normalizeHeaders(baseInit.headers),
+				...normalizeHeaders(init.headers)
+			} : baseInit.headers
+		});
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
+/**
+* Utilities for handling OAuth resource URIs.
+*/
+/**
+* Converts a server URL to a resource URL by removing the fragment.
+* RFC 8707 section 2 states that resource URIs "MUST NOT include a fragment component".
+* Keeps everything else unchanged (scheme, domain, port, path, query).
+*/
+function resourceUrlFromServerUrl(url) {
+	const resourceURL = typeof url === "string" ? new URL(url) : new URL(url.href);
+	resourceURL.hash = "";
+	return resourceURL;
+}
+/**
+* Checks if a requested resource URL matches a configured resource URL.
+* A requested resource matches if it has the same scheme, domain, port,
+* and its path starts with the configured resource's path.
+*
+* @param requestedResource The resource URL being requested
+* @param configuredResource The resource URL that has been configured
+* @returns true if the requested resource matches the configured resource, false otherwise
+*/
+function checkResourceAllowed({ requestedResource, configuredResource }) {
+	const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href);
+	const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href);
+	if (requested.origin !== configured.origin) return false;
+	if (requested.pathname.length < configured.pathname.length) return false;
+	const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/";
+	const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/";
+	return requestedPath.startsWith(configuredPath);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
+var UnauthorizedError = class extends Error {
+	constructor(message) {
+		super(message ?? "Unauthorized");
+	}
+};
+function isClientAuthMethod(method) {
+	return [
+		"client_secret_basic",
+		"client_secret_post",
+		"none"
+	].includes(method);
+}
+const AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
+const AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
+/**
+* Determines the best client authentication method to use based on server support and client configuration.
+*
+* Priority order (highest to lowest):
+* 1. client_secret_basic (if client secret is available)
+* 2. client_secret_post (if client secret is available)
+* 3. none (for public clients)
+*
+* @param clientInformation - OAuth client information containing credentials
+* @param supportedMethods - Authentication methods supported by the authorization server
+* @returns The selected authentication method
+*/
+function selectClientAuthMethod(clientInformation, supportedMethods) {
+	const hasClientSecret = clientInformation.client_secret !== void 0;
+	if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) return clientInformation.token_endpoint_auth_method;
+	if (supportedMethods.length === 0) return hasClientSecret ? "client_secret_basic" : "none";
+	if (hasClientSecret && supportedMethods.includes("client_secret_basic")) return "client_secret_basic";
+	if (hasClientSecret && supportedMethods.includes("client_secret_post")) return "client_secret_post";
+	if (supportedMethods.includes("none")) return "none";
+	return hasClientSecret ? "client_secret_post" : "none";
+}
+/**
+* Applies client authentication to the request based on the specified method.
+*
+* Implements OAuth 2.1 client authentication methods:
+* - client_secret_basic: HTTP Basic authentication (RFC 6749 Section 2.3.1)
+* - client_secret_post: Credentials in request body (RFC 6749 Section 2.3.1)
+* - none: Public client authentication (RFC 6749 Section 2.1)
+*
+* @param method - The authentication method to use
+* @param clientInformation - OAuth client information containing credentials
+* @param headers - HTTP headers object to modify
+* @param params - URL search parameters to modify
+* @throws {Error} When required credentials are missing
+*/
+function applyClientAuthentication(method, clientInformation, headers, params) {
+	const { client_id, client_secret } = clientInformation;
+	switch (method) {
+		case "client_secret_basic":
+			applyBasicAuth(client_id, client_secret, headers);
+			return;
+		case "client_secret_post":
+			applyPostAuth(client_id, client_secret, params);
+			return;
+		case "none":
+			applyPublicAuth(client_id, params);
+			return;
+		default: throw new Error(`Unsupported client authentication method: ${method}`);
+	}
+}
+/**
+* Applies HTTP Basic authentication (RFC 6749 Section 2.3.1)
+*/
+function applyBasicAuth(clientId, clientSecret, headers) {
+	if (!clientSecret) throw new Error("client_secret_basic authentication requires a client_secret");
+	const credentials = btoa(`${clientId}:${clientSecret}`);
+	headers.set("Authorization", `Basic ${credentials}`);
+}
+/**
+* Applies POST body authentication (RFC 6749 Section 2.3.1)
+*/
+function applyPostAuth(clientId, clientSecret, params) {
+	params.set("client_id", clientId);
+	if (clientSecret) params.set("client_secret", clientSecret);
+}
+/**
+* Applies public client authentication (RFC 6749 Section 2.1)
+*/
+function applyPublicAuth(clientId, params) {
+	params.set("client_id", clientId);
+}
+/**
+* Parses an OAuth error response from a string or Response object.
+*
+* If the input is a standard OAuth2.0 error response, it will be parsed according to the spec
+* and an instance of the appropriate OAuthError subclass will be returned.
+* If parsing fails, it falls back to a generic ServerError that includes
+* the response status (if available) and original content.
+*
+* @param input - A Response object or string containing the error response
+* @returns A Promise that resolves to an OAuthError instance
+*/
+async function parseErrorResponse(input) {
+	const statusCode = input instanceof Response ? input.status : void 0;
+	const body = input instanceof Response ? await input.text() : input;
+	try {
+		const { error, error_description, error_uri } = OAuthErrorResponseSchema.parse(JSON.parse(body));
+		return new (OAUTH_ERRORS[error] || ServerError)(error_description || "", error_uri);
+	} catch (error) {
+		return new ServerError(`${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error}. Raw body: ${body}`);
+	}
+}
+/**
+* Orchestrates the full auth flow with a server.
+*
+* This can be used as a single entry point for all authorization functionality,
+* instead of linking together the other lower-level functions in this module.
+*/
+async function auth(provider, options) {
+	try {
+		return await authInternal(provider, options);
+	} catch (error) {
+		if (error instanceof InvalidClientError || error instanceof UnauthorizedClientError) {
+			await provider.invalidateCredentials?.("all");
+			return await authInternal(provider, options);
+		} else if (error instanceof InvalidGrantError) {
+			await provider.invalidateCredentials?.("tokens");
+			return await authInternal(provider, options);
+		}
+		throw error;
+	}
+}
+async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+	const cachedState = await provider.discoveryState?.();
+	let resourceMetadata;
+	let authorizationServerUrl;
+	let metadata;
+	let effectiveResourceMetadataUrl = resourceMetadataUrl;
+	if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
+	if (cachedState?.authorizationServerUrl) {
+		authorizationServerUrl = cachedState.authorizationServerUrl;
+		resourceMetadata = cachedState.resourceMetadata;
+		metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
+		if (!resourceMetadata) try {
+			resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
+		} catch {}
+		if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) await provider.saveDiscoveryState?.({
+			authorizationServerUrl: String(authorizationServerUrl),
+			resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+			resourceMetadata,
+			authorizationServerMetadata: metadata
+		});
+	} else {
+		const serverInfo = await discoverOAuthServerInfo(serverUrl, {
+			resourceMetadataUrl: effectiveResourceMetadataUrl,
+			fetchFn
+		});
+		authorizationServerUrl = serverInfo.authorizationServerUrl;
+		metadata = serverInfo.authorizationServerMetadata;
+		resourceMetadata = serverInfo.resourceMetadata;
+		await provider.saveDiscoveryState?.({
+			authorizationServerUrl: String(authorizationServerUrl),
+			resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+			resourceMetadata,
+			authorizationServerMetadata: metadata
+		});
+	}
+	const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+	const resolvedScope = scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope;
+	let clientInformation = await Promise.resolve(provider.clientInformation());
+	if (!clientInformation) {
+		if (authorizationCode !== void 0) throw new Error("Existing OAuth client information is required when exchanging an authorization code");
+		const supportsUrlBasedClientId = metadata?.client_id_metadata_document_supported === true;
+		const clientMetadataUrl = provider.clientMetadataUrl;
+		if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
+		if (supportsUrlBasedClientId && clientMetadataUrl) {
+			clientInformation = { client_id: clientMetadataUrl };
+			await provider.saveClientInformation?.(clientInformation);
+		} else {
+			if (!provider.saveClientInformation) throw new Error("OAuth client information must be saveable for dynamic registration");
+			const fullInformation = await registerClient(authorizationServerUrl, {
+				metadata,
+				clientMetadata: provider.clientMetadata,
+				scope: resolvedScope,
+				fetchFn
+			});
+			await provider.saveClientInformation(fullInformation);
+			clientInformation = fullInformation;
+		}
+	}
+	const nonInteractiveFlow = !provider.redirectUrl;
+	if (authorizationCode !== void 0 || nonInteractiveFlow) {
+		const tokens = await fetchToken(provider, authorizationServerUrl, {
+			metadata,
+			resource,
+			authorizationCode,
+			fetchFn
+		});
+		await provider.saveTokens(tokens);
+		return "AUTHORIZED";
+	}
+	const tokens = await provider.tokens();
+	if (tokens?.refresh_token) try {
+		const newTokens = await refreshAuthorization(authorizationServerUrl, {
+			metadata,
+			clientInformation,
+			refreshToken: tokens.refresh_token,
+			resource,
+			addClientAuthentication: provider.addClientAuthentication,
+			fetchFn
+		});
+		await provider.saveTokens(newTokens);
+		return "AUTHORIZED";
+	} catch (error) {
+		if (!(error instanceof OAuthError) || error instanceof ServerError) {} else throw error;
+	}
+	const state = provider.state ? await provider.state() : void 0;
+	const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
+		metadata,
+		clientInformation,
+		state,
+		redirectUrl: provider.redirectUrl,
+		scope: resolvedScope,
+		resource
+	});
+	await provider.saveCodeVerifier(codeVerifier);
+	await provider.redirectToAuthorization(authorizationUrl);
+	return "REDIRECT";
+}
+/**
+* SEP-991: URL-based Client IDs
+* Validate that the client_id is a valid URL with https scheme
+*/
+function isHttpsUrl(value) {
+	if (!value) return false;
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.pathname !== "/";
+	} catch {
+		return false;
+	}
+}
+async function selectResourceURL(serverUrl, provider, resourceMetadata) {
+	const defaultResource = resourceUrlFromServerUrl(serverUrl);
+	if (provider.validateResourceURL) return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
+	if (!resourceMetadata) return;
+	if (!checkResourceAllowed({
+		requestedResource: defaultResource,
+		configuredResource: resourceMetadata.resource
+	})) throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
+	return new URL(resourceMetadata.resource);
+}
+/**
+* Extract resource_metadata, scope, and error from WWW-Authenticate header.
+*/
+function extractWWWAuthenticateParams(res) {
+	const authenticateHeader = res.headers.get("WWW-Authenticate");
+	if (!authenticateHeader) return {};
+	const [type, scheme] = authenticateHeader.split(" ");
+	if (type.toLowerCase() !== "bearer" || !scheme) return {};
+	const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || void 0;
+	let resourceMetadataUrl;
+	if (resourceMetadataMatch) try {
+		resourceMetadataUrl = new URL(resourceMetadataMatch);
+	} catch {}
+	const scope = extractFieldFromWwwAuth(res, "scope") || void 0;
+	const error = extractFieldFromWwwAuth(res, "error") || void 0;
+	return {
+		resourceMetadataUrl,
+		scope,
+		error
+	};
+}
+/**
+* Extracts a specific field's value from the WWW-Authenticate header string.
+*
+* @param response The HTTP response object containing the headers.
+* @param fieldName The name of the field to extract (e.g., "realm", "nonce").
+* @returns The field value
+*/
+function extractFieldFromWwwAuth(response, fieldName) {
+	const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+	if (!wwwAuthHeader) return null;
+	const pattern = new RegExp(`${fieldName}=(?:"([^"]+)"|([^\\s,]+))`);
+	const match = wwwAuthHeader.match(pattern);
+	if (match) return match[1] || match[2];
+	return null;
+}
+/**
+* Looks up RFC 9728 OAuth 2.0 Protected Resource Metadata.
+*
+* If the server returns a 404 for the well-known endpoint, this function will
+* return `undefined`. Any other errors will be thrown as exceptions.
+*/
+async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
+	const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
+		protocolVersion: opts?.protocolVersion,
+		metadataUrl: opts?.resourceMetadataUrl
+	});
+	if (!response || response.status === 404) {
+		await response?.body?.cancel();
+		throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
+	}
+	if (!response.ok) {
+		await response.body?.cancel();
+		throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
+	}
+	return OAuthProtectedResourceMetadataSchema.parse(await response.json());
+}
+/**
+* Helper function to handle fetch with CORS retry logic
+*/
+async function fetchWithCorsRetry(url, headers, fetchFn = fetch) {
+	try {
+		return await fetchFn(url, { headers });
+	} catch (error) {
+		if (error instanceof TypeError) if (headers) return fetchWithCorsRetry(url, void 0, fetchFn);
+		else return;
+		throw error;
+	}
+}
+/**
+* Constructs the well-known path for auth-related metadata discovery
+*/
+function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
+	if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+	return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
+}
+/**
+* Tries to discover OAuth metadata at a specific URL
+*/
+async function tryMetadataDiscovery(url, protocolVersion, fetchFn = fetch) {
+	return await fetchWithCorsRetry(url, { "MCP-Protocol-Version": protocolVersion }, fetchFn);
+}
+/**
+* Determines if fallback to root discovery should be attempted
+*/
+function shouldAttemptFallback(response, pathname) {
+	return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
+}
+/**
+* Generic function for discovering OAuth metadata with fallback support
+*/
+async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
+	const issuer = new URL(serverUrl);
+	const protocolVersion = opts?.protocolVersion ?? "2025-11-25";
+	let url;
+	if (opts?.metadataUrl) url = new URL(opts.metadataUrl);
+	else {
+		const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
+		url = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
+		url.search = issuer.search;
+	}
+	let response = await tryMetadataDiscovery(url, protocolVersion, fetchFn);
+	if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) response = await tryMetadataDiscovery(new URL(`/.well-known/${wellKnownType}`, issuer), protocolVersion, fetchFn);
+	return response;
+}
+/**
+* Builds a list of discovery URLs to try for authorization server metadata.
+* URLs are returned in priority order:
+* 1. OAuth metadata at the given URL
+* 2. OIDC metadata endpoints at the given URL
+*/
+function buildDiscoveryUrls(authorizationServerUrl) {
+	const url = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
+	const hasPath = url.pathname !== "/";
+	const urlsToTry = [];
+	if (!hasPath) {
+		urlsToTry.push({
+			url: new URL("/.well-known/oauth-authorization-server", url.origin),
+			type: "oauth"
+		});
+		urlsToTry.push({
+			url: new URL(`/.well-known/openid-configuration`, url.origin),
+			type: "oidc"
+		});
+		return urlsToTry;
+	}
+	let pathname = url.pathname;
+	if (pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+	urlsToTry.push({
+		url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url.origin),
+		type: "oauth"
+	});
+	urlsToTry.push({
+		url: new URL(`/.well-known/openid-configuration${pathname}`, url.origin),
+		type: "oidc"
+	});
+	urlsToTry.push({
+		url: new URL(`${pathname}/.well-known/openid-configuration`, url.origin),
+		type: "oidc"
+	});
+	return urlsToTry;
+}
+/**
+* Discovers authorization server metadata with support for RFC 8414 OAuth 2.0 Authorization Server Metadata
+* and OpenID Connect Discovery 1.0 specifications.
+*
+* This function implements a fallback strategy for authorization server discovery:
+* 1. Attempts RFC 8414 OAuth metadata discovery first
+* 2. If OAuth discovery fails, falls back to OpenID Connect Discovery
+*
+* @param authorizationServerUrl - The authorization server URL obtained from the MCP Server's
+*                                 protected resource metadata, or the MCP server's URL if the
+*                                 metadata was not found.
+* @param options - Configuration options
+* @param options.fetchFn - Optional fetch function for making HTTP requests, defaults to global fetch
+* @param options.protocolVersion - MCP protocol version to use, defaults to LATEST_PROTOCOL_VERSION
+* @returns Promise resolving to authorization server metadata, or undefined if discovery fails
+*/
+async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) {
+	const headers = {
+		"MCP-Protocol-Version": protocolVersion,
+		Accept: "application/json"
+	};
+	const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
+	for (const { url: endpointUrl, type } of urlsToTry) {
+		const response = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
+		if (!response)
+ /**
+		* CORS error occurred - don't throw as the endpoint may not allow CORS,
+		* continue trying other possible endpoints
+		*/
+		continue;
+		if (!response.ok) {
+			await response.body?.cancel();
+			if (response.status >= 400 && response.status < 500) continue;
+			throw new Error(`HTTP ${response.status} trying to load ${type === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
+		}
+		if (type === "oauth") return OAuthMetadataSchema.parse(await response.json());
+		else return OpenIdProviderDiscoveryMetadataSchema.parse(await response.json());
+	}
+}
+/**
+* Discovers the authorization server for an MCP server following
+* {@link https://datatracker.ietf.org/doc/html/rfc9728 | RFC 9728} (OAuth 2.0 Protected
+* Resource Metadata), with fallback to treating the server URL as the
+* authorization server.
+*
+* This function combines two discovery steps into one call:
+* 1. Probes `/.well-known/oauth-protected-resource` on the MCP server to find the
+*    authorization server URL (RFC 9728).
+* 2. Fetches authorization server metadata from that URL (RFC 8414 / OpenID Connect Discovery).
+*
+* Use this when you need the authorization server metadata for operations outside the
+* {@linkcode auth} orchestrator, such as token refresh or token revocation.
+*
+* @param serverUrl - The MCP resource server URL
+* @param opts - Optional configuration
+* @param opts.resourceMetadataUrl - Override URL for the protected resource metadata endpoint
+* @param opts.fetchFn - Custom fetch function for HTTP requests
+* @returns Authorization server URL, metadata, and resource metadata (if available)
+*/
+async function discoverOAuthServerInfo(serverUrl, opts) {
+	let resourceMetadata;
+	let authorizationServerUrl;
+	try {
+		resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
+		if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) authorizationServerUrl = resourceMetadata.authorization_servers[0];
+	} catch {}
+	if (!authorizationServerUrl) authorizationServerUrl = String(new URL("/", serverUrl));
+	const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts?.fetchFn });
+	return {
+		authorizationServerUrl,
+		authorizationServerMetadata,
+		resourceMetadata
+	};
+}
+/**
+* Begins the authorization flow with the given server, by generating a PKCE challenge and constructing the authorization URL.
+*/
+async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) {
+	let authorizationUrl;
+	if (metadata) {
+		authorizationUrl = new URL(metadata.authorization_endpoint);
+		if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
+		if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
+	} else authorizationUrl = new URL("/authorize", authorizationServerUrl);
+	const challenge = await pkceChallenge();
+	const codeVerifier = challenge.code_verifier;
+	const codeChallenge = challenge.code_challenge;
+	authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
+	authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
+	authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+	authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
+	authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
+	if (state) authorizationUrl.searchParams.set("state", state);
+	if (scope) authorizationUrl.searchParams.set("scope", scope);
+	if (scope?.includes("offline_access")) authorizationUrl.searchParams.append("prompt", "consent");
+	if (resource) authorizationUrl.searchParams.set("resource", resource.href);
+	return {
+		authorizationUrl,
+		codeVerifier
+	};
+}
+/**
+* Prepares token request parameters for an authorization code exchange.
+*
+* This is the default implementation used by fetchToken when the provider
+* doesn't implement prepareTokenRequest.
+*
+* @param authorizationCode - The authorization code received from the authorization endpoint
+* @param codeVerifier - The PKCE code verifier
+* @param redirectUri - The redirect URI used in the authorization request
+* @returns URLSearchParams for the authorization_code grant
+*/
+function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
+	return new URLSearchParams({
+		grant_type: "authorization_code",
+		code: authorizationCode,
+		code_verifier: codeVerifier,
+		redirect_uri: String(redirectUri)
+	});
+}
+/**
+* Internal helper to execute a token request with the given parameters.
+* Used by exchangeAuthorization, refreshAuthorization, and fetchToken.
+*/
+async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams, clientInformation, addClientAuthentication, resource, fetchFn }) {
+	const tokenUrl = metadata?.token_endpoint ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl);
+	const headers = new Headers({
+		"Content-Type": "application/x-www-form-urlencoded",
+		Accept: "application/json"
+	});
+	if (resource) tokenRequestParams.set("resource", resource.href);
+	if (addClientAuthentication) await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata);
+	else if (clientInformation) applyClientAuthentication(selectClientAuthMethod(clientInformation, metadata?.token_endpoint_auth_methods_supported ?? []), clientInformation, headers, tokenRequestParams);
+	const response = await (fetchFn ?? fetch)(tokenUrl, {
+		method: "POST",
+		headers,
+		body: tokenRequestParams
+	});
+	if (!response.ok) throw await parseErrorResponse(response);
+	return OAuthTokensSchema.parse(await response.json());
+}
+/**
+* Exchange a refresh token for an updated access token.
+*
+* Supports multiple client authentication methods as specified in OAuth 2.1:
+* - Automatically selects the best authentication method based on server support
+* - Preserves the original refresh token if a new one is not returned
+*
+* @param authorizationServerUrl - The authorization server's base URL
+* @param options - Configuration object containing client info, refresh token, etc.
+* @returns Promise resolving to OAuth tokens (preserves original refresh_token if not replaced)
+* @throws {Error} When token refresh fails or authentication is invalid
+*/
+async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
+	return {
+		refresh_token: refreshToken,
+		...await executeTokenRequest(authorizationServerUrl, {
+			metadata,
+			tokenRequestParams: new URLSearchParams({
+				grant_type: "refresh_token",
+				refresh_token: refreshToken
+			}),
+			clientInformation,
+			addClientAuthentication,
+			resource,
+			fetchFn
+		})
+	};
+}
+/**
+* Unified token fetching that works with any grant type via provider.prepareTokenRequest().
+*
+* This function provides a single entry point for obtaining tokens regardless of the
+* OAuth grant type. The provider's prepareTokenRequest() method determines which grant
+* to use and supplies the grant-specific parameters.
+*
+* @param provider - OAuth client provider that implements prepareTokenRequest()
+* @param authorizationServerUrl - The authorization server's base URL
+* @param options - Configuration for the token request
+* @returns Promise resolving to OAuth tokens
+* @throws {Error} When provider doesn't implement prepareTokenRequest or token fetch fails
+*
+* @example
+* // Provider for client_credentials:
+* class MyProvider implements OAuthClientProvider {
+*   prepareTokenRequest(scope) {
+*     const params = new URLSearchParams({ grant_type: 'client_credentials' });
+*     if (scope) params.set('scope', scope);
+*     return params;
+*   }
+*   // ... other methods
+* }
+*
+* const tokens = await fetchToken(provider, authServerUrl, { metadata });
+*/
+async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, fetchFn } = {}) {
+	const scope = provider.clientMetadata.scope;
+	let tokenRequestParams;
+	if (provider.prepareTokenRequest) tokenRequestParams = await provider.prepareTokenRequest(scope);
+	if (!tokenRequestParams) {
+		if (!authorizationCode) throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
+		if (!provider.redirectUrl) throw new Error("redirectUrl is required for authorization_code flow");
+		tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, await provider.codeVerifier(), provider.redirectUrl);
+	}
+	const clientInformation = await provider.clientInformation();
+	return executeTokenRequest(authorizationServerUrl, {
+		metadata,
+		tokenRequestParams,
+		clientInformation: clientInformation ?? void 0,
+		addClientAuthentication: provider.addClientAuthentication,
+		resource,
+		fetchFn
+	});
+}
+/**
+* Performs OAuth 2.0 Dynamic Client Registration according to RFC 7591.
+*
+* If `scope` is provided, it overrides `clientMetadata.scope` in the registration
+* request body. This allows callers to apply the Scope Selection Strategy (SEP-835)
+* consistently across both DCR and the subsequent authorization request.
+*/
+async function registerClient(authorizationServerUrl, { metadata, clientMetadata, scope, fetchFn }) {
+	let registrationUrl;
+	if (metadata) {
+		if (!metadata.registration_endpoint) throw new Error("Incompatible auth server: does not support dynamic client registration");
+		registrationUrl = new URL(metadata.registration_endpoint);
+	} else registrationUrl = new URL("/register", authorizationServerUrl);
+	const response = await (fetchFn ?? fetch)(registrationUrl, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			...clientMetadata,
+			...scope !== void 0 ? { scope } : {}
+		})
+	});
+	if (!response.ok) throw await parseErrorResponse(response);
+	return OAuthClientInformationFullSchema.parse(await response.json());
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/eventsource-parser@3.1.0/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+	constructor(message, options) {
+		super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+	}
+};
+const LF = 10, CR = 13, SPACE = 32;
+function noop$2(_arg) {}
+function createParser(config) {
+	if (typeof config == "function") throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
+	const { onEvent = noop$2, onError = noop$2, onRetry = noop$2, onComment, maxBufferSize } = config, pendingFragments = [];
+	let pendingFragmentsLength = 0, isFirstChunk = !0, id, data = "", dataLines = 0, eventType, terminated = !1;
+	function feed(chunk) {
+		if (terminated) throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
+		if (isFirstChunk && (isFirstChunk = !1, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+			const trailing2 = processLines(chunk);
+			trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+			return;
+		}
+		if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+			pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+			return;
+		}
+		pendingFragments.push(chunk);
+		const input = pendingFragments.join("");
+		pendingFragments.length = 0, pendingFragmentsLength = 0;
+		const trailing = processLines(input);
+		trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+	}
+	function checkBufferSize() {
+		maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = !0, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, { type: "max-buffer-size-exceeded" }))));
+	}
+	function processLines(chunk) {
+		let searchIndex = 0;
+		if (chunk.indexOf("\r") === -1) {
+			let lfIndex = chunk.indexOf(`
+`, searchIndex);
+			for (; lfIndex !== -1;) {
+				if (searchIndex === lfIndex) {
+					dataLines > 0 && onEvent({
+						id,
+						event: eventType,
+						data
+					}), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+					continue;
+				}
+				const firstCharCode = chunk.charCodeAt(searchIndex);
+				if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+					const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+					if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+						onEvent({
+							id,
+							event: eventType,
+							data: value
+						}), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+						continue;
+					}
+					data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+				} else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6, lfIndex) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+				searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+			}
+			return chunk.slice(searchIndex);
+		}
+		for (; searchIndex < chunk.length;) {
+			const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+			let lineEnd = -1;
+			if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) break;
+			parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+		}
+		return chunk.slice(searchIndex);
+	}
+	function parseLine(chunk, start, end) {
+		if (start === end) {
+			dispatchEvent();
+			return;
+		}
+		const firstCharCode = chunk.charCodeAt(start);
+		if (isDataPrefix(chunk, start, firstCharCode)) {
+			const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+			data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+			return;
+		}
+		if (isEventPrefix(chunk, start, firstCharCode)) {
+			eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+			return;
+		}
+		if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+			const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+			id = value2.includes("\0") ? void 0 : value2;
+			return;
+		}
+		if (firstCharCode === 58) {
+			if (onComment) onComment(chunk.slice(start, end).slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+			return;
+		}
+		const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+		if (fieldSeparatorIndex === -1) {
+			processField(line, "", line);
+			return;
+		}
+		const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1;
+		processField(field, line.slice(fieldSeparatorIndex + offset), line);
+	}
+	function processField(field, value, line) {
+		switch (field) {
+			case "event":
+				eventType = value || void 0;
+				break;
+			case "data":
+				data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+				break;
+			case "id":
+				id = value.includes("\0") ? void 0 : value;
+				break;
+			case "retry":
+				/^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
+					type: "invalid-retry",
+					value,
+					line
+				}));
+				break;
+			default:
+				onError(new ParseError(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, {
+					type: "unknown-field",
+					field,
+					value,
+					line
+				}));
+				break;
+		}
+	}
+	function dispatchEvent() {
+		dataLines > 0 && onEvent({
+			id,
+			event: eventType,
+			data
+		}), id = void 0, data = "", dataLines = 0, eventType = void 0;
+	}
+	function reset(options = {}) {
+		if (options.consume && pendingFragments.length > 0) {
+			const incompleteLine = pendingFragments.join("");
+			parseLine(incompleteLine, 0, incompleteLine.length);
+		}
+		isFirstChunk = !0, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = !1;
+	}
+	return {
+		feed,
+		reset
+	};
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+	return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+	return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/eventsource-parser@3.1.0/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+	constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
+		let parser;
+		super({
+			start(controller) {
+				parser = createParser({
+					onEvent: (event) => {
+						controller.enqueue(event);
+					},
+					onError(error) {
+						typeof onError == "function" && onError(error), (onError === "terminate" || error.type === "max-buffer-size-exceeded") && controller.error(error);
+					},
+					onRetry,
+					onComment,
+					maxBufferSize
+				});
+			},
+			transform(chunk) {
+				parser.feed(chunk);
+			}
+		});
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/client/streamableHttp.js
+const DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS = {
+	initialReconnectionDelay: 1e3,
+	maxReconnectionDelay: 3e4,
+	reconnectionDelayGrowFactor: 1.5,
+	maxRetries: 2
+};
+var StreamableHTTPError = class extends Error {
+	constructor(code, message) {
+		super(`Streamable HTTP error: ${message}`);
+		this.code = code;
+	}
+};
+/**
+* Client transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.
+* It will connect to a server using HTTP POST for sending messages and HTTP GET with Server-Sent Events
+* for receiving messages.
+*/
+var StreamableHTTPClientTransport = class {
+	constructor(url, opts) {
+		this._hasCompletedAuthFlow = false;
+		this._url = url;
+		this._resourceMetadataUrl = void 0;
+		this._scope = void 0;
+		this._requestInit = opts?.requestInit;
+		this._authProvider = opts?.authProvider;
+		this._fetch = opts?.fetch;
+		this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+		this._sessionId = opts?.sessionId;
+		this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
+	}
+	async _authThenStart() {
+		if (!this._authProvider) throw new UnauthorizedError("No auth provider");
+		let result;
+		try {
+			result = await auth(this._authProvider, {
+				serverUrl: this._url,
+				resourceMetadataUrl: this._resourceMetadataUrl,
+				scope: this._scope,
+				fetchFn: this._fetchWithInit
+			});
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+		if (result !== "AUTHORIZED") throw new UnauthorizedError();
+		return await this._startOrAuthSse({ resumptionToken: void 0 });
+	}
+	async _commonHeaders() {
+		const headers = {};
+		if (this._authProvider) {
+			const tokens = await this._authProvider.tokens();
+			if (tokens) headers["Authorization"] = `Bearer ${tokens.access_token}`;
+		}
+		if (this._sessionId) headers["mcp-session-id"] = this._sessionId;
+		if (this._protocolVersion) headers["mcp-protocol-version"] = this._protocolVersion;
+		const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+		return new Headers({
+			...headers,
+			...extraHeaders
+		});
+	}
+	async _startOrAuthSse(options) {
+		const { resumptionToken } = options;
+		try {
+			const headers = await this._commonHeaders();
+			headers.set("Accept", "text/event-stream");
+			if (resumptionToken) headers.set("last-event-id", resumptionToken);
+			const response = await (this._fetch ?? fetch)(this._url, {
+				method: "GET",
+				headers,
+				signal: this._abortController?.signal
+			});
+			if (!response.ok) {
+				await response.body?.cancel();
+				if (response.status === 401 && this._authProvider) return await this._authThenStart();
+				if (response.status === 405) return;
+				throw new StreamableHTTPError(response.status, `Failed to open SSE stream: ${response.statusText}`);
+			}
+			this._handleSseStream(response.body, options, true);
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+	}
+	/**
+	* Calculates the next reconnection delay using  backoff algorithm
+	*
+	* @param attempt Current reconnection attempt count for the specific stream
+	* @returns Time to wait in milliseconds before next reconnection attempt
+	*/
+	_getNextReconnectionDelay(attempt) {
+		if (this._serverRetryMs !== void 0) return this._serverRetryMs;
+		const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
+		const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
+		const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
+		return Math.min(initialDelay * Math.pow(growFactor, attempt), maxDelay);
+	}
+	/**
+	* Schedule a reconnection attempt using server-provided retry interval or backoff
+	*
+	* @param lastEventId The ID of the last received event for resumability
+	* @param attemptCount Current reconnection attempt count for this specific stream
+	*/
+	_scheduleReconnection(options, attemptCount = 0) {
+		const maxRetries = this._reconnectionOptions.maxRetries;
+		if (attemptCount >= maxRetries) {
+			this.onerror?.(/* @__PURE__ */ new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
+			return;
+		}
+		const delay = this._getNextReconnectionDelay(attemptCount);
+		this._reconnectionTimeout = setTimeout(() => {
+			this._startOrAuthSse(options).catch((error) => {
+				this.onerror?.(/* @__PURE__ */ new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
+				this._scheduleReconnection(options, attemptCount + 1);
+			});
+		}, delay);
+	}
+	_handleSseStream(stream, options, isReconnectable) {
+		if (!stream) return;
+		const { onresumptiontoken, replayMessageId } = options;
+		let lastEventId;
+		let hasPrimingEvent = false;
+		let receivedResponse = false;
+		const processStream = async () => {
+			try {
+				const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({ onRetry: (retryMs) => {
+					this._serverRetryMs = retryMs;
+				} })).getReader();
+				while (true) {
+					const { value: event, done } = await reader.read();
+					if (done) break;
+					if (event.id) {
+						lastEventId = event.id;
+						hasPrimingEvent = true;
+						onresumptiontoken?.(event.id);
+					}
+					if (!event.data) continue;
+					if (!event.event || event.event === "message") try {
+						const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
+						if (isJSONRPCResultResponse(message)) {
+							receivedResponse = true;
+							if (replayMessageId !== void 0) message.id = replayMessageId;
+						}
+						this.onmessage?.(message);
+					} catch (error) {
+						this.onerror?.(error);
+					}
+				}
+				if ((isReconnectable || hasPrimingEvent) && !receivedResponse && this._abortController && !this._abortController.signal.aborted) this._scheduleReconnection({
+					resumptionToken: lastEventId,
+					onresumptiontoken,
+					replayMessageId
+				}, 0);
+			} catch (error) {
+				this.onerror?.(/* @__PURE__ */ new Error(`SSE stream disconnected: ${error}`));
+				if ((isReconnectable || hasPrimingEvent) && !receivedResponse && this._abortController && !this._abortController.signal.aborted) try {
+					this._scheduleReconnection({
+						resumptionToken: lastEventId,
+						onresumptiontoken,
+						replayMessageId
+					}, 0);
+				} catch (error) {
+					this.onerror?.(/* @__PURE__ */ new Error(`Failed to reconnect: ${error instanceof Error ? error.message : String(error)}`));
+				}
+			}
+		};
+		processStream();
+	}
+	async start() {
+		if (this._abortController) throw new Error("StreamableHTTPClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+		this._abortController = new AbortController();
+	}
+	/**
+	* Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
+	*/
+	async finishAuth(authorizationCode) {
+		if (!this._authProvider) throw new UnauthorizedError("No auth provider");
+		if (await auth(this._authProvider, {
+			serverUrl: this._url,
+			authorizationCode,
+			resourceMetadataUrl: this._resourceMetadataUrl,
+			scope: this._scope,
+			fetchFn: this._fetchWithInit
+		}) !== "AUTHORIZED") throw new UnauthorizedError("Failed to authorize");
+	}
+	async close() {
+		if (this._reconnectionTimeout) {
+			clearTimeout(this._reconnectionTimeout);
+			this._reconnectionTimeout = void 0;
+		}
+		this._abortController?.abort();
+		this.onclose?.();
+	}
+	async send(message, options) {
+		try {
+			const { resumptionToken, onresumptiontoken } = options || {};
+			if (resumptionToken) {
+				this._startOrAuthSse({
+					resumptionToken,
+					replayMessageId: isJSONRPCRequest(message) ? message.id : void 0
+				}).catch((err) => this.onerror?.(err));
+				return;
+			}
+			const headers = await this._commonHeaders();
+			headers.set("content-type", "application/json");
+			headers.set("accept", "application/json, text/event-stream");
+			const init = {
+				...this._requestInit,
+				method: "POST",
+				headers,
+				body: JSON.stringify(message),
+				signal: this._abortController?.signal
+			};
+			const response = await (this._fetch ?? fetch)(this._url, init);
+			const sessionId = response.headers.get("mcp-session-id");
+			if (sessionId) this._sessionId = sessionId;
+			if (!response.ok) {
+				const text = await response.text().catch(() => null);
+				if (response.status === 401 && this._authProvider) {
+					if (this._hasCompletedAuthFlow) throw new StreamableHTTPError(401, "Server returned 401 after successful authentication");
+					const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response);
+					this._resourceMetadataUrl = resourceMetadataUrl;
+					this._scope = scope;
+					if (await auth(this._authProvider, {
+						serverUrl: this._url,
+						resourceMetadataUrl: this._resourceMetadataUrl,
+						scope: this._scope,
+						fetchFn: this._fetchWithInit
+					}) !== "AUTHORIZED") throw new UnauthorizedError();
+					this._hasCompletedAuthFlow = true;
+					return this.send(message);
+				}
+				if (response.status === 403 && this._authProvider) {
+					const { resourceMetadataUrl, scope, error } = extractWWWAuthenticateParams(response);
+					if (error === "insufficient_scope") {
+						const wwwAuthHeader = response.headers.get("WWW-Authenticate");
+						if (this._lastUpscopingHeader === wwwAuthHeader) throw new StreamableHTTPError(403, "Server returned 403 after trying upscoping");
+						if (scope) this._scope = scope;
+						if (resourceMetadataUrl) this._resourceMetadataUrl = resourceMetadataUrl;
+						this._lastUpscopingHeader = wwwAuthHeader ?? void 0;
+						if (await auth(this._authProvider, {
+							serverUrl: this._url,
+							resourceMetadataUrl: this._resourceMetadataUrl,
+							scope: this._scope,
+							fetchFn: this._fetch
+						}) !== "AUTHORIZED") throw new UnauthorizedError();
+						return this.send(message);
+					}
+				}
+				throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`);
+			}
+			this._hasCompletedAuthFlow = false;
+			this._lastUpscopingHeader = void 0;
+			if (response.status === 202) {
+				await response.body?.cancel();
+				if (isInitializedNotification(message)) this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => this.onerror?.(err));
+				return;
+			}
+			const hasRequests = (Array.isArray(message) ? message : [message]).filter((msg) => "method" in msg && "id" in msg && msg.id !== void 0).length > 0;
+			const contentType = response.headers.get("content-type");
+			if (hasRequests) if (contentType?.includes("text/event-stream")) this._handleSseStream(response.body, { onresumptiontoken }, false);
+			else if (contentType?.includes("application/json")) {
+				const data = await response.json();
+				const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
+				for (const msg of responseMessages) this.onmessage?.(msg);
+			} else {
+				await response.body?.cancel();
+				throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`);
+			}
+			else await response.body?.cancel();
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+	}
+	get sessionId() {
+		return this._sessionId;
+	}
+	/**
+	* Terminates the current session by sending a DELETE request to the server.
+	*
+	* Clients that no longer need a particular session
+	* (e.g., because the user is leaving the client application) SHOULD send an
+	* HTTP DELETE to the MCP endpoint with the Mcp-Session-Id header to explicitly
+	* terminate the session.
+	*
+	* The server MAY respond with HTTP 405 Method Not Allowed, indicating that
+	* the server does not allow clients to terminate sessions.
+	*/
+	async terminateSession() {
+		if (!this._sessionId) return;
+		try {
+			const headers = await this._commonHeaders();
+			const init = {
+				...this._requestInit,
+				method: "DELETE",
+				headers,
+				signal: this._abortController?.signal
+			};
+			const response = await (this._fetch ?? fetch)(this._url, init);
+			await response.body?.cancel();
+			if (!response.ok && response.status !== 405) throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`);
+			this._sessionId = void 0;
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+	}
+	setProtocolVersion(version) {
+		this._protocolVersion = version;
+	}
+	get protocolVersion() {
+		return this._protocolVersion;
+	}
+	/**
+	* Resume an SSE stream from a previous event ID.
+	* Opens a GET SSE connection with Last-Event-ID header to replay missed events.
+	*
+	* @param lastEventId The event ID to resume from
+	* @param options Optional callback to receive new resumption tokens
+	*/
+	async resumeStream(lastEventId, options) {
+		await this._startOrAuthSse({
+			resumptionToken: lastEventId,
+			onresumptiontoken: options?.onresumptiontoken
+		});
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/inMemory.js
+/**
+* In-memory transport for creating clients and servers that talk to each other within the same process.
+*/
+var InMemoryTransport = class InMemoryTransport {
+	constructor() {
+		this._messageQueue = [];
+	}
+	/**
+	* Creates a pair of linked in-memory transports that can communicate with each other. One should be passed to a Client and one to a Server.
+	*/
+	static createLinkedPair() {
+		const clientTransport = new InMemoryTransport();
+		const serverTransport = new InMemoryTransport();
+		clientTransport._otherTransport = serverTransport;
+		serverTransport._otherTransport = clientTransport;
+		return [clientTransport, serverTransport];
+	}
+	async start() {
+		while (this._messageQueue.length > 0) {
+			const queuedMessage = this._messageQueue.shift();
+			this.onmessage?.(queuedMessage.message, queuedMessage.extra);
+		}
+	}
+	async close() {
+		const other = this._otherTransport;
+		this._otherTransport = void 0;
+		await other?.close();
+		this.onclose?.();
+	}
+	/**
+	* Sends a message with optional auth info.
+	* This is useful for testing authentication scenarios.
+	*/
+	async send(message, options) {
+		if (!this._otherTransport) throw new Error("Not connected");
+		if (this._otherTransport.onmessage) this._otherTransport.onmessage(message, { authInfo: options?.authInfo });
+		else this._otherTransport._messageQueue.push({
+			message,
+			extra: { authInfo: options?.authInfo }
+		});
+	}
+};
+
 //#endregion
 //#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
 /**
@@ -55093,58 +57335,6 @@ var ExperimentalServerTasks = class {
 	}
 };
 
-//#endregion
-//#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
-/**
-* Experimental task capability assertion helpers.
-* WARNING: These APIs are experimental and may change without notice.
-*
-* @experimental
-*/
-/**
-* Asserts that task creation is supported for tools/call.
-* Used by Client.assertTaskCapability and Server.assertTaskHandlerCapability.
-*
-* @param requests - The task requests capability object
-* @param method - The method being checked
-* @param entityName - 'Server' or 'Client' for error messages
-* @throws Error if the capability is not supported
-*
-* @experimental
-*/
-function assertToolsCallTaskCapability(requests, method, entityName) {
-	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
-	switch (method) {
-		case "tools/call":
-			if (!requests.tools?.call) throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
-			break;
-		default: break;
-	}
-}
-/**
-* Asserts that task creation is supported for sampling/createMessage or elicitation/create.
-* Used by Server.assertTaskCapability and Client.assertTaskHandlerCapability.
-*
-* @param requests - The task requests capability object
-* @param method - The method being checked
-* @param entityName - 'Server' or 'Client' for error messages
-* @throws Error if the capability is not supported
-*
-* @experimental
-*/
-function assertClientRequestTaskCapability(requests, method, entityName) {
-	if (!requests) throw new Error(`${entityName} does not support task creation (required for ${method})`);
-	switch (method) {
-		case "sampling/createMessage":
-			if (!requests.sampling?.createMessage) throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-			break;
-		case "elicitation/create":
-			if (!requests.elicitation?.create) throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
-			break;
-		default: break;
-	}
-}
-
 //#endregion
 //#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_zod@4.4.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 /**
@@ -56241,6 +58431,26 @@ const EMPTY_COMPLETION_RESULT = { completion: {
 //#endregion
 //#region ../mcp-microsoft-planner-premium/dist/index.mjs
 /**
+* The rhythm, fixed. The caller chooses how long to wait; it never chooses how often
+* to look, because that is a property of the API's latency rather than of anything a
+* caller knows. The recorder's sequences come out at this cadence for the better reason:
+* it drives `waitForOperationSet` rather than polling by hand.
+*/
+const POLL_SECONDS = 4;
+/**
+* The order the verbs are staged in — creates, then updates, then deletes.
+*
+* Fixed rather than derived from the caller's list, because it is the order that was
+* driven against a real org and observed applying whole. Whether the service would
+* honour another order is unknown and not worth discovering by accident, and a
+* caller has no reason to care: the set is one transaction either way.
+*/
+const STAGING_ORDER = [
+	"create",
+	"update",
+	"delete"
+];
+/**
 * When to read, in seconds from the call: immediately, every `POLL_SECONDS`, and at
 * the closing bell. A list rather than a loop condition — the schedule is data, so
 * it can be read, tested, and argued about without a clock anywhere near it.
@@ -56251,7 +58461,7 @@ const EMPTY_COMPLETION_RESULT = { completion: {
 */
 function readInstants(seconds) {
 	const instants = [0];
-	for (let at = 4; at < seconds; at += 4) instants.push(at);
+	for (let at = POLL_SECONDS; at < seconds; at += POLL_SECONDS) instants.push(at);
 	if (seconds > 0) instants.push(seconds);
 	return instants;
 }
@@ -56259,11 +58469,11 @@ function reason(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 /**
-* Submit one write and hand back the receipt.
+* Submit one operation set and hand back the receipt.
 *
-* ABANDON ONLY ON A STAGING FAILURE. A set whose staging threw holds nothing and is
-* still open, so it would sit against the caller's open-set quota forever with no
-* API to find it again; abandoning an empty set is accepted. After execute the
+* ABANDON ONLY ON A STAGING FAILURE. A set whose staging threw holds a partial
+* transaction and is still open, so it would sit against the caller's open-set quota
+* forever with no API to find it again; abandoning it is accepted. After execute the
 * question does not arise — this returns the moment the service accepts, and what
 * happens to the set afterwards belongs to `waitForOperationSet`.
 *
@@ -56271,17 +58481,32 @@ function reason(error) {
 * half true: a set closes when the WORK fails and stays OPEN when the SET itself is
 * rejected (an empty one, for instance). The rule above holds either way; the
 * plausible-sounding premise does not.
+*
+* An EMPTY submission is the caller's to prevent. Executing a set with nothing
+* staged is rejected AND leaves the set open — the one execute failure that leaks a
+* quota slot — so the edge refuses it before a set is ever minted, rather than this
+* layer growing a branch for a call that should not have been made.
 */
-async function submitWrite(api, input) {
+async function submitOperationSet(api, input) {
 	const operationSetId = await api.createOperationSet({
 		description: input.description,
 		projectId: input.projectId
 	});
 	try {
-		await api.stage({
-			operationSetId,
-			write: input.write
-		});
+		const entitiesByVerb = {
+			create: [],
+			delete: [],
+			update: []
+		};
+		for (const write of input.writes) entitiesByVerb[write.verb].push(write.entity);
+		for (const verb of STAGING_ORDER) {
+			const entities = entitiesByVerb[verb];
+			if (entities.length > 0) await api.stage({
+				entities,
+				operationSetId,
+				verb
+			});
+		}
 	} catch (error) {
 		try {
 			await api.abandonOperationSet(operationSetId);
@@ -56313,6 +58538,9 @@ async function outcomeOf(api, set) {
 * Lifting it out is what makes the two exits the same line of code: whether the set
 * settled or the caller simply ran out of window, the answer is the last thing the
 * set actually said.
+*
+* `executing` is not a promise of settlement. When the window closes, return the
+* last observed status rather than timing out and inviting a non-idempotent retry.
 */
 async function waitForOperationSet(api, input) {
 	let elapsed = 0;
@@ -56325,6 +58553,56 @@ async function waitForOperationSet(api, input) {
 	}
 	return outcomeOf(api, set);
 }
+/**
+* The record kinds this package can write, and the two wire facts each one needs:
+* its `@odata.type` and the column holding its primary key. One table rather than a
+* literal per builder, because a delete names a record by exactly these two things
+* and would otherwise have to restate every one of them.
+*/
+const RECORD = {
+	assignment: {
+		id: "msdyn_resourceassignmentid",
+		type: "Microsoft.Dynamics.CRM.msdyn_resourceassignment"
+	},
+	bucket: {
+		id: "msdyn_projectbucketid",
+		type: "Microsoft.Dynamics.CRM.msdyn_projectbucket"
+	},
+	label: {
+		id: "msdyn_projectlabelid",
+		type: "Microsoft.Dynamics.CRM.msdyn_projectlabel"
+	},
+	task: {
+		id: "msdyn_projecttaskid",
+		type: "Microsoft.Dynamics.CRM.msdyn_projecttask"
+	},
+	taskLabel: {
+		id: "msdyn_projecttasktolabelid",
+		type: "Microsoft.Dynamics.CRM.msdyn_projecttasktolabel"
+	}
+};
+const identify = (kind, id) => ({
+	"@odata.type": RECORD[kind].type,
+	[RECORD[kind].id]: id
+});
+/**
+* A lookup, in OData's reference syntax.
+*
+* The navigation property is NOT always the column that holds the lookup, and
+* Dataverse matches it case-sensitively: a task binds its project through
+* `msdyn_project` but a task-label link binds its task through `msdyn_ProjectTaskId`.
+* Every name passed here comes from the org's own `$metadata`, never from the
+* column name it resembles.
+*/
+const bind = (navigationProperty, entitySet, id) => id === void 0 ? {} : { [`${navigationProperty}@odata.bind`]: `/${entitySet}(${id})` };
+/**
+* The entity, minus the columns the caller did not name. THIS is what makes a partial
+* update partial.
+*
+* `undefined` and absent are the same thing to this API; a column is written or it is
+* not, and there is no third state to lose here.
+*/
+const written = (entity) => Object.fromEntries(Object.entries(entity).filter(([, value]) => value !== void 0));
 const OPERATION_SET_STATUS = {
 	19235e4: "open",
 	192350001: "executing",
@@ -56361,50 +58639,188 @@ const pssErrorLogRowSchema = object$4({
 });
 const createOperationSetResponseSchema = object$4({ OperationSetId: string$3().min(1) });
 const SET_COLUMNS = "?$select=msdyn_status,_msdyn_psserrorlog_value";
-const projectTaskType = "Microsoft.Dynamics.CRM.msdyn_projecttask";
-const bucketBind = (bucketId) => ({ "msdyn_projectbucket@odata.bind": `/msdyn_projectbuckets(${bucketId})` });
 /**
-* A NEW project task. Every column is written, so nothing here is optional — and
-* the primary key is ours to choose: the service honours a client-supplied
-* `msdyn_projecttaskid`, which is what lets a caller know the id before the write
-* has even been executed.
+* The task columns a create and an update spell identically.
+*
+* `msdyn_description` only — NEVER `msdyn_descriptionplaintext`. Writing the first
+* populates the second; writing the second directly is refused. A caller that set
+* both would be sending one column the service rejects, for nothing.
+*
+* Dates are forwarded unchanged. Callers must provide an unambiguous instant; this
+* layer does not normalize because doing so would guess their intent.
+*/
+function taskColumns(fields) {
+	return {
+		msdyn_description: fields.description,
+		msdyn_finish: fields.finish,
+		msdyn_priority: fields.priority,
+		msdyn_start: fields.start
+	};
+}
+/**
+* A NEW project task.
+*
+* The primary key is OURS to choose: the service honours a client-supplied
+* `msdyn_projecttaskid`. That is what lets a caller know the id before the write has
+* been executed — and what lets this task name a BUCKET created in the same batch.
+*
+* `outlineLevel` is the caller's to state rather than ours to default. A subtask sits
+* one level below its parent, and this file cannot learn a parent's level without a
+* read it has no business making; the agent has that column in the synced tables.
 */
 function createProjectTask(fields) {
+	return {
+		entity: written({
+			...identify("task", fields.taskId),
+			msdyn_outlinelevel: fields.outlineLevel,
+			msdyn_subject: fields.subject,
+			...bind("msdyn_project", "msdyn_projects", fields.projectId),
+			...bind("msdyn_projectbucket", "msdyn_projectbuckets", fields.bucketId),
+			...bind("msdyn_parenttask", "msdyn_projecttasks", fields.parentTaskId),
+			...taskColumns(fields)
+		}),
+		verb: "create"
+	};
+}
+/**
+* A CHANGE to an existing task: only the named columns are written, which is what
+* makes a partial update partial. The project is deliberately not expressible — a
+* change cannot move a task to another project.
+*
+* Cross-project moves are deliberately unsupported because they can silently mutate
+* unintended data rather than fail.
+*
+* Date updates can reschedule dependent tasks. This builder forwards them without
+* attempting impact analysis.
+*/
+function updateProjectTask(fields) {
+	return {
+		entity: written({
+			...identify("task", fields.taskId),
+			msdyn_duration: fields.duration,
+			msdyn_effort: fields.effort,
+			msdyn_progress: fields.progress,
+			msdyn_subject: fields.subject,
+			...bind("msdyn_projectbucket", "msdyn_projectbuckets", fields.bucketId),
+			...bind("msdyn_parenttask", "msdyn_projecttasks", fields.parentTaskId),
+			...taskColumns(fields)
+		}),
+		verb: "update"
+	};
+}
+/**
+* A NEW bucket on a project.
+*
+* Display order is deliberately unsupported; the recorder's create display-order
+* probe owns the service claim behind that omission.
+*/
+function createProjectBucket(fields) {
 	return {
 		entity: {
-			"@odata.type": projectTaskType,
-			msdyn_outlinelevel: 1,
-			"msdyn_project@odata.bind": `/msdyn_projects(${fields.projectId})`,
-			...bucketBind(fields.bucketId),
-			msdyn_projecttaskid: fields.taskId,
-			msdyn_subject: fields.subject
+			...identify("bucket", fields.bucketId),
+			msdyn_name: fields.name,
+			...bind("msdyn_project", "msdyn_projects", fields.projectId)
 		},
 		verb: "create"
 	};
 }
 /**
-* A CHANGE to an existing task: only the named fields are written, which is what
-* makes a partial update partial. Neither the project nor the outline is expressible
-* — a change cannot reparent or restructure.
+* Rename an existing bucket.
 *
-* That guarantee is worth keeping for a reason the wire made plain: asked to move a
-* task into a bucket belonging to ANOTHER project, the service does not refuse. It
-* reports the set `completed` and writes a third bucket, neither the one requested
-* nor the one the task was in. Withholding the project change is not withholding a
-* rejection.
+* Reordering is deliberately unsupported; the recorder's update display-order probe
+* owns the service claim behind that omission.
 */
-function updateProjectTask(fields) {
+function updateProjectBucket(fields) {
+	return {
+		entity: {
+			...identify("bucket", fields.bucketId),
+			msdyn_name: fields.name
+		},
+		verb: "update"
+	};
+}
+/**
+* Rename a label. Its colour is not ours to change.
+*
+* A label is never CREATED, and the API offers no way to: every project is born with
+* twenty-five of them, unnamed, one per colour. So the only way to have a label
+* called "Blocked" is to rename one that already exists, and the only way to be rid
+* of one is to clear its text.
+*
+* Colour is deliberately unsupported; the recorder's label-colour probe owns the
+* service claim behind that omission.
+*/
+function updateProjectLabel(fields) {
 	return {
 		entity: {
-			"@odata.type": projectTaskType,
-			msdyn_projecttaskid: fields.taskId,
-			...fields.progress === void 0 ? {} : { msdyn_progress: fields.progress },
-			...fields.bucketId === void 0 ? {} : bucketBind(fields.bucketId),
-			...fields.subject === void 0 ? {} : { msdyn_subject: fields.subject }
+			...identify("label", fields.labelId),
+			msdyn_projectlabeltext: fields.text
 		},
 		verb: "update"
 	};
 }
+/**
+* Put a label on a task. A join row — so taking the label off is deleting this row,
+* which is why there is no `updateTaskLabel` to go with it.
+*/
+function createTaskLabel(fields) {
+	return {
+		entity: {
+			...identify("taskLabel", fields.linkId),
+			...bind("msdyn_ProjectTaskId", "msdyn_projecttasks", fields.taskId),
+			...bind("msdyn_ProjectLabelId", "msdyn_projectlabels", fields.labelId)
+		},
+		verb: "create"
+	};
+}
+/**
+* Assign a project team member to a task.
+*
+* An assignment inherits its task's dates and identifies the assignee by project-team
+* membership.
+*/
+function createResourceAssignment(fields) {
+	return {
+		entity: {
+			...identify("assignment", fields.assignmentId),
+			msdyn_name: fields.name,
+			...bind("msdyn_taskid", "msdyn_projecttasks", fields.taskId),
+			...bind("msdyn_projectid", "msdyn_projects", fields.projectId),
+			...bind("msdyn_projectteamid", "msdyn_projectteams", fields.projectTeamId)
+		},
+		verb: "create"
+	};
+}
+/**
+* Remove a record. A staged delete names its record exactly as a create does — type
+* and id — so one shape covers every kind this package can write.
+*/
+function deleteRecord(fields) {
+	return {
+		entity: identify(fields.kind, fields.id),
+		verb: "delete"
+	};
+}
+/** A non-2xx answer from the Schedule API, distinct from local/schema failures. */
+var ScheduleApiError = class extends Error {
+	path;
+	status;
+	statusText;
+	responseBody;
+	name = "ScheduleApiError";
+	constructor(path, status, statusText, responseBody) {
+		super(`Schedule API ${path} failed: ${status} ${statusText}${responseBody ? ` — ${responseBody}` : ""}`);
+		this.path = path;
+		this.status = status;
+		this.statusText = statusText;
+		this.responseBody = responseBody;
+	}
+};
+const STAGE_ACTION = {
+	create: "msdyn_PssCreateV2",
+	delete: "msdyn_PssDeleteV2",
+	update: "msdyn_PssUpdateV2"
+};
 function createScheduleApiClient(config) {
 	async function hop(path, init) {
 		const response = await fetch(`${config.orgUrl}/api/data/v9.2/${path}`, {
@@ -56417,7 +58833,7 @@ function createScheduleApiClient(config) {
 		});
 		if (!response.ok) {
 			const detail = await response.text().catch(() => "");
-			throw new Error(`Schedule API ${path} failed: ${response.status} ${response.statusText}${detail ? ` — ${detail}` : ""}`);
+			throw new ScheduleApiError(path, response.status, response.statusText, detail);
 		}
 		return await response.text();
 	}
@@ -56455,30 +58871,143 @@ function createScheduleApiClient(config) {
 				log: row.msdyn_log ?? ""
 			};
 		},
-		stage: (input) => action(input.write.verb === "create" ? "msdyn_PssCreateV1" : "msdyn_PssUpdateV1", {
-			Entity: input.write.entity,
+		stage: (input) => action(STAGE_ACTION[input.verb], {
+			EntityCollection: input.entities,
 			OperationSetId: input.operationSetId
 		})
 	};
 }
-const SERVER_VERSION = "0.5.14";
+const SERVER_VERSION = "0.5.16";
+/** The most operations one OperationSet will carry. The service's own ceiling. */
+const MAX_OPERATIONS = 200;
 /**
-* A Dataverse row as the write tools take it: the GUID does the work, the name is
-* what the human reads on the approval card. They are ONE object because they are
-* one concept — which makes "an id without its label" unrepresentable in the
-* advertised schema, rather than a runtime check that fires after a human has
-* already approved.
+* A Dataverse row as the tools take it: the GUID does the work, the name is what the
+* human reads on the approval card. They are ONE object because they are one concept
+* — which makes "an id without its label" unrepresentable in the advertised schema,
+* rather than a runtime check that fires after a human has already approved.
 *
 * `guid()`, NOT `uuid()`: Dataverse GUIDs are not RFC-4122, so msdyn_* ids routinely
 * carry a non-version nibble (`…-f011-…`) that zod's `uuid()` rejects — a `uuid()`
-* here silently fails every real `create_task` at argument validation. `guid()`
-* still enforces the 8-4-4-4-12 shape. Do not tighten.
+* here silently fails every real write at argument validation. `guid()` still
+* enforces the 8-4-4-4-12 shape. Do not tighten.
 */
-const reference = (what, idColumn) => strictObject({
+const existing = (what, idColumn) => strictObject({
 	id: guid$1().describe(`${what} GUID from the synced Postgres tables (${idColumn})`),
 	name: string$3().min(1).describe(`${what} name, for the human approving this action`)
 });
 /**
+* A record being created in THIS submission, addressed by the caller's own label.
+*
+* It exists because record ids are client-supplied upstream, which is the whole
+* reason a task can be created into a bucket created alongside it. Rather than ask a
+* model to mint GUIDs and keep them unique, the caller names the new record and this
+* file mints the id — returning the mapping in the receipt.
+*/
+const pending = strictObject({ ref: string$3().min(1).describe("The `ref` of a record created in this same submission — how a task names a bucket that does not exist yet") });
+const reference = (what, idColumn) => union$2([existing(what, idColumn), pending]);
+/** Require a full UTC timestamp because date-only input can land on a different working day. */
+const instant = datetime$2().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/, "must be a full UTC timestamp like 2026-08-28T17:00:00Z — a bare date is read as midnight and lands on the previous working day");
+const taskRef = () => reference("task", "msdyn_projecttaskid");
+const bucketRef = () => reference("bucket", "msdyn_projectbucketid");
+const taskCreate = strictObject({
+	bucket: bucketRef().describe("The bucket the task goes in"),
+	description: string$3().optional().describe("Body text for the task, shown under its name"),
+	finish: instant.optional().describe("When the task is due"),
+	kind: literal("task"),
+	name: string$3().min(1).describe("The new task's name"),
+	outline_level: number$4().int().min(1).default(1).describe("1 for a top-level task. A subtask is its parent's level plus one — read the parent's msdyn_outlinelevel from the synced tables."),
+	parent_task: taskRef().optional().describe("Makes this a subtask of that task"),
+	priority: number$4().int().min(0).max(10).optional().describe("0-10; 5 is the default"),
+	ref: string$3().min(1).optional().describe("Name this task so other operations here can reference it, and so the receipt returns its id"),
+	start: instant.optional().describe("When work on the task starts")
+});
+const bucketCreate = strictObject({
+	kind: literal("bucket"),
+	name: string$3().min(1).describe("The new bucket's name"),
+	ref: string$3().min(1).optional().describe("Name this bucket so tasks in this same submission can go into it")
+});
+const taskLabelCreate = strictObject({
+	kind: literal("task_label"),
+	label: existing("label", "msdyn_projectlabelid").describe("The label to put on the task"),
+	task: taskRef().describe("The task getting the label")
+});
+const assignmentCreate = strictObject({
+	kind: literal("assignment"),
+	member: existing("project team member", "msdyn_projectteamid").describe("The team member to assign, from msdyn_projectteams"),
+	name: string$3().min(1).describe("A label for the assignment, shown on the approval card"),
+	task: taskRef().describe("The task to assign. A task that has subtasks CANNOT be assigned to — the service refuses it.")
+});
+const taskUpdate = strictObject({
+	bucket: bucketRef().optional().describe("Move the task to this bucket, in the same project"),
+	description: string$3().optional(),
+	duration: number$4().optional().describe("Working days. Writing this moves the finish."),
+	effort: number$4().optional().describe("Hours of work"),
+	finish: instant.optional(),
+	kind: literal("task"),
+	name: string$3().min(1).optional().describe("Rename the task to this"),
+	parent_task: taskRef().optional(),
+	priority: number$4().int().min(0).max(10).optional(),
+	progress: number$4().min(0).max(1).optional().describe("Fraction complete, 0-1 — 0.55 is 55%, and 1 is done. NOT a percentage: 55 is rejected."),
+	start: instant.optional(),
+	task: taskRef().describe("The task to change")
+}).refine((input) => input.bucket !== void 0 || input.description !== void 0 || input.duration !== void 0 || input.effort !== void 0 || input.finish !== void 0 || input.name !== void 0 || input.parent_task !== void 0 || input.priority !== void 0 || input.progress !== void 0 || input.start !== void 0, { message: "Nothing to update — a task update needs at least one changed field." });
+const bucketUpdate = strictObject({
+	bucket: bucketRef().describe("The bucket to change"),
+	kind: literal("bucket"),
+	name: string$3().min(1).describe("Rename the bucket to this")
+});
+const labelUpdate = strictObject({
+	kind: literal("label"),
+	label: existing("label", "msdyn_projectlabelid"),
+	text: string$3().describe("The label's name. A project's labels start unnamed; clearing the text retires one.")
+});
+const taskDelete = strictObject({
+	kind: literal("task"),
+	task: existing("task", "msdyn_projecttaskid")
+});
+const taskLabelDelete = strictObject({
+	kind: literal("task_label"),
+	link: existing("task-label link", "msdyn_projecttasktolabelid")
+});
+const assignmentDelete = strictObject({
+	assignment: existing("assignment", "msdyn_resourceassignmentid"),
+	kind: literal("assignment")
+});
+const createOperationSchema = discriminatedUnion("kind", [
+	taskCreate,
+	bucketCreate,
+	taskLabelCreate,
+	assignmentCreate
+]);
+const updateOperationSchema = discriminatedUnion("kind", [
+	taskUpdate,
+	bucketUpdate,
+	labelUpdate
+]);
+const deleteOperationSchema = discriminatedUnion("kind", [
+	taskDelete,
+	taskLabelDelete,
+	assignmentDelete
+]);
+/**
+* One submission, as the tool takes it.
+*
+* Defined at module scope so `Submission` derives from the exact schema and cannot
+* drift. The refinements enforce cross-field and service-boundary invariants that the
+* individual field schemas cannot express.
+*/
+const submissionSchema = strictObject({
+	creates: array$1(createOperationSchema).default([]).describe("Records to create"),
+	deletes: array$1(deleteOperationSchema).default([]).describe("Records to remove. Buckets cannot be deleted here — removing one takes every task in it."),
+	description: string$3().min(1).describe("What this set does, in the words of the person approving it"),
+	project: existing("project", "msdyn_projectid"),
+	updates: array$1(updateOperationSchema).default([]).describe("Records to change")
+}).refine((input) => input.creates.length + input.updates.length + input.deletes.length > 0, { message: "Nothing to do — a set needs at least one create, update or delete." }).refine((input) => input.creates.length + input.updates.length + input.deletes.length <= MAX_OPERATIONS, { message: `An operation set carries at most ${MAX_OPERATIONS} operations.` }).refine((input) => [...input.creates, ...input.updates].every((operation) => {
+	const start = "start" in operation ? operation.start : void 0;
+	const finish = "finish" in operation ? operation.finish : void 0;
+	return start === void 0 || finish === void 0 || Date.parse(start) <= Date.parse(finish);
+}), { message: "finish is before start — the service accepts this, silently recomputes the finish from the duration, and still reports the set completed, so the board would end up holding dates you did not send" });
+/**
 * The caller's Dataverse credentials, recovered entirely from the request: the
 * delegated token in `Authorization`, and the org URL from its `aud` claim (`aud` IS
 * the `https://<org>.crm.dynamics.com` origin).
@@ -56499,67 +59028,145 @@ const toolResult = (payload) => ({ content: [{
 	text: JSON.stringify(payload),
 	type: "text"
 }] });
-const RECEIPT = "Returns an operation_set_id — a RECEIPT, not a confirmation: the write has been accepted, not applied. Pass it to wait_for_operation_set to learn whether it landed.";
-const SAME_PROJECT = "The bucket must belong to the named project. A bucket from another project is NOT rejected — the service reports the set completed anyway, and where the write landed, when checked, was a bucket nobody asked for.";
+function assertNever(value, where) {
+	throw new Error(`Unhandled ${where}: ${JSON.stringify(value)}`);
+}
+/**
+* Every create paired with its id, and the subset the caller named.
+*
+* Mint each create id exactly once before mapping any writes. Client-supplied primary
+* keys let operations in the same set reference each other; only caller-named refs
+* enter `createsByRef`.
+*/
+function planCreates(requested) {
+	const createsByRef = /* @__PURE__ */ new Map();
+	return {
+		createsByRef,
+		plannedCreates: requested.map((create) => {
+			const id = randomUUID();
+			if ((create.kind === "bucket" || create.kind === "task") && create.ref !== void 0) {
+				if (createsByRef.has(create.ref)) throw new Error(`Two creates in this submission share the ref '${create.ref}' — a ref names exactly one record.`);
+				createsByRef.set(create.ref, {
+					id,
+					kind: create.kind
+				});
+			}
+			return {
+				create,
+				id
+			};
+		})
+	};
+}
+function resolveReferenceId(createsByRef, reference, expectedKind) {
+	if ("id" in reference) return reference.id;
+	const created = createsByRef.get(reference.ref);
+	if (created === void 0) throw new Error(`Nothing in this submission is created with the ref '${reference.ref}'. A ref must name a create in the same call; an existing record is named by { id, name }.`);
+	if (created.kind !== expectedKind) throw new Error(`The ref '${reference.ref}' names a ${created.kind}, but this field needs a ${expectedKind}.`);
+	return created.id;
+}
+function writesOf(submission, plannedCreates, createsByRef) {
+	const resolveId = (reference, kind) => resolveReferenceId(createsByRef, reference, kind);
+	const projectId = submission.project.id;
+	const staged = [];
+	for (const { create, id: newId } of plannedCreates) if (create.kind === "task") staged.push(createProjectTask({
+		bucketId: resolveId(create.bucket, "bucket"),
+		description: create.description,
+		finish: create.finish,
+		outlineLevel: create.outline_level,
+		parentTaskId: create.parent_task === void 0 ? void 0 : resolveId(create.parent_task, "task"),
+		priority: create.priority,
+		projectId,
+		start: create.start,
+		subject: create.name,
+		taskId: newId
+	}));
+	else if (create.kind === "bucket") staged.push(createProjectBucket({
+		bucketId: newId,
+		name: create.name,
+		projectId
+	}));
+	else if (create.kind === "task_label") staged.push(createTaskLabel({
+		labelId: create.label.id,
+		linkId: newId,
+		taskId: resolveId(create.task, "task")
+	}));
+	else if (create.kind === "assignment") staged.push(createResourceAssignment({
+		assignmentId: newId,
+		name: create.name,
+		projectId,
+		projectTeamId: create.member.id,
+		taskId: resolveId(create.task, "task")
+	}));
+	else assertNever(create, "create operation");
+	for (const update of submission.updates) if (update.kind === "task") staged.push(updateProjectTask({
+		bucketId: update.bucket === void 0 ? void 0 : resolveId(update.bucket, "bucket"),
+		description: update.description,
+		duration: update.duration,
+		effort: update.effort,
+		finish: update.finish,
+		parentTaskId: update.parent_task === void 0 ? void 0 : resolveId(update.parent_task, "task"),
+		priority: update.priority,
+		progress: update.progress,
+		start: update.start,
+		subject: update.name,
+		taskId: resolveId(update.task, "task")
+	}));
+	else if (update.kind === "bucket") staged.push(updateProjectBucket({
+		bucketId: resolveId(update.bucket, "bucket"),
+		name: update.name
+	}));
+	else if (update.kind === "label") staged.push(updateProjectLabel({
+		labelId: update.label.id,
+		text: update.text
+	}));
+	else assertNever(update, "update operation");
+	for (const deleteOperation of submission.deletes) if (deleteOperation.kind === "task") staged.push(deleteRecord({
+		id: deleteOperation.task.id,
+		kind: "task"
+	}));
+	else if (deleteOperation.kind === "task_label") staged.push(deleteRecord({
+		id: deleteOperation.link.id,
+		kind: "taskLabel"
+	}));
+	else if (deleteOperation.kind === "assignment") staged.push(deleteRecord({
+		id: deleteOperation.assignment.id,
+		kind: "assignment"
+	}));
+	else assertNever(deleteOperation, "delete operation");
+	return staged;
+}
 function createMcpServer() {
 	const server = new McpServer({
 		name: "microsoft-planner-premium",
 		version: SERVER_VERSION
 	});
-	server.registerTool("create_task", {
-		description: `Create a task on a Premium Planner (Project for the web) board, in a specific bucket. Read the ids from the synced msdyn_projects / msdyn_projectbuckets tables; each id travels with the matching name, which is what the human approving this action reads. ${SAME_PROJECT} ${RECEIPT} It also returns task_id — the id the task WILL have if the set completes.`,
-		inputSchema: strictObject({
-			bucket: reference("bucket", "msdyn_projectbucketid"),
-			name: string$3().min(1).describe("The new task's name"),
-			project: reference("project", "msdyn_projectid")
-		})
-	}, async ({ bucket, name, project }, extra) => {
-		const taskId = randomUUID();
+	server.registerTool("submit_operation_set", {
+		description: [
+			"Change a Premium Planner (Project for the web) board. One call is one OPERATION SET — the scheduling service's own unit of work: a transaction over many operations, all against ONE project, applied together or not at all.",
+			"Put everything one intent needs into a single call. Creating a bucket and the tasks that go in it, or renaming a task and setting its dates and assigning it, is one set and one approval — not several. A task can go into a bucket created in the SAME call by giving that bucket a `ref` and naming it.",
+			"Read every id from the synced msdyn_* tables; each id travels with the matching name, which the human sees in the approval arguments. `description` is yours to write, so summarize the set in that human's words.",
+			"Changing a task's dates can move OTHER tasks: tasks are auto-scheduled, so a task that has dependents drags them along, and the set reports only that it completed.",
+			"Returns an operation_set_id — a RECEIPT, not a confirmation: the set has been accepted, not applied. Pass it to wait_for_operation_set to learn whether it landed."
+		].join(" "),
+		inputSchema: submissionSchema
+	}, async (submission, extra) => {
+		const { createsByRef, plannedCreates } = planCreates(submission.creates);
+		const operationSetId = await submitOperationSet(scheduleApiFromRequest(extra.requestInfo), {
+			description: submission.description,
+			projectId: submission.project.id,
+			writes: writesOf(submission, plannedCreates, createsByRef)
+		});
 		return toolResult({
-			operation_set_id: await submitWrite(scheduleApiFromRequest(extra.requestInfo), {
-				description: `ContextLayer create_task: ${name}`,
-				projectId: project.id,
-				write: createProjectTask({
-					bucketId: bucket.id,
-					projectId: project.id,
-					subject: name,
-					taskId
-				})
-			}),
-			task_id: taskId
+			created: Object.fromEntries([...createsByRef].map(([ref, created]) => [ref, created.id])),
+			operation_set_id: operationSetId
 		});
 	});
-	server.registerTool("update_task", {
-		description: `Change an existing task on a Premium Planner (Project for the web) board — rename it, move it to another bucket, set how complete it is, or any combination, applied as one atomic write. Read the ids from the synced msdyn_* tables; each id travels with the matching name, which is what the human approving this action reads. ${SAME_PROJECT} ${RECEIPT}`,
-		inputSchema: strictObject({
-			changes: strictObject({
-				bucket: reference("bucket", "msdyn_projectbucketid").optional().describe("Move the task to this bucket, in the same project"),
-				name: string$3().min(1).optional().describe("Rename the task to this"),
-				progress: number$4().min(0).max(1).optional().describe("Fraction complete, 0-1 — 0.55 is 55%, and 1 is done. NOT a percentage: 55 is rejected.")
-			}).describe("What to change about the task — at least one of these."),
-			project: reference("project", "msdyn_projectid"),
-			task: reference("task", "msdyn_projecttaskid")
-		}).refine((input) => Object.keys(input.changes).length > 0, {
-			message: "Nothing to update — changes needs at least one of name, bucket, progress.",
-			path: ["changes"]
-		})
-	}, async ({ changes, project, task }, extra) => {
-		return toolResult({ operation_set_id: await submitWrite(scheduleApiFromRequest(extra.requestInfo), {
-			description: `ContextLayer update_task: ${task.name}`,
-			projectId: project.id,
-			write: updateProjectTask({
-				bucketId: changes.bucket?.id,
-				progress: changes.progress,
-				subject: changes.name,
-				taskId: task.id
-			})
-		}) });
-	});
 	server.registerTool("wait_for_operation_set", {
-		description: "Find out what became of a write. Takes the operation_set_id returned by create_task or update_task and reads it until it settles or the window closes, then reports the scheduling service's own status: completed, failed (with its reason), executing, open, or abandoned. Writes usually settle within a few seconds; the slowest recorded took about half a minute. Note that 'completed' means the service applied the set without error — it is not a promise that a field holds the value you sent.",
+		description: "Find out what became of a submitted set. Takes the operation_set_id returned by submit_operation_set and reads it once. While the status is executing, it polls until the set becomes terminal or the window closes; any other status returns immediately. Reports the scheduling service's own status: completed, failed (with its reason), executing, open, or abandoned. Note that 'completed' means the service applied the set without error — it is not a promise that a field holds the value you sent.",
 		inputSchema: strictObject({
-			operation_set_id: string$3().min(1).describe("The operation_set_id returned by create_task or update_task"),
-			seconds: number$4().int().min(0).max(45).describe(`How long to wait, 0-45. 0 reads once and returns whatever it says. Still 'executing' when the window closes means the write is in flight, NOT lost — call again.`)
+			operation_set_id: string$3().min(1).describe("The operation_set_id returned by submit_operation_set"),
+			seconds: number$4().int().min(0).max(45).describe(`How long to wait, 0-45. 0 reads once and returns whatever the service says. If it still reports 'executing' when the window closes, call again.`)
 		})
 	}, async ({ operation_set_id, seconds }, extra) => {
 		return toolResult({ ...await waitForOperationSet(scheduleApiFromRequest(extra.requestInfo), {
@@ -83896,7 +86503,7 @@ function osUsername() {
 }
 
 //#endregion
-//#region ../slate-bridge/dist/goldens-BiX3rFo-.mjs
+//#region ../slate-bridge/dist/goldens-CEuJ0Yli.mjs
 const nonEmptyStringSchema = string$3().trim().min(1);
 const portSchema = number$3().int().min(0).max(65535).default(7777);
 const envSchema = object$4({
@@ -83905,7 +86512,7 @@ const envSchema = object$4({
 	CTX_PLATFORM_URL: url().default("http://127.0.0.1:3010").transform((url) => url.replace(/\/+$/, "")),
 	CTX_WEB_URL: url().default("http://localhost:3000").transform((url) => url.replace(/\/+$/, "")),
 	CTXS_BRIDGE_PORT: portSchema,
-	CTXS_CLAUDE_IMAGE: nonEmptyStringSchema.default("ghcr.io/usecontextlayer/ctx-sandbox:0.5.14"),
+	CTXS_CLAUDE_IMAGE: nonEmptyStringSchema.default("ghcr.io/usecontextlayer/ctx-sandbox:0.5.16"),
 	CTXS_CLAUDE_MODEL: nonEmptyStringSchema.default("opus"),
 	CTXS_HOST_CLAUDE_JSON_PATH: nonEmptyStringSchema.default(() => path.join(os.homedir(), ".claude.json")),
 	NODE_ENV: _enum$1([
@@ -83942,6 +86549,30 @@ You are working in the user's workspace: a directory of documents that is also a
 Do this bookkeeping quietly. Don't narrate routine git operations — mention git only when something needs the user's attention: a conflict, a rejected push you cannot heal, or work you found and preserved.
 
 The workspace's synced source data — email, meetings, tasks, whatever the user connected — lives in a Postgres database called the base. Query it with the \`ctxb\` CLI, following the contextbase skill. \`CTXB_DATABASE_URL\` is already set when this workspace has a base; if it is unset, no base is connected. Answer data questions from the base, not from memory.`;
+const BUILTIN_ALLOWED_TOOLS = [
+	"Agent",
+	"AskUserQuestion",
+	"Bash",
+	"BashOutput",
+	"Edit",
+	"EnterPlanMode",
+	"ExitPlanMode",
+	"Glob",
+	"Grep",
+	"KillShell",
+	"ListMcpResources",
+	"MultiEdit",
+	"NotebookEdit",
+	"Read",
+	"ReadMcpResource",
+	"Skill",
+	"SlashCommand",
+	"Task",
+	"TodoWrite",
+	"WebFetch",
+	"WebSearch",
+	"Write"
+];
 const CLAUDE_ARGS = [
 	"--input-format",
 	"stream-json",
@@ -83955,31 +86586,6 @@ const CLAUDE_ARGS = [
 	"summarized",
 	"--permission-mode",
 	"default",
-	"--allowedTools",
-	[
-		"Agent",
-		"AskUserQuestion",
-		"Bash",
-		"BashOutput",
-		"Edit",
-		"EnterPlanMode",
-		"ExitPlanMode",
-		"Glob",
-		"Grep",
-		"KillShell",
-		"ListMcpResources",
-		"MultiEdit",
-		"NotebookEdit",
-		"Read",
-		"ReadMcpResource",
-		"Skill",
-		"SlashCommand",
-		"Task",
-		"TodoWrite",
-		"WebFetch",
-		"WebSearch",
-		"Write"
-	].join(","),
 	"--permission-prompt-tool",
 	"stdio",
 	"--append-system-prompt-file",
@@ -83991,9 +86597,13 @@ function resolveChatBaseId(baseIds, workspaceId) {
 	return baseId;
 }
 function buildChatSpawnPlan(input) {
+	const { allowedTools, disallowedTools } = input.mcpToolRules;
 	return {
 		args: [
 			...CLAUDE_ARGS,
+			"--allowedTools",
+			[...BUILTIN_ALLOWED_TOOLS, ...allowedTools].join(","),
+			...disallowedTools.length > 0 ? ["--disallowedTools", disallowedTools.join(",")] : [],
 			...input.mcpConfigArgs ?? [],
 			"--model",
 			input.model,
@@ -84007,6 +86617,47 @@ function buildChatSpawnPlan(input) {
 		}
 	};
 }
+/** Wait for every promise before propagating the first rejection in input order. */
+async function joinAll(promises) {
+	const failed = (await Promise.allSettled(promises)).find((result) => result.status === "rejected");
+	if (failed !== void 0) throw failed.reason;
+}
+function liveChatKey(repoId, sessionId) {
+	return `${repoId}\n${sessionId}`;
+}
+/**
+* Delete one chat session: stop whatever is live on it, then drop its transcript from the
+* claude home and snapshot the removal. Returns false when the home holds no such
+* transcript — a chat the user opened but never sent a turn in, which is a legitimate
+* no-op rather than a failure. THROWS when the home cannot be made local or the removal
+* cannot be pushed; a rejection means remote deletion was not proven, and the caller must
+* not report success.
+*
+* THE ORDER IS THE WHOLE FUNCTION, and every step is here because skipping it makes the
+* delete silently undo itself:
+*  1. `stop()` every live connection on this chat — request the terminal client signal and
+*     abort its claude work. A connection deleted before its socket opens delivers the signal
+*     on open.
+*  2. join every `done` — a connection that reached a turn may fire a final `capture()`
+*     after disposal. Remove the file before that lands and the capture pushes it straight
+*     back; worse, a guest still running re-creates the transcript outright. The settled
+*     join waits for every writer before propagating a teardown failure.
+*  3. `restore()` — the delete may be this process's first contact with the home. The
+*     sidebar lists chats from pggit, not from the host dir, so deleting a chat you never
+*     opened is the NORMAL path; without this the removal finds an empty dir, reports
+*     "nothing here", and the chat survives. After the join, so the clone never lands on a
+*     dir a guest is writing.
+*  4. `settle()` — drain the capture chain, so nothing already queued pushes after the rm.
+*  5. `removeTranscript` — rm + capture, the git half. Steps 1-4 are exactly the
+*     precondition it documents and cannot check for itself.
+*/
+async function deleteChatSession(input) {
+	for (const liveChatSession of input.liveChatSessions) liveChatSession.stop();
+	await joinAll(input.liveChatSessions.map((liveChatSession) => liveChatSession.done));
+	await input.claudeRepo.restore();
+	await input.claudeRepo.settle();
+	return input.claudeRepo.removeTranscript(input.sessionId);
+}
 function createProviderTokenClient(config) {
 	const fetchImpl = config.fetchImpl ?? fetch;
 	const redeemUrl = `${config.webUrl}/api/auth/provider-token`;
@@ -84053,17 +86704,57 @@ async function resolveMcpMounts(input) {
 	}
 	return mounts;
 }
+function sanitizeNameSegment(segment) {
+	return segment.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function mcpToolRuleName(serverName, wireToolName) {
+	return `mcp__${sanitizeNameSegment(serverName)}__${sanitizeNameSegment(wireToolName)}`;
+}
+function compileToolRules(input) {
+	const declared = /* @__PURE__ */ new Set();
+	const allowedTools = [];
+	for (const [tool, config] of Object.entries(input.enabledTools)) {
+		declared.add(tool);
+		if (config.autoAllow) allowedTools.push(mcpToolRuleName(input.serverName, tool));
+	}
+	const missing = new Set(declared);
+	const disallowedTools = [];
+	for (const tool of input.census) {
+		missing.delete(tool);
+		if (!declared.has(tool)) disallowedTools.push(mcpToolRuleName(input.serverName, tool));
+	}
+	if (missing.size > 0) throw new Error(`mcp server '${input.serverName}': enabledTools name(s) the server does not expose: ${[...missing].join(", ")} — the manifest is stale against the live census.`);
+	return {
+		allowedTools,
+		disallowedTools
+	};
+}
 function isServableMount(mount) {
 	return mount.bindingAuth.type === "authenticated_account";
 }
 function unknownModuleError(mount, moduleName) {
 	return /* @__PURE__ */ new Error(`MCP server '${mount.serverName}' names module '${moduleName}', which this bridge build does not carry.`);
 }
+async function listToolCensus(transport) {
+	const client = new Client({
+		name: "slate-bridge-census",
+		version: "0.0.0"
+	});
+	await client.connect(transport);
+	try {
+		const page = await client.listTools();
+		if (page.nextCursor !== void 0) throw new Error("mcp census: server paginates tools/list; census pagination is not built");
+		return page.tools.map((tool) => tool.name);
+	} finally {
+		await client.close();
+	}
+}
 function createMcpGateway(input) {
 	const sessions = /* @__PURE__ */ new Map();
 	const providerToken = createProviderTokenClient({ webUrl: input.webUrl });
+	const moduleFactories = new Map(Object.entries(input.moduleServers));
 	const moduleMounts = /* @__PURE__ */ new Map();
-	for (const [moduleName, createServer] of Object.entries(input.moduleServers)) {
+	for (const [moduleName, createServer] of moduleFactories) {
 		const moduleApp = new Hono();
 		moduleApp.all("*", async (c) => {
 			const transport = new StreamableHTTPTransport();
@@ -84142,6 +86833,49 @@ function createMcpGateway(input) {
 		registerSession: (sessionToken, session) => {
 			sessions.set(sessionToken, session);
 		},
+		resolveGuestMcpPlan: async (mounts, session) => {
+			const serverNames = [];
+			const allowedTools = [];
+			const disallowedTools = [];
+			for (const mount of mounts) {
+				let census;
+				if (mount.server.type === "http") {
+					const lease = await providerToken.redeem({
+						accountId: mount.bindingAuth.accountId,
+						providerId: mount.bindingAuth.providerId,
+						refresh: false,
+						userToken: session.userToken
+					});
+					const transport = new StreamableHTTPClientTransport(new URL(mount.server.url), { requestInit: { headers: { authorization: `Bearer ${lease.accessToken}` } } });
+					try {
+						census = await listToolCensus(transport);
+					} catch (error) {
+						throw new Error(`census for mcp server '${mount.serverName}' failed against ${mount.server.url}`, { cause: error });
+					}
+				} else {
+					const factory = moduleFactories.get(mount.server.module);
+					if (factory === void 0) throw unknownModuleError(mount, mount.server.module);
+					const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+					await factory().connect(serverTransport);
+					census = await listToolCensus(clientTransport);
+				}
+				const rules = compileToolRules({
+					census,
+					enabledTools: mount.server.enabledTools,
+					serverName: mount.serverName
+				});
+				serverNames.push(mount.serverName);
+				allowedTools.push(...rules.allowedTools);
+				disallowedTools.push(...rules.disallowedTools);
+			}
+			return {
+				serverNames,
+				toolRules: {
+					allowedTools,
+					disallowedTools
+				}
+			};
+		},
 		selectServableMounts: selectServable
 	};
 }
@@ -84157,6 +86891,7 @@ function registerMcpGatewayRoutes(app, gateway) {
 function buildMcpConfigArgs(input) {
 	if (input.serverNames.length === 0) return [];
 	const mcpServers = Object.fromEntries(input.serverNames.map((serverName) => [serverName, {
+		alwaysLoad: true,
 		headers: { Authorization: `Bearer ${input.sessionToken}` },
 		type: "http",
 		url: rewriteHostUrlForGuest(`${input.bridgeOrigin}/bridge/mcp/${serverName}`)
@@ -84196,17 +86931,14 @@ async function createClaudeMicrosandbox(options) {
 	});
 	await ensureHostFilesystemReady(bootConfig.bindMounts);
 	const { guestMemory, sandbox } = await bootSandbox(await import("microsandbox"), bootConfig);
-	let disposed = false;
+	let disposePromise = null;
 	return {
-		dispose: async () => {
-			if (disposed) return;
-			disposed = true;
-			guestMemory.stop();
-			try {
-				await sandbox.stopWithTimeout(SANDBOX_STOP_TIMEOUT_MS);
-			} catch (error) {
-				console.error("[slate-bridge] sandbox stop failed:", error);
+		dispose: () => {
+			if (disposePromise === null) {
+				guestMemory.stop();
+				disposePromise = sandbox.stopWithTimeout(SANDBOX_STOP_TIMEOUT_MS);
 			}
+			return disposePromise;
 		},
 		guestMemory: () => guestMemory.read(),
 		spawn: (spawnOptions) => spawnClaudeProcess(sandbox, spawnOptions)
@@ -84506,6 +87238,31 @@ var WorkspaceDocsCache = class {
 	}
 };
 (0, import_undici.setGlobalDispatcher)(new import_undici.Agent({ allowH2: false }));
+const CHAT_HOME_CONFIG = {
+	maintainIndex: true,
+	restore: true,
+	watch: HOME_WATCH_CONFIG
+};
+const CHAT_SESSION_PATH_SCHEMA = strictObject({
+	sessionId: string$3().uuid(),
+	workspaceId: string$3().uuid()
+});
+async function resolveClaudeHomeRepo(input) {
+	const repoId = buildRepoId({
+		kind: "claude",
+		owner: "slate",
+		userId: input.sub,
+		workspaceId: input.workspaceId
+	});
+	return {
+		claudeRepo: ClaudeRepo.get(await resolveRepo({
+			platformUrl: input.platformUrl,
+			repoId,
+			token: input.token
+		}, input.gitHostBaseDir), CHAT_HOME_CONFIG),
+		repoId
+	};
+}
 function bearerToken(c) {
 	const header = c.req.header("Authorization") ?? "";
 	return header.startsWith("Bearer ") ? header.slice(7) : "";
@@ -84543,7 +87300,7 @@ function wsReject(code, reason) {
 		wsCtx.close(code, reason);
 	} };
 }
-function wsFailClose(ws, code, reason) {
+function wsCloseWithErrorFrame(ws, code, reason) {
 	if (ws === null || ws.readyState !== WebSocket.OPEN) return;
 	ws.send(`${JSON.stringify({
 		reason,
@@ -84573,6 +87330,8 @@ async function createBridgeServer(opts) {
 	});
 	let boundPort = 0;
 	const inflight = /* @__PURE__ */ new Set();
+	const liveChatSessions = /* @__PURE__ */ new Set();
+	const chatDeletionPromises = /* @__PURE__ */ new Map();
 	const docsCache = new WorkspaceDocsCache();
 	const app = new Hono();
 	const wss = new WebSocketServer({ noServer: true });
@@ -84628,32 +87387,71 @@ async function createBridgeServer(opts) {
 			return c.text(err instanceof Error ? err.message : String(err), 400);
 		}
 	});
+	app.delete("/bridge/workspaces/:workspaceId/sessions/:id", renderAuth, async (c) => {
+		const sub = c.get("sub");
+		if (!sub) return c.text("chat sessions are user-scoped", 403);
+		const parsedPath = CHAT_SESSION_PATH_SCHEMA.safeParse({
+			sessionId: c.req.param("id"),
+			workspaceId: c.req.param("workspaceId")
+		});
+		if (!parsedPath.success) return c.text(prettifyError(parsedPath.error), 400);
+		const { sessionId, workspaceId } = parsedPath.data;
+		try {
+			const { claudeRepo, repoId } = await resolveClaudeHomeRepo({
+				gitHostBaseDir,
+				platformUrl,
+				sub,
+				token: bearerToken(c),
+				workspaceId
+			});
+			const key = liveChatKey(repoId, sessionId);
+			let deletionPromise = chatDeletionPromises.get(key);
+			if (deletionPromise === void 0) {
+				deletionPromise = deleteChatSession({
+					claudeRepo,
+					liveChatSessions: [...liveChatSessions].filter((liveChatSession) => liveChatSession.key === key),
+					sessionId
+				});
+				chatDeletionPromises.set(key, deletionPromise);
+				deletionPromise.then(() => chatDeletionPromises.delete(key), () => chatDeletionPromises.delete(key));
+			}
+			await deletionPromise;
+			return c.body(null, 204);
+		} catch (err) {
+			console.error(`[slate-bridge] chat delete failed (${sessionId}):`, err);
+			Sentry.captureException(err, { extra: {
+				sessionId,
+				workspaceId
+			} });
+			return c.text(err instanceof Error ? err.message : String(err), 500);
+		}
+	});
 	app.get("/bridge/workspaces/:workspaceId/sessions/:id/wss", upgradeWebSocket(async (c) => {
-		const workspaceId = c.req.param("workspaceId") ?? "";
-		const sessionId = c.req.param("id") ?? "";
 		const userToken = c.req.query("token") ?? "";
 		const r = await verify(userToken);
 		if (!r.ok) return wsReject(4401, "unauthorized");
 		if (r.kind !== "user") return wsReject(4403, "forbidden: machine token");
-		const repoId = buildRepoId({
-			kind: "claude",
-			owner: "slate",
-			userId: r.sub,
-			workspaceId
+		if (!r.sub) return wsReject(4403, "forbidden: empty user identity");
+		const parsedPath = CHAT_SESSION_PATH_SCHEMA.safeParse({
+			sessionId: c.req.param("id"),
+			workspaceId: c.req.param("workspaceId")
 		});
-		const claudeRepo = ClaudeRepo.get(await resolveRepo({
+		if (!parsedPath.success) return wsReject(4400, "invalid chat session path");
+		const { sessionId, workspaceId } = parsedPath.data;
+		const { claudeRepo, repoId } = await resolveClaudeHomeRepo({
+			gitHostBaseDir,
 			platformUrl,
-			repoId,
-			token: userToken
-		}, gitHostBaseDir), {
-			maintainIndex: true,
-			restore: true,
-			watch: HOME_WATCH_CONFIG
+			sub: r.sub,
+			token: userToken,
+			workspaceId
 		});
+		const key = liveChatKey(repoId, sessionId);
+		if (chatDeletionPromises.has(key)) return wsReject(4410, "session deletion in progress");
 		if (!claudeRepo.tryAcquireSession(sessionId)) return wsReject(4409, "session already in use by another connection");
 		const earlyBuffer = [];
 		let stdin = null;
 		let ws = null;
+		let deletionRequested = false;
 		const ac = new AbortController();
 		const work = (async () => {
 			console.log("[slate-bridge] connection opened");
@@ -84684,12 +87482,16 @@ async function createBridgeServer(opts) {
 				});
 				const { servable: servableMounts, skipped: skippedMounts } = mcpGateway.selectServableMounts(mcpMounts);
 				for (const mount of skippedMounts) console.warn(`[slate-bridge] skipping MCP server '${mount.serverName}' (plugin '${mount.pluginId}'): binding auth '${mount.bindingAuth.type}' is not 'authenticated_account' — excluded until the binding is flipped to a linked account; chat continues without it.`);
+				const guestMcpPlan = await mcpGateway.resolveGuestMcpPlan(servableMounts, {
+					userToken,
+					workspaceId
+				});
+				if (ac.signal.aborted) return;
 				mcpSessionToken = randomUUID();
 				mcpGateway.registerSession(mcpSessionToken, {
 					userToken,
 					workspaceId
 				});
-				if (ac.signal.aborted) return;
 				session = await createClaudeMicrosandbox({
 					claudeHomeHostDir: claudeRepo.hostDir,
 					hostClaudeJsonPath,
@@ -84714,9 +87516,10 @@ async function createBridgeServer(opts) {
 					},
 					mcpConfigArgs: buildMcpConfigArgs({
 						bridgeOrigin: `http://127.0.0.1:${boundPort}`,
-						serverNames: servableMounts.map((mount) => mount.serverName),
+						serverNames: guestMcpPlan.serverNames,
 						sessionToken: mcpSessionToken
 					}),
+					mcpToolRules: guestMcpPlan.toolRules,
 					model: plan.model ?? defaultModel,
 					sessionFlag
 				});
@@ -84745,20 +87548,43 @@ async function createBridgeServer(opts) {
 				const guestMemory = session?.guestMemory();
 				console.error("[slate-bridge] connection handler error:", err, { guestMemory });
 				Sentry.captureException(err, { extra: { guestMemory } });
-				if (phase === "boot") wsFailClose(ws, 4500, "session boot failed");
-				else wsFailClose(ws, 4501, "session turn failed");
+				if (phase === "boot") wsCloseWithErrorFrame(ws, 4500, "session boot failed");
+				else wsCloseWithErrorFrame(ws, 4501, "session turn failed");
 			} finally {
 				claudeRepo.releaseSession(sessionId);
 				ac.abort();
-				if (session) await session.dispose();
-				if (mcpSessionToken) mcpGateway.deregisterSession(mcpSessionToken);
-				if (phase === "turn") claudeRepo.capture({ message: `chat ${repoId} (final)` });
-				await claudeRepo.settle();
+				try {
+					if (session) await session.dispose();
+					if (phase === "turn") claudeRepo.capture({ message: `chat ${repoId} (final)` }).catch((err) => {
+						console.error(`[slate-bridge] final capture failed (${repoId}):`, err);
+					});
+				} finally {
+					if (mcpSessionToken) mcpGateway.deregisterSession(mcpSessionToken);
+					await claudeRepo.settle();
+				}
 				console.log("[slate-bridge] connection closed");
 			}
 		})();
 		inflight.add(work);
-		work.finally(() => inflight.delete(work));
+		const liveChatSession = {
+			done: work,
+			key,
+			stop: () => {
+				deletionRequested = true;
+				wsCloseWithErrorFrame(ws, 4410, "session deleted");
+				ac.abort();
+			}
+		};
+		liveChatSessions.add(liveChatSession);
+		const forgetLiveChatSession = () => {
+			inflight.delete(work);
+			liveChatSessions.delete(liveChatSession);
+		};
+		work.then(forgetLiveChatSession, (err) => {
+			forgetLiveChatSession();
+			console.error("[slate-bridge] connection teardown error:", err);
+			Sentry.captureException(err);
+		});
 		return {
 			onClose() {
 				claudeRepo.releaseSession(sessionId);
@@ -84774,6 +87600,7 @@ async function createBridgeServer(opts) {
 			},
 			onOpen(_evt, wsCtx) {
 				ws = wsCtx;
+				if (deletionRequested) wsCloseWithErrorFrame(wsCtx, 4410, "session deleted");
 			}
 		};
 	}));
@@ -84791,6 +87618,7 @@ async function createBridgeServer(opts) {
 	boundPort = address.port;
 	return {
 		async close() {
+			const closingConnections = [...inflight];
 			for (const client of wss.clients) client.close(1001, "server shutting down");
 			await new Promise((resolve, reject) => {
 				wss.close((err) => err ? reject(err) : resolve());
@@ -84798,7 +87626,7 @@ async function createBridgeServer(opts) {
 			await new Promise((resolve, reject) => {
 				server.close((err) => err ? reject(err) : resolve());
 			});
-			await Promise.all([...inflight]);
+			await joinAll(closingConnections);
 		},
 		port: boundPort
 	};
@@ -88924,7 +91752,7 @@ function createProgram() {
 	program.command("bridge").description("Slate bridge commands").command("start").description("Start the slate bridge server in the foreground, bound to localhost on CTXS_BRIDGE_PORT (default 7777). Authenticates each connection's aud=ctx user token and resolves its workspace + credentials from the platform (CTX_WEB_URL verifies the token, CTX_PLATFORM_URL serves the plan + base DSN); serves the render endpoints + the per-session WebSocket that spawns claude inside a microsandbox sandbox. Blocks until SIGINT/SIGTERM.").action(async () => {
 		await createBridgeServer({});
 	});
-	program.command("parity").description("Translator parity golden tooling (dev/maintainer)").command("generate [scenarios...]").description("Drive scripted multi-turn conversations through the real bridge + microsandbox + claude and (re)write the parity goldens consumed by slate-shared's parity test. Pass scenario names to capture only those (others keep their existing goldens); omit to regenerate all. Dev tool: needs local claude auth and the microsandbox runtime. Run from source ('npx tsx cli.ts parity generate [names...]').").action(async (scenarios) => {
+	program.command("parity").description("Translator parity golden tooling (dev/maintainer)").command("generate [scenarios...]").description("Drive scripted multi-turn conversations through the real bridge + microsandbox + claude and (re)write the parity goldens consumed by slate-shared's parity test. Pass scenario names to capture only those (others keep their existing goldens); omit to regenerate all. Dev tool: needs local claude auth and the microsandbox runtime. Run from source ('node --import tsx cli.ts parity generate [names...]').").action(async (scenarios) => {
 		await generateParityGoldens({ only: scenarios });
 	});
 	program.command("sandbox").allowUnknownOption(true).allowExcessArguments(true).argument("[command...]", "Command + args to run in the guest (default: uname -a)").requiredOption("--image <ref>", "Guest image to boot in the microVM").description("Boot a microsandbox microVM from --image, run a command inside it, print its output, and tear it down. A DB-free check that the host can boot guest microVMs (/dev/kvm in a container; HVF on macOS).").action(async (command, options) => {
@@ -88950,4 +91778,4 @@ runCli().catch((error) => {
 //#endregion
 export { createProgram, runCli };
 //# sourceMappingURL=cli.mjs.map
-//# debugId=1fde104d-ada4-505b-9cff-03f35e9d5ed1
+//# debugId=3bf0713e-bd74-5249-b278-e30de2c2d243