@qodercn-ai/qmind-cli 3.0.0

package/dist/qmind.js

@@ -0,0 +1,4696 @@
+import { $ as executeStream, A as retrieveResultSchema, B as sourceTreeSchema, C as chatSessionListSchema, E as imageUrlsSchema, F as sourceImportResultsSchema, G as streamWireEventSchema, H as sourceUploadTicketSchema, I as sourceListSchema, J as voidResponseSchema, K as taskRunListSchema, L as sourcePreviewSchema, M as sourceActionAccessSchema, N as sourceChildrenCountsSchema, O as notebookListSchema, P as sourceContentSchema, Q as assertCapability, R as sourceRawContentSchema, S as chatMessageListSchema, T as imageUploadTicketSchema, U as sourceWebOfficeSessionSchema, V as sourceUploadCapabilitiesSchema, W as sourceWebOfficeTokenSchema, X as QMIND_MULTIPART_UPLOAD_MAX_BYTES, Y as wikiBranchListSchema, Z as QMIND_SOURCE_UPLOAD_MAX_BYTES, a as invalidArgument$1, c as optionalRecord, d as pagination$1, et as executeUnary, f as positiveInteger$1, h as stringList, i as httpUrl, j as sharedNotebookListSchema, k as notebookSchema, l as optionalString$1, m as requiredString$2, n as call, o as nonNegativeInteger$1, p as queryPath, q as taskRunSchema, r as compactUndefined, s as optionalBoolean, t as assertNonEmptyPatch, tt as QMindError, u as optionalTrimmedString, v as batchMutationResultSchema, w as chatSessionSchema, y as cancelQuestionResultSchema, z as sourceSchema } from "./shared-DwycozMA.js";
+import { createInterface } from "node:readline/promises";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+import { createHash, randomBytes } from "node:crypto";
+import { chmod, copyFile, link, lstat, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import lockfile from "proper-lockfile";
+import open from "open";
+import { createReadStream, createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createParser } from "eventsource-parser";
+import { Agent, EnvHttpProxyAgent, request } from "undici";
+import { Command, CommanderError, Option } from "commander";
+import pLimit from "p-limit";
+import picomatch from "picomatch";
+import { decodeHTML } from "entities";
+//#region ../sdk/src/operations/agents.ts
+const workflowPrompt = "Follow the system prompt strictly: use the provided tools to discover, process and prepare the result, then emit the final report. Do NOT greet, do NOT ask for clarification — act immediately.";
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finiteNumber(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw invalidArgument$1(`${field} must be a finite number`, field);
+	return value;
+}
+function queryHints(value) {
+	const input = optionalRecord(value, "queryHints");
+	if (input === void 0) return void 0;
+	return compactUndefined({
+		intent: optionalTrimmedString(input.intent, "queryHints.intent"),
+		keywords: input.keywords === void 0 ? void 0 : stringList(input.keywords, "queryHints.keywords"),
+		language: optionalTrimmedString(input.language, "queryHints.language"),
+		queryVariants: input.queryVariants === void 0 ? void 0 : stringList(input.queryVariants, "queryHints.queryVariants"),
+		rewrittenQuery: optionalTrimmedString(input.rewrittenQuery, "queryHints.rewrittenQuery")
+	});
+}
+function businessContext(value) {
+	const input = optionalRecord(value, "billingContext.business");
+	if (input === void 0) return void 0;
+	const beginAt = input.beginAt;
+	if (beginAt !== void 0 && (typeof beginAt !== "number" || !Number.isSafeInteger(beginAt))) throw invalidArgument$1("billingContext.business.beginAt must be a safe integer", "beginAt");
+	return compactUndefined({
+		beginAt,
+		id: optionalTrimmedString(input.id, "billingContext.business.id"),
+		name: optionalTrimmedString(input.name, "billingContext.business.name"),
+		product: optionalTrimmedString(input.product, "billingContext.business.product"),
+		stage: optionalTrimmedString(input.stage, "billingContext.business.stage"),
+		type: optionalTrimmedString(input.type, "billingContext.business.type"),
+		version: optionalTrimmedString(input.version, "billingContext.business.version")
+	});
+}
+function billingContext(value) {
+	const input = optionalRecord(value, "billingContext");
+	if (input === void 0) return void 0;
+	return compactUndefined({
+		business: businessContext(input.business),
+		modelKey: optionalTrimmedString(input.modelKey, "billingContext.modelKey"),
+		sessionId: optionalTrimmedString(input.sessionId, "billingContext.sessionId")
+	});
+}
+function retrieveBody(input) {
+	if (!isRecord$3(input)) throw invalidArgument$1("input must be an object", "input");
+	return compactUndefined({
+		billingContext: billingContext(input.billingContext),
+		maxResults: nonNegativeInteger$1(input.maxResults, "maxResults"),
+		query: requiredString$2(input.query, "query"),
+		queryHints: queryHints(input.queryHints),
+		scoreThreshold: finiteNumber(input.scoreThreshold, "scoreThreshold"),
+		sourceIds: stringList(input.sourceIds ?? [], "sourceIds"),
+		topK: nonNegativeInteger$1(input.topK, "topK")
+	});
+}
+function chatSessionBody(input = {}) {
+	if (!isRecord$3(input)) throw invalidArgument$1("input must be an object", "input");
+	return compactUndefined({
+		metadata: optionalRecord(input.metadata, "metadata"),
+		modelOverride: optionalTrimmedString(input.modelOverride, "modelOverride"),
+		sceneType: optionalTrimmedString(input.sceneType, "sceneType") ?? "rag",
+		status: optionalTrimmedString(input.status, "status"),
+		title: optionalString$1(input.title, "title")
+	});
+}
+function streamBody(input) {
+	if (!isRecord$3(input)) throw invalidArgument$1("input must be an object", "input");
+	return compactUndefined({
+		content: requiredString$2(input.content, "content"),
+		maxResults: nonNegativeInteger$1(input.maxResults, "maxResults"),
+		modelOverride: optionalTrimmedString(input.modelOverride, "modelOverride"),
+		sceneType: optionalTrimmedString(input.sceneType, "sceneType"),
+		sourceIds: stringList(input.sourceIds ?? [], "sourceIds"),
+		topK: nonNegativeInteger$1(input.topK, "topK")
+	});
+}
+function taskRunBody(input) {
+	if (!isRecord$3(input)) throw invalidArgument$1("input must be an object", "input");
+	return compactUndefined({
+		chatSessionId: optionalTrimmedString(input.chatSessionId, "chatSessionId"),
+		config: optionalRecord(input.config, "config"),
+		parentRunId: optionalTrimmedString(input.parentRunId, "parentRunId"),
+		sceneType: requiredString$2(input.sceneType, "sceneType"),
+		settings: optionalRecord(input.settings, "settings"),
+		sourceId: optionalTrimmedString(input.sourceId, "sourceId"),
+		scheduledTaskId: optionalTrimmedString(input.scheduledTaskId, "scheduledTaskId"),
+		trigger: optionalTrimmedString(input.trigger, "trigger")
+	});
+}
+function taskRunListPath(context, notebookId, input = {}) {
+	if (!isRecord$3(input)) throw invalidArgument$1("input must be an object", "input");
+	const normalizedPage = pagination$1(input);
+	const status = optionalTrimmedString(input.status, "status");
+	if (status !== void 0 && ![
+		"pending",
+		"running",
+		"success",
+		"partial",
+		"failed",
+		"canceled"
+	].includes(status)) throw invalidArgument$1("status must be a known task run status", "status");
+	return queryPath(context.profile.apiPath("notebooks", notebookId, "task-runs"), [
+		["scheduled_task_id", optionalTrimmedString(input.scheduledTaskId, "scheduledTaskId")],
+		["parent_run_id", optionalTrimmedString(input.parentRunId, "parentRunId")],
+		["scene_type", optionalTrimmedString(input.sceneType, "sceneType")],
+		["source_id", optionalTrimmedString(input.sourceId, "sourceId")],
+		["trigger", optionalTrimmedString(input.trigger, "trigger")],
+		["status", status],
+		["page", normalizedPage.page],
+		["page_size", normalizedPage.pageSize]
+	]);
+}
+function agentContent(input) {
+	if (input.scene === "rag") return {
+		content: requiredString$2(input.question, "question"),
+		maxResults: input.maxResults,
+		modelOverride: input.modelOverride,
+		sceneType: "rag",
+		sourceIds: input.sourceIds,
+		topK: input.topK
+	};
+	return {
+		content: `Begin the ${input.scene} workflow now for this notebook. ${workflowPrompt}`,
+		modelOverride: input.modelOverride,
+		sceneType: input.scene
+	};
+}
+function callOptions(options) {
+	return {
+		...options?.signal === void 0 ? {} : { signal: options.signal },
+		...options?.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+	};
+}
+function streamCallOptions(options) {
+	return {
+		...callOptions(options),
+		...options?.connectTimeoutMs === void 0 ? {} : { connectTimeoutMs: options.connectTimeoutMs },
+		...options?.idleTimeoutMs === void 0 ? {} : { idleTimeoutMs: options.idleTimeoutMs }
+	};
+}
+function createAgentOperations(context) {
+	const createChatSessionFor = (notebookId, input, options, featured) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		return call(context, {
+			body: chatSessionBody(input),
+			callOptions: options,
+			capability: featured ? "featuredNotebooks.read" : "chat",
+			idempotent: false,
+			method: "POST",
+			operation: featured ? "featuredChatSessions.create" : "chatSessions.create",
+			path: context.profile.apiPath(featured ? "featured-notebooks" : "notebooks", notebook, "chat-sessions"),
+			schema: chatSessionSchema
+		});
+	};
+	const createChatSession = (notebookId, input, options) => createChatSessionFor(notebookId, input, options, false);
+	const createFeaturedChatSession = (notebookId, input, options) => createChatSessionFor(notebookId, input, options, true);
+	const streamQuestionFor = (notebookId, sessionId, input, options, featured) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const session = requiredString$2(sessionId, "sessionId");
+		return executeStream({
+			capability: featured ? "featuredNotebooks.read" : "chat",
+			operation: featured ? "featuredChat.stream" : "chat.stream",
+			profile: context.profile,
+			request: {
+				body: {
+					kind: "json",
+					value: streamBody(input)
+				},
+				destination: {
+					kind: "host",
+					path: queryPath(context.profile.apiPath(featured ? "featured-notebooks" : "notebooks", notebook, "chat-sessions", session, "messages", "stream"), [["client", context.client]])
+				},
+				idempotent: false,
+				method: "POST",
+				...streamCallOptions(options)
+			},
+			transport: context.transport
+		});
+	};
+	const streamQuestion = (notebookId, sessionId, input, options) => streamQuestionFor(notebookId, sessionId, input, options, false);
+	const streamFeaturedQuestion = (notebookId, sessionId, input, options) => streamQuestionFor(notebookId, sessionId, input, options, true);
+	const cancelQuestionFor = (notebookId, sessionId, input = {}, options, featured = false) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const session = requiredString$2(sessionId, "sessionId");
+		if (!isRecord$3(input)) throw invalidArgument$1("input must be an object", "input");
+		return call(context, {
+			body: compactUndefined({ reason: optionalTrimmedString(input.reason, "reason") }),
+			callOptions: options,
+			capability: featured ? "featuredNotebooks.read" : "chat",
+			idempotent: false,
+			method: "POST",
+			operation: featured ? "featuredChat.cancel" : "chat.cancel",
+			path: context.profile.apiPath(featured ? "featured-notebooks" : "notebooks", notebook, "chat-sessions", session, "messages", "cancel"),
+			schema: cancelQuestionResultSchema
+		});
+	};
+	const listChatSessionsFor = (notebookId, input = {}, options, featured = false) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const normalizedPage = pagination$1({
+			page: input.page ?? 1,
+			pageSize: input.pageSize ?? 20
+		});
+		return call(context, {
+			callOptions: options,
+			capability: featured ? "featuredNotebooks.read" : "chat",
+			idempotent: true,
+			method: "GET",
+			operation: featured ? "featuredChatSessions.list" : "chatSessions.list",
+			path: queryPath(context.profile.apiPath(featured ? "featured-notebooks" : "notebooks", notebook, "chat-sessions"), [["page", normalizedPage.page], ["page_size", normalizedPage.pageSize]]),
+			schema: chatSessionListSchema
+		});
+	};
+	const listChatMessagesFor = (notebookId, sessionId, input = {}, options, featured = false) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const session = requiredString$2(sessionId, "sessionId");
+		const normalizedPage = pagination$1({
+			page: input.page ?? 1,
+			pageSize: input.pageSize ?? 100
+		});
+		return call(context, {
+			callOptions: options,
+			capability: featured ? "featuredNotebooks.read" : "chat",
+			idempotent: true,
+			method: "GET",
+			operation: featured ? "featuredChatMessages.list" : "chatMessages.list",
+			path: queryPath(context.profile.apiPath(featured ? "featured-notebooks" : "notebooks", notebook, "chat-sessions", session, "messages"), [["page", normalizedPage.page], ["page_size", normalizedPage.pageSize]]),
+			schema: chatMessageListSchema
+		});
+	};
+	const deleteChatSessionFor = (notebookId, sessionId, options, featured = false) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const session = requiredString$2(sessionId, "sessionId");
+		return call(context, {
+			callOptions: options,
+			capability: featured ? "featuredNotebooks.read" : "chat",
+			idempotent: false,
+			method: "DELETE",
+			operation: featured ? "featuredChatSessions.delete" : "chatSessions.delete",
+			path: context.profile.apiPath(featured ? "featured-notebooks" : "notebooks", notebook, "chat-sessions", session),
+			schema: voidResponseSchema
+		});
+	};
+	const startAgentRunFor = async (notebookId, input, options, featured) => {
+		if (!isRecord$3(input)) throw invalidArgument$1("input must be an object", "input");
+		if (input.scene !== "rag" && input.scene !== "compilation" && input.scene !== "lint") throw invalidArgument$1("scene must be rag, compilation or lint", "scene");
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const scene = input.scene;
+		const modelOverride = optionalTrimmedString(input.modelOverride, "modelOverride");
+		const title = optionalString$1(input.title, "title");
+		const session = await (featured ? createFeaturedChatSession : createChatSession)(notebook, {
+			...modelOverride === void 0 ? {} : { modelOverride },
+			sceneType: scene,
+			...title === void 0 ? {} : { title }
+		}, options);
+		return {
+			events: (featured ? streamFeaturedQuestion : streamQuestion)(notebook, session.id, agentContent(input), options),
+			scene,
+			session
+		};
+	};
+	return {
+		cancelFeaturedQuestion: (notebookId, sessionId, input, options) => cancelQuestionFor(notebookId, sessionId, input, options, true),
+		cancelQuestion: (notebookId, sessionId, input, options) => cancelQuestionFor(notebookId, sessionId, input, options),
+		createChatSession,
+		createFeaturedChatSession,
+		deleteChatSession: (notebookId, sessionId, options) => deleteChatSessionFor(notebookId, sessionId, options),
+		deleteFeaturedChatSession: (notebookId, sessionId, options) => deleteChatSessionFor(notebookId, sessionId, options, true),
+		async createTaskRun(notebookId, input, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				body: taskRunBody(input),
+				callOptions: options,
+				capability: "taskRuns.write",
+				idempotent: false,
+				method: "POST",
+				operation: "taskRuns.create",
+				path: context.profile.apiPath("notebooks", notebook, "task-runs"),
+				schema: taskRunSchema
+			});
+		},
+		async getTaskRun(notebookId, runId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const run = requiredString$2(runId, "runId");
+			return call(context, {
+				callOptions: options,
+				capability: "taskRuns.read",
+				idempotent: true,
+				method: "GET",
+				operation: "taskRuns.get",
+				path: context.profile.apiPath("notebooks", notebook, "task-runs", run),
+				schema: taskRunSchema
+			});
+		},
+		async listTaskRuns(notebookId, input, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				callOptions: options,
+				capability: "taskRuns.read",
+				idempotent: true,
+				method: "GET",
+				operation: "taskRuns.list",
+				path: taskRunListPath(context, notebook, input),
+				schema: taskRunListSchema
+			});
+		},
+		listChatMessages: (notebookId, sessionId, input, options) => listChatMessagesFor(notebookId, sessionId, input, options),
+		listChatSessions: (notebookId, input, options) => listChatSessionsFor(notebookId, input, options),
+		listFeaturedChatMessages: (notebookId, sessionId, input, options) => listChatMessagesFor(notebookId, sessionId, input, options, true),
+		listFeaturedChatSessions: (notebookId, input, options) => listChatSessionsFor(notebookId, input, options, true),
+		async retrieve(notebookId, input, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				body: retrieveBody(input),
+				callOptions: options,
+				capability: "retrieval",
+				idempotent: false,
+				method: "POST",
+				operation: "retrieval.retrieve",
+				path: context.profile.apiPath("notebooks", notebook, "retrieve"),
+				schema: retrieveResultSchema
+			});
+		},
+		startAgentRun: (notebookId, input, options) => startAgentRunFor(notebookId, input, options, false),
+		startFeaturedAgentRun: (notebookId, input, options) => startAgentRunFor(notebookId, input, options, true),
+		streamFeaturedQuestion,
+		streamQuestion
+	};
+}
+//#endregion
+//#region ../sdk/src/operations/notebooks.ts
+function createNotebookOperations(context) {
+	return {
+		async createNotebook(input, options) {
+			const title = requiredString$2(input?.title, "title");
+			const description = optionalString$1(input?.description, "description");
+			const settings = optionalRecord(input?.settings, "settings");
+			return call(context, {
+				body: compactUndefined({
+					client: context.client,
+					description,
+					settings,
+					title
+				}),
+				callOptions: options,
+				capability: "notebooks.write",
+				idempotent: false,
+				method: "POST",
+				operation: "notebooks.create",
+				path: context.profile.apiPath("notebooks"),
+				schema: notebookSchema
+			});
+		},
+		async deleteNotebook(notebookId, options) {
+			const id = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				callOptions: options,
+				capability: "notebooks.write",
+				idempotent: false,
+				method: "DELETE",
+				operation: "notebooks.delete",
+				path: context.profile.apiPath("notebooks", id),
+				schema: voidResponseSchema
+			});
+		},
+		async getNotebook(notebookId, options) {
+			const id = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				callOptions: options,
+				capability: "notebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "notebooks.get",
+				path: context.profile.apiPath("notebooks", id),
+				schema: notebookSchema
+			});
+		},
+		async getFeaturedNotebook(notebookId, options) {
+			const id = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				callOptions: options,
+				capability: "featuredNotebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "featuredNotebooks.get",
+				path: context.profile.featuredNotebookPath(id),
+				schema: notebookSchema
+			});
+		},
+		async listFeaturedNotebooks(input = {}, options) {
+			const normalized = pagination$1(input);
+			return call(context, {
+				callOptions: options,
+				capability: "featuredNotebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "featuredNotebooks.list",
+				path: context.profile.listFeaturedNotebooksPath(normalized),
+				schema: notebookListSchema
+			});
+		},
+		async listNotebooks(input = {}, options) {
+			const normalizedPage = pagination$1(input);
+			const client = optionalTrimmedString(input.client, "client");
+			if (client !== void 0 && !context.profile.capabilities["notebooks.filterByClient"]) assertCapability(context.profile, "notebooks.filterByClient", "notebooks.list");
+			const normalized = {
+				...normalizedPage,
+				...client === void 0 ? {} : { client }
+			};
+			return call(context, {
+				callOptions: options,
+				capability: "notebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "notebooks.list",
+				path: context.profile.listNotebooksPath(normalized),
+				schema: notebookListSchema
+			});
+		},
+		async listSharedNotebooks(input = {}, options) {
+			const normalized = pagination$1(input);
+			return call(context, {
+				callOptions: options,
+				capability: "sharedNotebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "sharedNotebooks.list",
+				path: context.profile.listSharedNotebooksPath(normalized),
+				schema: sharedNotebookListSchema
+			});
+		},
+		async listWikiBranches(notebookId, options) {
+			const id = requiredString$2(notebookId, "notebookId");
+			return (await call(context, {
+				callOptions: options,
+				capability: "wikiBranches.read",
+				idempotent: true,
+				method: "GET",
+				operation: "wikiBranches.list",
+				path: context.profile.apiPath("notebooks", id, "wiki-branches"),
+				schema: wikiBranchListSchema
+			})).branches;
+		},
+		async updateNotebook(notebookId, input, options) {
+			const id = requiredString$2(notebookId, "notebookId");
+			const body = compactUndefined({
+				description: optionalString$1(input?.description, "description"),
+				settings: optionalRecord(input?.settings, "settings"),
+				status: optionalString$1(input?.status, "status"),
+				title: input?.title === void 0 ? void 0 : requiredString$2(input.title, "title")
+			});
+			assertNonEmptyPatch(body, "input");
+			return call(context, {
+				body,
+				callOptions: options,
+				capability: "notebooks.write",
+				idempotent: false,
+				method: "PUT",
+				operation: "notebooks.update",
+				path: context.profile.apiPath("notebooks", id),
+				schema: notebookSchema
+			});
+		}
+	};
+}
+//#endregion
+//#region ../sdk/src/operations/sources.ts
+const maxImageBytes = 52428800;
+function sourceTreeNodeOrder(left, right) {
+	if (left.type !== right.type) return left.type === "directory" ? -1 : 1;
+	if (left.name !== right.name) return left.name < right.name ? -1 : 1;
+	return left.id < right.id ? -1 : left.id === right.id ? 0 : 1;
+}
+function sortSourceTree(nodes) {
+	nodes.sort(sourceTreeNodeOrder);
+	for (const node of nodes) sortSourceTree(node.files);
+}
+function createsSourceCycle(source, sourcesById) {
+	const seen = /* @__PURE__ */ new Set([source.id]);
+	let parentId = source.parentSourceId;
+	while (parentId.length > 0) {
+		if (seen.has(parentId)) return true;
+		seen.add(parentId);
+		const parent = sourcesById.get(parentId);
+		if (parent === void 0) return false;
+		parentId = parent.parentSourceId;
+	}
+	return false;
+}
+function buildSourceTree(sources) {
+	const sourcesById = new Map(sources.map((source) => [source.id, source]));
+	const parentIds = new Set(sources.filter((source) => sourcesById.has(source.parentSourceId) && !createsSourceCycle(source, sourcesById)).map((source) => source.parentSourceId));
+	const nodesById = /* @__PURE__ */ new Map();
+	for (const source of sources) nodesById.set(source.id, {
+		files: [],
+		id: source.id,
+		name: source.title,
+		path: source.path,
+		sourceType: source.sourceType,
+		status: source.status,
+		type: source.isDir || parentIds.has(source.id) ? "directory" : "file"
+	});
+	const tree = [];
+	for (const source of sources) {
+		const node = nodesById.get(source.id);
+		if (node === void 0) continue;
+		const parent = nodesById.get(source.parentSourceId);
+		if (parent === void 0 || createsSourceCycle(source, sourcesById)) tree.push(node);
+		else parent.files.push(node);
+	}
+	sortSourceTree(tree);
+	return {
+		totalSize: sources.length,
+		tree
+	};
+}
+function sourceBody(input) {
+	return compactUndefined({
+		isDir: optionalBoolean(input?.isDir, "isDir"),
+		metadata: optionalRecord(input?.metadata, "metadata"),
+		parentSourceId: optionalString$1(input?.parentSourceId, "parentSourceId"),
+		path: optionalString$1(input?.path, "path"),
+		sourceType: optionalTrimmedString(input?.sourceType, "sourceType"),
+		status: optionalTrimmedString(input?.status, "status"),
+		title: requiredString$2(input?.title, "title"),
+		uri: optionalString$1(input?.uri, "uri")
+	});
+}
+function sourcePatch(input) {
+	const patch = compactUndefined({
+		content: optionalString$1(input?.content, "content"),
+		errorMessage: optionalString$1(input?.errorMessage, "errorMessage"),
+		isDir: optionalBoolean(input?.isDir, "isDir"),
+		metadata: optionalRecord(input?.metadata, "metadata"),
+		parentSourceId: optionalString$1(input?.parentSourceId, "parentSourceId"),
+		path: optionalString$1(input?.path, "path"),
+		sourceType: optionalString$1(input?.sourceType, "sourceType"),
+		status: optionalString$1(input?.status, "status"),
+		title: optionalString$1(input?.title, "title"),
+		uri: optionalString$1(input?.uri, "uri")
+	});
+	assertNonEmptyPatch(patch, "input");
+	return patch;
+}
+function siteBody(input) {
+	const maxPages = positiveInteger$1(input?.maxPages, "maxPages") ?? 50;
+	if (maxPages > 200) throw invalidArgument$1("maxPages must not exceed 200", "maxPages");
+	const includePaths = stringList(input?.includePaths ?? [], "includePaths");
+	const excludePaths = stringList(input?.excludePaths ?? [], "excludePaths");
+	const sitemap = optionalTrimmedString(input?.sitemapUrl, "sitemapUrl");
+	const compileAfterRefresh = optionalBoolean(input?.compileAfterRefresh, "compileAfterRefresh");
+	return compactUndefined({
+		config: compactUndefined({
+			compileAfterRefresh,
+			excludePaths,
+			includePaths,
+			maxPages,
+			rootUrl: httpUrl(input?.rootUrl, "rootUrl"),
+			sitemapUrl: sitemap === void 0 ? void 0 : httpUrl(sitemap, "sitemapUrl")
+		}),
+		parentSourceId: optionalString$1(input?.parentSourceId, "parentSourceId"),
+		path: optionalString$1(input?.pathPrefix, "pathPrefix"),
+		sourceType: "site_import",
+		title: optionalTrimmedString(input?.title, "title")
+	});
+}
+function createSourceOperations(context) {
+	const createSource = async (notebookId, input, options) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		return call(context, {
+			body: sourceBody(input),
+			callOptions: options,
+			capability: "sources.write",
+			idempotent: false,
+			method: "POST",
+			operation: "sources.create",
+			path: context.profile.apiPath("notebooks", notebook, "sources"),
+			schema: sourceSchema
+		});
+	};
+	const updateSource = async (notebookId, sourceId, input, options) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const source = requiredString$2(sourceId, "sourceId");
+		return call(context, {
+			body: sourcePatch(input),
+			callOptions: options,
+			capability: "sources.write",
+			idempotent: false,
+			method: "PUT",
+			operation: "sources.update",
+			path: context.profile.apiPath("notebooks", notebook, "sources", source),
+			schema: sourceSchema
+		});
+	};
+	const readSourcePage = async (notebookId, input = {}, options, operation = "sources.list") => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const normalizedPage = pagination$1(input);
+		const isDir = optionalBoolean(input.isDir, "isDir");
+		const view = input.view ?? "list";
+		if (view !== "list" && view !== "children") throw invalidArgument$1("view must be either \"list\" or \"children\"", "view");
+		const parentSourceId = optionalString$1(input.parentSourceId, "parentSourceId");
+		const query = optionalTrimmedString(input.query, "query");
+		if (view === "children") assertCapability(context.profile, "sources.children", "sources.list");
+		if (query !== void 0) assertCapability(context.profile, "sources.search", "sources.list");
+		if (parentSourceId !== void 0 && view !== "children") throw invalidArgument$1("parentSourceId requires view=\"children\"", "parentSourceId");
+		const path = queryPath(context.profile.apiPath("notebooks", notebook, "sources"), [
+			["view", view === "list" ? void 0 : view],
+			["is_dir", isDir === void 0 ? void 0 : String(isDir)],
+			["parent_source_id", parentSourceId],
+			["page", normalizedPage.page],
+			["page_size", normalizedPage.pageSize],
+			["query", query]
+		]);
+		return call(context, {
+			callOptions: options,
+			capability: "sources.read",
+			idempotent: true,
+			method: "GET",
+			operation,
+			path,
+			schema: sourceListSchema
+		});
+	};
+	const listSources = (notebookId, input, options) => readSourcePage(notebookId, input, options);
+	const listFeaturedSources = async (notebookId, input = {}, options) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const normalizedPage = pagination$1({
+			page: input.page ?? 1,
+			pageSize: input.pageSize ?? 200
+		});
+		const parentSourceId = optionalString$1(input.parentSourceId, "parentSourceId");
+		const view = input.view ?? "list";
+		if (view !== "list" && view !== "children") throw invalidArgument$1("view must be either \"list\" or \"children\"", "view");
+		return call(context, {
+			callOptions: options,
+			capability: "featuredNotebooks.read",
+			idempotent: true,
+			method: "GET",
+			operation: "featuredSources.list",
+			path: queryPath(context.profile.apiPath("featured-notebooks", notebook, "sources"), [
+				["view", view === "list" ? void 0 : view],
+				["parent_source_id", parentSourceId],
+				["page", normalizedPage.page],
+				["page_size", normalizedPage.pageSize]
+			]),
+			schema: sourceListSchema
+		});
+	};
+	const collectAllSources = async (notebookId, input = {}, options, operation) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const pageSize = positiveInteger$1(input.pageSize, "pageSize") ?? 200;
+		const maxPages = positiveInteger$1(input.maxPages, "maxPages") ?? 1e4;
+		const sources = [];
+		for (let page = 1; page <= maxPages; page += 1) {
+			const result = await readSourcePage(notebook, {
+				page,
+				pageSize,
+				view: "list"
+			}, options, operation);
+			sources.push(...result.sources);
+			const lastPage = result.pages?.lastPage;
+			if (result.sources.length < pageSize || lastPage !== void 0 && page >= lastPage) return sources;
+		}
+		throw new QMindError("PROTOCOL_ERROR", `source pagination exceeded ${maxPages} pages`, {
+			access: context.profile.access,
+			details: {
+				maxPages,
+				pageSize
+			},
+			operation
+		});
+	};
+	const listAllSources = (notebookId, input, options) => collectAllSources(notebookId, input, options, "sources.list");
+	const getSourceTree = async (notebookId, options) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		assertCapability(context.profile, "sources.tree", "sources.tree");
+		if (context.profile.access === "sash") return buildSourceTree(await collectAllSources(notebook, {}, options, "sources.tree"));
+		return call(context, {
+			callOptions: options,
+			capability: "sources.tree",
+			idempotent: true,
+			method: "GET",
+			operation: "sources.tree",
+			path: queryPath(context.profile.apiPath("notebooks", notebook, "sources"), [["view", "filetree"]]),
+			schema: sourceTreeSchema
+		});
+	};
+	return {
+		async batchDeleteSources(notebookId, sourceIds, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const ids = stringList(sourceIds, "sourceIds", { min: 1 });
+			return call(context, {
+				body: { sourceIds: ids },
+				callOptions: options,
+				capability: "sources.write",
+				idempotent: false,
+				method: "POST",
+				operation: "sources.batchDelete",
+				path: context.profile.apiPath("notebooks", notebook, "sources", "batch-delete"),
+				schema: batchMutationResultSchema
+			});
+		},
+		async countSourceChildren(notebookId, parentIds, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const ids = stringList(parentIds, "parentIds", {
+				max: 200,
+				min: 1
+			});
+			assertCapability(context.profile, "sources.childrenCount", "sources.childrenCount");
+			const path = context.profile.mindPath("notebooks", notebook, "sources", "children-count");
+			const query = new URLSearchParams();
+			for (const id of ids) query.append("parent_ids", id);
+			return call(context, {
+				callOptions: options,
+				capability: "sources.childrenCount",
+				idempotent: true,
+				method: "GET",
+				operation: "sources.childrenCount",
+				path: `${path}?${query.toString()}`,
+				schema: sourceChildrenCountsSchema
+			});
+		},
+		async createDirectory(notebookId, input, options) {
+			const title = requiredString$2(input?.title, "title");
+			return createSource(notebookId, {
+				isDir: true,
+				parentSourceId: input?.parentSourceId,
+				path: input?.path,
+				status: "ready",
+				title
+			}, options);
+		},
+		createSource,
+		async createSourceWebOfficeSession(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			assertCapability(context.profile, "sources.webOffice", "sources.webOffice.create");
+			return call(context, {
+				callOptions: options,
+				capability: "sources.webOffice",
+				idempotent: false,
+				method: "POST",
+				operation: "sources.webOffice.create",
+				path: context.profile.apiPath("notebooks", notebook, "sources", source, "weboffice", "session"),
+				schema: sourceWebOfficeSessionSchema
+			});
+		},
+		async deleteSource(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "sources.write",
+				idempotent: false,
+				method: "DELETE",
+				operation: "sources.delete",
+				path: context.profile.apiPath("notebooks", notebook, "sources", source),
+				schema: voidResponseSchema
+			});
+		},
+		async getFeaturedSource(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "featuredNotebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "featuredSources.get",
+				path: context.profile.apiPath("featured-notebooks", notebook, "sources", source),
+				schema: sourceSchema
+			});
+		},
+		async getFeaturedSourceContent(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "featuredNotebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "featuredSources.content",
+				path: context.profile.apiPath("featured-notebooks", notebook, "sources", source, "content"),
+				schema: sourceContentSchema
+			});
+		},
+		async getFeaturedSourcePreview(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "featuredNotebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "featuredSources.preview",
+				path: context.profile.apiPath("featured-notebooks", notebook, "sources", source, "preview"),
+				schema: sourcePreviewSchema
+			});
+		},
+		async getFeaturedSourceRawContent(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "featuredNotebooks.read",
+				idempotent: true,
+				method: "GET",
+				operation: "featuredSources.rawContent",
+				path: context.profile.apiPath("featured-notebooks", notebook, "sources", source, "raw-content"),
+				schema: sourceRawContentSchema
+			});
+		},
+		async getSource(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "sources.read",
+				idempotent: true,
+				method: "GET",
+				operation: "sources.get",
+				path: context.profile.apiPath("notebooks", notebook, "sources", source),
+				schema: sourceSchema
+			});
+		},
+		async getSourceContent(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "sources.read",
+				idempotent: true,
+				method: "GET",
+				operation: "sources.content",
+				path: context.profile.apiPath("notebooks", notebook, "sources", source, "content"),
+				schema: sourceContentSchema
+			});
+		},
+		async getSourceActionAccess(options) {
+			return call(context, {
+				callOptions: options,
+				capability: "sources.actionAccess",
+				idempotent: true,
+				method: "GET",
+				operation: "sources.actionAccess",
+				path: context.profile.mindPath("source-actions", "access"),
+				schema: sourceActionAccessSchema
+			});
+		},
+		async getSourcePreview(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "sources.preview",
+				idempotent: true,
+				method: "GET",
+				operation: "sources.preview",
+				path: context.profile.apiPath("notebooks", notebook, "sources", source, "preview"),
+				schema: sourcePreviewSchema
+			});
+		},
+		async getSourceRawContent(notebookId, sourceId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			return call(context, {
+				callOptions: options,
+				capability: "sources.rawContent",
+				idempotent: true,
+				method: "GET",
+				operation: "sources.rawContent",
+				path: context.profile.apiPath("notebooks", notebook, "sources", source, "raw-content"),
+				schema: sourceRawContentSchema
+			});
+		},
+		async getSourceUploadCapabilities(options) {
+			return call(context, {
+				callOptions: options,
+				capability: "sources.write",
+				idempotent: true,
+				method: "GET",
+				operation: "sources.uploadCapabilities",
+				path: context.profile.mindPath("source-upload", "capabilities"),
+				schema: sourceUploadCapabilitiesSchema
+			});
+		},
+		async getFeaturedSourceTree(notebookId, options) {
+			return buildSourceTree((await listFeaturedSources(notebookId, {
+				page: 1,
+				pageSize: 200
+			}, options)).sources);
+		},
+		getSourceTree,
+		async importSite(notebookId, input, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				body: siteBody(input),
+				callOptions: options,
+				capability: "sources.write",
+				idempotent: false,
+				method: "POST",
+				operation: "sources.importSite",
+				path: context.profile.apiPath("notebooks", notebook, "sources"),
+				schema: sourceSchema
+			});
+		},
+		async importWebLinks(notebookId, input, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const urls = stringList(input?.urls ?? [], "urls", {
+				max: 5,
+				min: 1
+			}).map((url) => httpUrl(url, "urls"));
+			return call(context, {
+				body: compactUndefined({
+					parentSourceId: optionalString$1(input?.parentSourceId, "parentSourceId"),
+					path: optionalString$1(input?.path, "path"),
+					sourceType: "url",
+					urls
+				}),
+				callOptions: options,
+				capability: "sources.importWeb",
+				idempotent: false,
+				method: "POST",
+				operation: "sources.importWeb",
+				path: context.profile.apiPath("notebooks", notebook, "sources"),
+				schema: sourceImportResultsSchema
+			});
+		},
+		async importWikiDocuments(notebookId, input, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const urls = stringList(input?.urls ?? [], "urls", {
+				max: 5,
+				min: 1
+			});
+			return call(context, {
+				body: compactUndefined({
+					parentSourceId: optionalString$1(input?.parentSourceId, "parentSourceId"),
+					path: "/repowiki",
+					sourceType: "repowiki",
+					urls
+				}),
+				callOptions: options,
+				capability: "sources.write",
+				idempotent: false,
+				method: "POST",
+				operation: "sources.importWiki",
+				path: context.profile.apiPath("notebooks", notebook, "sources"),
+				schema: sourceImportResultsSchema
+			});
+		},
+		listAllSources,
+		listFeaturedSources,
+		listSources,
+		async moveSource(notebookId, sourceId, input, options) {
+			const parentSourceId = optionalString$1(input?.parentSourceId, "parentSourceId");
+			const path = optionalString$1(input?.path, "path");
+			const status = optionalString$1(input?.status, "status");
+			const title = optionalString$1(input?.title, "title");
+			const patch = {
+				...parentSourceId === void 0 ? {} : { parentSourceId },
+				...path === void 0 ? {} : { path },
+				...status === void 0 ? {} : { status },
+				...title === void 0 ? {} : { title }
+			};
+			assertNonEmptyPatch(patch, "input");
+			return updateSource(notebookId, sourceId, patch, options);
+		},
+		async presignImageUpload(notebookId, sourceId, input, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			const filename = requiredString$2(input?.filename, "filename");
+			const mimeType = requiredString$2(input?.mimeType, "mimeType");
+			const size = nonNegativeInteger$1(input?.size, "size");
+			if (size === void 0) throw invalidArgument$1("size must be a non-negative integer", "size");
+			if (size > maxImageBytes) throw invalidArgument$1(`size must not exceed ${maxImageBytes} bytes`, "size");
+			return call(context, {
+				body: compactUndefined({
+					filename,
+					mimeType,
+					size
+				}),
+				callOptions: options,
+				capability: "images.presignUpload",
+				idempotent: false,
+				method: "POST",
+				operation: "images.presignUpload",
+				path: context.profile.apiPath("notebooks", notebook, "sources", source, "images", "presign"),
+				schema: imageUploadTicketSchema
+			});
+		},
+		async refreshSourceWebOfficeSession(notebookId, sourceId, input, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = requiredString$2(sourceId, "sourceId");
+			const sessionId = requiredString$2(input?.sessionId, "sessionId");
+			const tokenVersion = nonNegativeInteger$1(input?.tokenVersion, "tokenVersion") ?? 0;
+			assertCapability(context.profile, "sources.webOffice", "sources.webOffice.refresh");
+			return call(context, {
+				body: { tokenVersion },
+				callOptions: options,
+				capability: "sources.webOffice",
+				idempotent: false,
+				method: "POST",
+				operation: "sources.webOffice.refresh",
+				path: context.profile.apiPath("notebooks", notebook, "sources", source, "weboffice", "session", sessionId, "refresh"),
+				schema: sourceWebOfficeTokenSchema
+			});
+		},
+		async presignImageUrls(notebookId, ossKeys, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const keys = stringList(ossKeys, "ossKeys", {
+				max: 100,
+				min: 1
+			});
+			return call(context, {
+				body: { ossKeys: keys },
+				callOptions: options,
+				capability: "images.presignUrls",
+				idempotent: false,
+				method: "POST",
+				operation: "images.presignUrls",
+				path: context.profile.apiPath("notebooks", notebook, "images", "presign-urls"),
+				schema: imageUrlsSchema
+			});
+		},
+		updateSource
+	};
+}
+//#endregion
+//#region ../sdk/src/operations/transfers.ts
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function binarySource(value) {
+	if (!isRecord$2(value)) throw invalidArgument$1("source must be a QMindBinarySource", "source");
+	const filename = requiredString$2(value.filename, "source.filename");
+	const mimeType = requiredString$2(value.mimeType, "source.mimeType");
+	const size = value.size;
+	if (typeof size !== "number" || !Number.isSafeInteger(size) || size <= 0) throw invalidArgument$1("source.size must be a positive safe integer", "source.size");
+	if (typeof value.open !== "function") throw invalidArgument$1("source.open must be a function", "source.open");
+	const source = value;
+	return {
+		filename,
+		mimeType,
+		open: () => source.open(),
+		size
+	};
+}
+function transferOptions(options) {
+	if (options === void 0) return {};
+	if (!isRecord$2(options)) throw invalidArgument$1("options must be an object", "options");
+	if (options.onProgress !== void 0 && typeof options.onProgress !== "function") throw invalidArgument$1("onProgress must be a function", "onProgress");
+	return options;
+}
+function uploadMetadata(value) {
+	if (value === void 0) return {};
+	if (!isRecord$2(value)) throw invalidArgument$1("metadata must be an object", "metadata");
+	return {
+		parentSourceId: optionalString$1(value.parentSourceId, "parentSourceId"),
+		path: optionalString$1(value.path, "path"),
+		sha256: optionalTrimmedString(value.sha256, "sha256"),
+		sourceType: optionalTrimmedString(value.sourceType, "sourceType"),
+		title: optionalTrimmedString(value.title, "title")
+	};
+}
+function progressReporter(context, operation, strategy, totalBytes, options) {
+	let lastUploadedBytes = 0;
+	const notify = (phase, uploadedBytes) => {
+		if (!Number.isSafeInteger(uploadedBytes) || uploadedBytes < lastUploadedBytes) throw new QMindError("HOST_POLICY_ERROR", "upload progress must be a monotonic integer", {
+			access: context.profile.access,
+			details: {
+				lastUploadedBytes,
+				totalBytes,
+				uploadedBytes
+			},
+			operation
+		});
+		if (uploadedBytes > totalBytes) throw new QMindError("HOST_POLICY_ERROR", "upload progress exceeds source size", {
+			access: context.profile.access,
+			details: {
+				totalBytes,
+				uploadedBytes
+			},
+			operation
+		});
+		lastUploadedBytes = uploadedBytes;
+		const progress = {
+			phase,
+			strategy,
+			totalBytes,
+			uploadedBytes
+		};
+		options.onProgress?.(progress);
+	};
+	return {
+		complete: () => notify("uploading", totalBytes),
+		registering: () => notify("registering", totalBytes),
+		start: () => notify("uploading", 0),
+		update: (uploadedBytes) => notify("uploading", uploadedBytes)
+	};
+}
+function requestOptions(options) {
+	return {
+		...options.signal === void 0 ? {} : { signal: options.signal },
+		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+	};
+}
+function transferCall(context, operation, request, schema) {
+	return executeUnary({
+		capability: operation.startsWith("images.") ? "images.presignUpload" : "transfers",
+		operation,
+		profile: context.profile,
+		request,
+		schema,
+		transport: context.transport
+	});
+}
+function hostRequest(path, method, idempotent, options, body) {
+	const authorization = options.authorization?.trim();
+	return {
+		body,
+		destination: {
+			kind: "host",
+			path
+		},
+		...authorization === void 0 || authorization.length === 0 ? {} : { headers: { authorization: `Bearer ${authorization}` } },
+		idempotent,
+		method,
+		...requestOptions(options)
+	};
+}
+function signedUploadRequest(ticket, source, progress, options) {
+	return {
+		body: {
+			kind: "binary",
+			onProgress: progress.update,
+			source
+		},
+		destination: {
+			kind: "signed",
+			url: ticket.uploadUrl
+		},
+		headers: ticket.headers,
+		idempotent: true,
+		method: "PUT",
+		...requestOptions(options)
+	};
+}
+function createTransferOperations(context) {
+	return {
+		async uploadImage(notebookId, sourceId, rawSource, rawOptions) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const sourceIdValue = requiredString$2(sourceId, "sourceId");
+			const source = binarySource(rawSource);
+			const options = transferOptions(rawOptions);
+			if (source.size > 52428800) throw new QMindError("FILE_TOO_LARGE", "image exceeds the 50 MiB upload limit", {
+				access: context.profile.access,
+				details: {
+					limitBytes: QMIND_MULTIPART_UPLOAD_MAX_BYTES,
+					size: source.size
+				},
+				operation: "images.upload"
+			});
+			const ticket = await transferCall(context, "images.presignUpload", hostRequest(context.profile.apiPath("notebooks", notebook, "sources", sourceIdValue, "images", "presign"), "POST", false, options, {
+				kind: "json",
+				value: {
+					filename: source.filename,
+					mimeType: source.mimeType,
+					size: source.size
+				}
+			}), imageUploadTicketSchema);
+			const progress = progressReporter(context, "images.upload", "presigned", source.size, options);
+			progress.start();
+			await transferCall(context, "images.upload", signedUploadRequest(ticket, source, progress, options), voidResponseSchema);
+			progress.complete();
+			return ticket;
+		},
+		async uploadSource(notebookId, rawSource, rawMetadata, rawOptions) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const source = binarySource(rawSource);
+			const metadata = uploadMetadata(rawMetadata);
+			const options = transferOptions(rawOptions);
+			if (source.size > 524288e3) throw new QMindError("FILE_TOO_LARGE", "file exceeds the 500 MiB upload limit", {
+				access: context.profile.access,
+				details: {
+					limitBytes: QMIND_SOURCE_UPLOAD_MAX_BYTES,
+					size: source.size
+				},
+				operation: "transfers.source.multipart"
+			});
+			if (source.size <= 52428800) {
+				const progress = progressReporter(context, "transfers.source.multipart", "multipart", source.size, options);
+				progress.start();
+				const fields = compactUndefined({
+					parent_source_id: metadata.parentSourceId,
+					path: metadata.path,
+					retain_original_file: "true",
+					source_type: metadata.sourceType,
+					title: metadata.title
+				});
+				const result = await transferCall(context, "transfers.source.multipart", hostRequest(queryPath(context.profile.apiPath("notebooks", notebook, "sources", "upload"), [["client", context.client]]), "POST", false, options, {
+					file: source,
+					fields,
+					kind: "multipart",
+					onProgress: progress.update
+				}), sourceSchema);
+				progress.complete();
+				return result;
+			}
+			const ticket = await transferCall(context, "transfers.source.presign", hostRequest(context.profile.apiPath("notebooks", notebook, "sources", "presign"), "POST", false, options, {
+				kind: "json",
+				value: {
+					filename: source.filename,
+					mimeType: source.mimeType,
+					size: source.size
+				}
+			}), sourceUploadTicketSchema);
+			const progress = progressReporter(context, "transfers.source.upload", "presigned", source.size, options);
+			progress.start();
+			await transferCall(context, "transfers.source.upload", signedUploadRequest(ticket, source, progress, options), voidResponseSchema);
+			progress.complete();
+			progress.registering();
+			return transferCall(context, "transfers.source.register", hostRequest(context.profile.apiPath("notebooks", notebook, "sources", "register"), "POST", false, options, {
+				kind: "json",
+				value: compactUndefined({
+					filename: source.filename,
+					mimeType: source.mimeType,
+					parentSourceId: metadata.parentSourceId,
+					path: metadata.path,
+					sha256: metadata.sha256,
+					size: source.size,
+					sourceType: metadata.sourceType,
+					title: metadata.title,
+					uri: ticket.uri
+				})
+			}), sourceSchema);
+		}
+	};
+}
+//#endregion
+//#region ../sdk/src/capabilities.ts
+const dashboardCapabilities = Object.freeze({
+	botGateway: false,
+	"cards.read": true,
+	"cards.write": true,
+	chat: true,
+	compilation: true,
+	"featuredNotebooks.read": true,
+	"images.presignUpload": false,
+	"images.presignUrls": false,
+	"imports.aliDing": true,
+	"imports.discover": true,
+	members: true,
+	"notebooks.filterByClient": false,
+	"notebooks.read": true,
+	"notebooks.write": true,
+	"notes.read": false,
+	"notes.write": false,
+	retrieval: true,
+	scheduledTasks: true,
+	"sharedNotebooks.read": true,
+	"sources.children": true,
+	"sources.childrenCount": true,
+	"sources.actionAccess": true,
+	"sources.importWeb": true,
+	"sources.preview": true,
+	"sources.rawContent": true,
+	"sources.read": true,
+	"sources.search": true,
+	"sources.tree": true,
+	"sources.webOffice": true,
+	"sources.write": true,
+	"taskRuns.read": true,
+	"taskRuns.write": true,
+	transfers: true,
+	"wikiBranches.read": true
+});
+const sashCapabilities = Object.freeze({
+	botGateway: false,
+	"cards.read": true,
+	"cards.write": true,
+	chat: true,
+	compilation: false,
+	"featuredNotebooks.read": false,
+	"images.presignUpload": true,
+	"images.presignUrls": true,
+	"imports.aliDing": false,
+	"imports.discover": false,
+	members: false,
+	"notebooks.filterByClient": true,
+	"notebooks.read": true,
+	"notebooks.write": true,
+	"notes.read": false,
+	"notes.write": false,
+	retrieval: true,
+	scheduledTasks: false,
+	"sharedNotebooks.read": false,
+	"sources.children": true,
+	"sources.childrenCount": false,
+	"sources.actionAccess": true,
+	"sources.importWeb": true,
+	"sources.preview": true,
+	"sources.rawContent": true,
+	"sources.read": true,
+	"sources.search": false,
+	"sources.tree": true,
+	"sources.webOffice": true,
+	"sources.write": true,
+	"taskRuns.read": true,
+	"taskRuns.write": true,
+	transfers: true,
+	"wikiBranches.read": true
+});
+function capabilitiesFor(access) {
+	return access === "sash" ? sashCapabilities : dashboardCapabilities;
+}
+//#endregion
+//#region ../sdk/src/profiles.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function encodeId(value) {
+	return encodeURIComponent(value);
+}
+function appendQuery(path, entries) {
+	const query = new URLSearchParams();
+	for (const [key, value] of entries) if (value !== void 0 && value !== "") query.set(key, String(value));
+	const suffix = query.toString();
+	return suffix ? `${path}?${suffix}` : path;
+}
+function dashboardEnvelope(body) {
+	if (!isRecord$1(body) || typeof body.status !== "number" || !("data" in body)) return body;
+	return body.data;
+}
+function firstResultSource(access, operation, body) {
+	if (!isRecord$1(body) || !Array.isArray(body.results)) return body;
+	const first = body.results[0];
+	if (!isRecord$1(first)) return void 0;
+	if ("source" in first) return first.source;
+	if (typeof first.error === "string" && first.error.length > 0) throw new QMindError("REMOTE_ERROR", first.error, {
+		access,
+		details: first,
+		operation,
+		status: 200
+	});
+}
+function dashboardBatchMutation(body) {
+	if (!isRecord$1(body)) return body;
+	const successCount = typeof body.successCount === "number" ? body.successCount : body.success_count;
+	const failureCount = typeof body.failureCount === "number" ? body.failureCount : body.failure_count;
+	if (typeof successCount !== "number" && typeof failureCount !== "number") return body;
+	return {
+		...body,
+		failureCount: typeof failureCount === "number" ? failureCount : 0,
+		successCount: typeof successCount === "number" ? successCount : 0
+	};
+}
+function normalizeSuccess(access, operation, body) {
+	const unwrapped = access === "dashboard" ? dashboardEnvelope(body) : body;
+	if (access !== "dashboard") return unwrapped;
+	if (operation === "cards.get" && isRecord$1(unwrapped) && "card" in unwrapped) return unwrapped.card;
+	if (operation === "cards.delete" || operation === "cards.batchDelete") return dashboardBatchMutation(unwrapped);
+	if (operation === "sources.create" || operation === "sources.importSite") return firstResultSource(access, operation, unwrapped);
+	if (operation === "transfers.source.multipart" || operation === "transfers.source.register") return firstResultSource(access, operation, unwrapped);
+	return unwrapped;
+}
+function streamError(access, message, details) {
+	return new QMindError("STREAM_ERROR", message, {
+		access,
+		...details === void 0 ? {} : { details },
+		operation: "chat.stream"
+	});
+}
+function requiredString$1(access, value, field) {
+	if (value !== void 0 && value.length > 0) return value;
+	throw streamError(access, `stream event is missing ${field}`, { field });
+}
+function stringValue$1(value) {
+	return value ?? "";
+}
+function presentString(access, value, field) {
+	if (value !== void 0) return value;
+	throw streamError(access, `stream event is missing ${field}`, { field });
+}
+function decodeStreamEvent(access, rawBody) {
+	const candidate = access === "dashboard" ? dashboardEnvelope(rawBody) : rawBody;
+	const parsed = streamWireEventSchema.safeParse(candidate);
+	if (!parsed.success) throw streamError(access, "stream event does not match the QMind contract", { issues: parsed.error.issues });
+	const event = parsed.data;
+	const eventType = event.eventType ?? event.event_type ?? event.type;
+	switch (eventType) {
+		case "message_start": return {
+			citations: event.citations ?? [],
+			reranked: event.reranked ?? false,
+			totalContextChunks: event.totalContextChunks ?? 0,
+			type: "messageStart",
+			...event.assistantMessageId === void 0 ? {} : { assistantMessageId: event.assistantMessageId },
+			...event.userMessage === void 0 ? {} : { userMessage: event.userMessage }
+		};
+		case "tool_call_start": return {
+			step: event.step ?? 0,
+			toolArguments: stringValue$1(event.toolArguments),
+			toolName: requiredString$1(access, event.toolName, "toolName"),
+			type: "toolCallStart",
+			...event.toolDisplayName === void 0 ? {} : { toolDisplayName: event.toolDisplayName }
+		};
+		case "tool_call_result": return {
+			step: event.step ?? 0,
+			toolName: requiredString$1(access, event.toolName, "toolName"),
+			toolResult: stringValue$1(event.toolResult),
+			type: "toolCallResult",
+			...event.toolDisplayName === void 0 ? {} : { toolDisplayName: event.toolDisplayName }
+		};
+		case "delta": return {
+			delta: presentString(access, event.delta, "delta"),
+			type: "delta"
+		};
+		case "batch_progress": return {
+			metadata: event.metadata ?? {},
+			type: "batchProgress"
+		};
+		case "heartbeat": return {
+			metadata: event.metadata ?? {},
+			type: "heartbeat"
+		};
+		case "cancel": return {
+			canceled: true,
+			type: "cancel",
+			...event.cancelReason === void 0 ? {} : { cancelReason: event.cancelReason }
+		};
+		case "message_complete": return {
+			canceled: event.canceled ?? false,
+			citations: event.citations ?? [],
+			metadata: event.metadata ?? {},
+			promptContext: event.promptContext ?? "",
+			reranked: event.reranked ?? false,
+			totalContextChunks: event.totalContextChunks ?? 0,
+			type: "messageComplete",
+			...event.assistantMessage === void 0 ? {} : { assistantMessage: event.assistantMessage },
+			...event.cancelReason === void 0 ? {} : { cancelReason: event.cancelReason }
+		};
+		case "error": return {
+			message: requiredString$1(access, event.errorMessage ?? event.error, "errorMessage"),
+			type: "error"
+		};
+		default: throw streamError(access, "stream event has an unsupported event type", { eventType });
+	}
+}
+function decodeStreamPayload(access, payload) {
+	let value;
+	try {
+		value = JSON.parse(payload);
+	} catch (cause) {
+		throw streamError(access, "stream event is not valid JSON", { cause });
+	}
+	return decodeStreamEvent(access, value);
+}
+function createProfile(access, apiPrefix) {
+	const capabilities = capabilitiesFor(access);
+	const apiPath = (...segments) => {
+		return `${apiPrefix}/${segments.map((segment) => encodeId(segment)).join("/")}`;
+	};
+	return Object.freeze({
+		access,
+		capabilities,
+		apiPath,
+		decodeStreamPayload(payload) {
+			return decodeStreamPayload(access, payload);
+		},
+		featuredNotebookPath(notebookId) {
+			return notebookId === void 0 ? apiPath("featured-notebooks") : apiPath("featured-notebooks", notebookId);
+		},
+		listFeaturedNotebooksPath(input) {
+			return appendQuery(`${apiPrefix}/featured-notebooks`, [["page", input.page], ["page_size", input.pageSize]]);
+		},
+		listNotebooksPath(input) {
+			return appendQuery(`${apiPrefix}/notebooks`, [
+				["page", input.page],
+				["page_size", input.pageSize],
+				["client", input.client]
+			]);
+		},
+		listSharedNotebooksPath(input) {
+			return appendQuery(`${apiPrefix}/notebooks/shared`, [["page", input.page], ["page_size", input.pageSize]]);
+		},
+		mindPath(...segments) {
+			return `/api/v1/mind/${segments.map((segment) => encodeId(segment)).join("/")}`;
+		},
+		notebookPath(notebookId) {
+			return notebookId === void 0 ? apiPath("notebooks") : apiPath("notebooks", notebookId);
+		},
+		unwrapError(body) {
+			return access === "dashboard" ? dashboardEnvelope(body) : body;
+		},
+		unwrapSuccess(operation, body) {
+			return normalizeSuccess(access, operation, body);
+		},
+		wikiBranchesPath(notebookId) {
+			return apiPath("notebooks", notebookId, "wiki-branches");
+		}
+	});
+}
+const dashboardProfile = createProfile("dashboard", "/api/v1");
+const sashProfile = createProfile("sash", "/sash/api/v1");
+function profileFor(access) {
+	return access === "sash" ? sashProfile : dashboardProfile;
+}
+//#endregion
+//#region ../sdk/src/client.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isQMindAccess(value) {
+	return value === "sash" || value === "dashboard";
+}
+function isQMindTransport(value) {
+	if (!isRecord(value)) return false;
+	return typeof value.request === "function" && typeof value.stream === "function";
+}
+const managementOperationNames = [
+	"addMember",
+	"createScheduledTask",
+	"deleteScheduledTask",
+	"getCompilationSettings",
+	"getCompilationStatus",
+	"listMembers",
+	"listScheduledTasks",
+	"removeMember",
+	"saveCompilationSettings",
+	"startCompilation",
+	"updateMemberPermission",
+	"updateScheduledTask"
+];
+const cardOperationNames = [
+	"batchDeleteCards",
+	"deleteCard",
+	"getCard",
+	"listCards",
+	"listFeaturedCards"
+];
+const importOperationNames = [
+	"getAliDingImportRun",
+	"listAliDingImportRunItems",
+	"listImportProviders",
+	"startAliDingKnowledgeBaseImport",
+	"startAliDingNodeSubtreeImport"
+];
+function createLazyCardOperations(context) {
+	let operations;
+	const load = () => {
+		operations ??= import("./cards-2J6ebaI0.js").then(({ createCardOperations }) => createCardOperations(context));
+		return operations;
+	};
+	return Object.fromEntries(cardOperationNames.map((name) => [name, (...args) => load().then((loaded) => Reflect.apply(loaded[name], loaded, args))]));
+}
+function createLazyImportOperations(context) {
+	let operations;
+	const load = () => {
+		operations ??= import("./imports-Da88W09Q.js").then(({ createImportOperations }) => createImportOperations(context));
+		return operations;
+	};
+	return Object.fromEntries(importOperationNames.map((name) => [name, (...args) => load().then((loaded) => Reflect.apply(loaded[name], loaded, args))]));
+}
+function createLazyManagementOperations(context) {
+	let operations;
+	const load = () => {
+		operations ??= import("./management-xYuUDFtg.js").then(({ createManagementOperations }) => createManagementOperations(context));
+		return operations;
+	};
+	return Object.fromEntries(managementOperationNames.map((name) => [name, (...args) => load().then((loaded) => Reflect.apply(loaded[name], loaded, args))]));
+}
+function createQMindClient(options) {
+	if (!isRecord(options)) throw invalidArgument$1("client options must be an object", "options");
+	if (!isQMindAccess(options.access)) throw invalidArgument$1("access must be either \"sash\" or \"dashboard\"", "access");
+	if (!isQMindTransport(options.transport)) throw invalidArgument$1("transport must implement request() and stream()", "transport");
+	const profile = profileFor(options.access);
+	const context = {
+		client: optionalTrimmedString(options.client, "client") ?? "qmind",
+		profile,
+		transport: options.transport
+	};
+	return Object.freeze({
+		access: profile.access,
+		capabilities: profile.capabilities,
+		...createNotebookOperations(context),
+		...createLazyCardOperations(context),
+		...createSourceOperations(context),
+		...createLazyImportOperations(context),
+		...createLazyManagementOperations(context),
+		...createTransferOperations(context),
+		...createAgentOperations(context),
+		supports(capability) {
+			return profile.capabilities[capability] === true;
+		}
+	});
+}
+//#endregion
+//#region ../node-host/src/auth.ts
+const responseRecordSchema = z.record(z.string(), z.unknown());
+const personalTokenExchangeSchema = z.object({ token: z.string().min(1) });
+const devicePollSchema = z.object({
+	expires_at: z.string().default(""),
+	refresh_token: z.string().default(""),
+	refresh_token_expires_at: z.string().default(""),
+	token: z.string().min(1)
+});
+const refreshSchema = z.object({
+	device_token: z.string().min(1),
+	expires_at: z.string().default(""),
+	refresh_token: z.string().optional(),
+	refresh_token_expires_at: z.string().optional()
+});
+const POLL_INTERVAL_MS = 2e3;
+const LOGIN_TIMEOUT_MS = 3e5;
+const EXPIRY_SKEW_MS = 3e4;
+function base64Url(bytes) {
+	return Buffer.from(bytes).toString("base64url");
+}
+function createPkce() {
+	const verifier = base64Url(randomBytes(32));
+	return {
+		challenge: createHash("sha256").update(verifier).digest("base64url"),
+		nonce: base64Url(randomBytes(16)),
+		verifier
+	};
+}
+function errorCodeForStatus(status) {
+	if (status === 401 || status === 403) return "AUTH_REQUIRED";
+	if (status === 404) return "NOT_FOUND";
+	if (status === 409) return "CONFLICT";
+	if (status === 429) return "RATE_LIMITED";
+	if (status >= 400 && status < 500) return "INVALID_ARGUMENT";
+	return "REMOTE_ERROR";
+}
+function record$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function responseString(response, ...keys) {
+	const body = record$1(response.body);
+	const nestedError = record$1(body?.error);
+	for (const source of [body, nestedError]) for (const key of keys) {
+		const value = source?.[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
+function header(response, name) {
+	const normalized = name.toLowerCase();
+	for (const [key, value] of Object.entries(response.headers)) if (key.toLowerCase() === normalized && value.length > 0) return value;
+}
+function authResponseError(response, operation) {
+	const requestId = responseString(response, "requestId", "request_id") ?? header(response, "x-request-id");
+	const upstreamCode = responseString(response, "errorCode", "error_code", "code");
+	return new QMindError(errorCodeForStatus(response.status), `${operation} failed`, {
+		details: { operation },
+		...requestId === void 0 ? {} : { requestId },
+		status: response.status,
+		...upstreamCode === void 0 ? {} : { upstreamCode }
+	});
+}
+async function authRequest(transport, method, path, operation, body) {
+	const request = {
+		...body === void 0 ? {} : { body: {
+			kind: "json",
+			value: body
+		} },
+		destination: {
+			kind: "host",
+			path
+		},
+		idempotent: method === "GET",
+		method
+	};
+	let response;
+	try {
+		response = await transport.request(request);
+	} catch (cause) {
+		if (cause instanceof QMindError) throw cause;
+		throw new QMindError("NETWORK_ERROR", `${operation} failed`);
+	}
+	if (response.status < 200 || response.status >= 300) throw authResponseError(response, operation);
+	const parsed = responseRecordSchema.safeParse(response.body);
+	if (!parsed.success) throw new QMindError("PROTOCOL_ERROR", `${operation} returned an invalid response`, {
+		details: { operation },
+		status: response.status
+	});
+	return parsed.data;
+}
+function credentialsFromLogin(value, sashOrigin) {
+	return {
+		deviceToken: value.token,
+		expiresAt: value.expires_at,
+		refreshToken: value.refresh_token,
+		refreshTokenExpiresAt: value.refresh_token_expires_at,
+		sashOrigin,
+		savedAt: "",
+		schemaVersion: 2
+	};
+}
+function isExpired(timestamp, now, skew = 0) {
+	if (timestamp.length === 0) return false;
+	const value = Date.parse(timestamp);
+	return Number.isFinite(value) && value <= now + skew;
+}
+function aborted(signal) {
+	return signal?.aborted === true ? new QMindError("ABORTED", "QMind authorization was aborted") : void 0;
+}
+function createSystemClock() {
+	return Object.freeze({
+		now: Date.now,
+		sleep(milliseconds, signal) {
+			return new Promise((resolve, reject) => {
+				const alreadyAborted = aborted(signal);
+				if (alreadyAborted !== void 0) {
+					reject(alreadyAborted);
+					return;
+				}
+				const onAbort = () => {
+					clearTimeout(timer);
+					reject(new QMindError("ABORTED", "QMind authorization was aborted"));
+				};
+				const timer = setTimeout(() => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve();
+				}, milliseconds);
+				signal?.addEventListener("abort", onAbort, { once: true });
+			});
+		}
+	});
+}
+function createQMindCliAuthManager(options) {
+	let credentials = options.credentials;
+	let explicitToken = options.explicitToken;
+	let token = "";
+	let refreshPromise;
+	const login = async (loginOptions = {}) => {
+		if (options.config.nonInteractive) throw new QMindError("AUTH_REQUIRED", "login requires an interactive terminal");
+		const pkce = createPkce();
+		const browserUrl = new URL("/device/selectAccounts", options.config.dashboardOrigin);
+		browserUrl.searchParams.set("nonce", pkce.nonce);
+		browserUrl.searchParams.set("challenge", pkce.challenge);
+		browserUrl.searchParams.set("challenge_method", "S256");
+		browserUrl.searchParams.set("machine_id", pkce.nonce);
+		if (loginOptions.clientId !== void 0 && loginOptions.clientId.trim().length > 0) browserUrl.searchParams.set("client_id", loginOptions.clientId.trim());
+		options.reporter.info(`Opening browser for authorization. If it does not open, visit:\n${browserUrl.toString()}`);
+		if (loginOptions.openBrowser !== false) try {
+			await options.browser.open(browserUrl.toString());
+		} catch {
+			options.reporter.warn("warning: unable to open a browser; use the authorization URL above");
+		}
+		options.reporter.info("Waiting for authorization (timeout: 5m)...");
+		const deadline = options.clock.now() + LOGIN_TIMEOUT_MS;
+		while (options.clock.now() < deadline) {
+			const abortError = aborted(loginOptions.signal);
+			if (abortError !== void 0) throw abortError;
+			await options.clock.sleep(POLL_INTERVAL_MS, loginOptions.signal);
+			const pollPath = `/api/v1/deviceToken/poll?${new URLSearchParams({
+				challenge_method: "S256",
+				nonce: pkce.nonce,
+				verifier: pkce.verifier
+			}).toString()}`;
+			try {
+				const raw = await authRequest(options.transport, "GET", pollPath, "device authorization polling");
+				const parsed = devicePollSchema.safeParse(raw);
+				if (!parsed.success) throw new QMindError("PROTOCOL_ERROR", "device authorization returned an invalid response");
+				credentials = credentialsFromLogin(parsed.data, options.config.sashOrigin);
+				await options.vault.save(credentials);
+				explicitToken = "";
+				token = credentials.deviceToken;
+				return {
+					expiresAt: credentials.expiresAt,
+					sashOrigin: credentials.sashOrigin
+				};
+			} catch (error) {
+				if (error instanceof QMindError && error.status === 404) continue;
+				throw error;
+			}
+		}
+		throw new QMindError("AUTH_REQUIRED", "authorization timed out after 5m");
+	};
+	const refreshInternal = async (reason) => {
+		if (credentials === void 0 || credentials.refreshToken.length === 0) {
+			token = "";
+			throw new QMindError("AUTH_REQUIRED", `credentials cannot be refreshed after ${reason}`);
+		}
+		if (isExpired(credentials.refreshTokenExpiresAt, options.clock.now())) {
+			await options.vault.deleteIf(credentials);
+			credentials = void 0;
+			token = "";
+			throw new QMindError("AUTH_REQUIRED", "stored refresh credentials have expired");
+		}
+		const raw = await authRequest(options.transport, "POST", "/api/v1/deviceToken/refresh", "credential refresh", { refresh_token: credentials.refreshToken });
+		const parsed = refreshSchema.safeParse(raw);
+		if (!parsed.success) throw new QMindError("PROTOCOL_ERROR", "credential refresh returned an invalid response");
+		const basis = credentials;
+		const legacy = basis.schemaVersion !== 2;
+		const refreshed = {
+			...basis,
+			deviceToken: parsed.data.device_token,
+			expiresAt: parsed.data.expires_at,
+			refreshToken: parsed.data.refresh_token ?? basis.refreshToken,
+			refreshTokenExpiresAt: parsed.data.refresh_token_expires_at ?? basis.refreshTokenExpiresAt,
+			sashOrigin: options.config.sashOrigin,
+			schemaVersion: 2
+		};
+		const current = await options.vault.compareAndSwap(basis, refreshed, { migrateLegacy: legacy }) ? refreshed : await options.vault.load();
+		if (current === void 0) {
+			credentials = void 0;
+			token = "";
+			throw new QMindError("AUTH_REQUIRED", "credentials changed during refresh");
+		}
+		credentials = current;
+		token = current.deviceToken;
+		return token;
+	};
+	const manager = {
+		async getToken() {
+			if (token.length > 0) return token;
+			const candidate = explicitToken || credentials?.deviceToken || "";
+			if (candidate.length === 0) {
+				if (options.config.nonInteractive) throw new QMindError("AUTH_REQUIRED", `no credentials found; run '${options.loginCommand ?? "qmind login"}' in an interactive terminal`);
+				await login();
+				return token;
+			}
+			if (candidate.startsWith("pt-")) {
+				const raw = await authRequest(options.transport, "POST", "/api/v1/jobToken/exchange", "personal token exchange", { personal_token: candidate });
+				const parsed = personalTokenExchangeSchema.safeParse(raw);
+				if (!parsed.success) throw new QMindError("PROTOCOL_ERROR", "personal token exchange returned an invalid response");
+				token = parsed.data.token;
+				return token;
+			}
+			if (credentials !== void 0 && candidate === credentials.deviceToken && isExpired(credentials.expiresAt, options.clock.now(), EXPIRY_SKEW_MS)) return manager.refreshToken("expired", candidate);
+			token = candidate;
+			return token;
+		},
+		login,
+		async logout() {
+			await options.vault.delete();
+			credentials = void 0;
+			explicitToken = "";
+			token = "";
+			refreshPromise = void 0;
+		},
+		async refreshToken(reason, rejectedToken) {
+			if (rejectedToken !== void 0 && token.length > 0 && token !== rejectedToken) return token;
+			refreshPromise ??= refreshInternal(reason).finally(() => {
+				refreshPromise = void 0;
+			});
+			return await refreshPromise;
+		}
+	};
+	return Object.freeze(manager);
+}
+//#endregion
+//#region ../node-host/src/authenticated-transport.ts
+function withBearer(request, token) {
+	const headers = Object.fromEntries(Object.entries(request.headers ?? {}).filter(([name]) => name.toLowerCase() !== "authorization"));
+	return {
+		...request,
+		headers: {
+			...headers,
+			authorization: `Bearer ${token}`
+		}
+	};
+}
+/** A caller-supplied per-request bearer wins over process-level auth and skips refresh. */
+function hasRequestAuthorization(request) {
+	const headers = request.headers;
+	if (headers === void 0) return false;
+	return Object.keys(headers).some((name) => name.toLowerCase() === "authorization");
+}
+function hostCredentialRequired() {
+	return new QMindError("AUTH_REQUIRED", "The embedding host did not provide a credential for this request.");
+}
+function createAuthenticatedQMindTransport(transport, auth, requestCredential) {
+	return Object.freeze({
+		async request(request) {
+			if (request.destination.kind === "signed") return await transport.request(request);
+			const providedToken = (await requestCredential?.())?.trim();
+			if (providedToken) return await transport.request(withBearer(request, providedToken));
+			if (hasRequestAuthorization(request)) return await transport.request(request);
+			if (requestCredential !== void 0) throw hostCredentialRequired();
+			const token = await auth.getToken();
+			const response = await transport.request(withBearer(request, token));
+			if (response.status !== 401) return response;
+			const refreshed = await auth.refreshToken("unauthorized", token);
+			return await transport.request(withBearer(request, refreshed));
+		},
+		async stream(request) {
+			const providedToken = (await requestCredential?.())?.trim();
+			if (providedToken) return await transport.stream(withBearer(request, providedToken));
+			if (hasRequestAuthorization(request)) return await transport.stream(request);
+			if (requestCredential !== void 0) throw hostCredentialRequired();
+			const token = await auth.getToken();
+			const response = await transport.stream(withBearer(request, token));
+			if (response.kind !== "response" || response.status !== 401) return response;
+			const refreshed = await auth.refreshToken("unauthorized", token);
+			return await transport.stream(withBearer(request, refreshed));
+		}
+	});
+}
+//#endregion
+//#region ../node-host/src/config.ts
+const fileConfigSchema = z.object({
+	client: z.string().optional(),
+	dashboard_url: z.string().optional(),
+	proxy_from_env: z.boolean().optional(),
+	request_timeout_ms: z.number().int().positive().optional(),
+	sash_url: z.string().optional(),
+	stream_idle_timeout_ms: z.number().int().positive().optional(),
+	tls_ca_file: z.string().optional(),
+	tls_reject_unauthorized: z.boolean().optional(),
+	update_public_key: z.string().optional()
+}).passthrough();
+const PRESETS = Object.freeze({
+	daily: {
+		dashboardOrigin: "https://daily.qoder.ai",
+		sashOrigin: "https://daily-openapi.qoder.sh"
+	},
+	prod: {
+		dashboardOrigin: "https://qoder.com",
+		sashOrigin: "https://openapi.qoder.sh"
+	},
+	test: {
+		dashboardOrigin: "https://test.qoder.ai",
+		sashOrigin: "https://test-openapi.qoder.sh"
+	}
+});
+/**
+* Embedding product identity → that product's backends per environment. Two products share neither
+* dashboard nor Sash, so a host that declares its identity must be routed by it; falling back to the
+* environment table alone would send the second product's requests to the first product's backend,
+* which is indistinguishable from a correct call on the wire.
+*
+* Cells that no backend exists for yet are absent rather than borrowed: resolving one throws.
+*/
+const PRODUCT_PRESETS = Object.freeze({
+	qoder: PRESETS,
+	"qoder-cn": Object.freeze({
+		prod: {
+			dashboardOrigin: "https://qoder.cn",
+			sashOrigin: "https://openapi.qoder.com.cn"
+		},
+		test: {
+			dashboardOrigin: "https://test.qoder.com.cn",
+			sashOrigin: "https://test-openapi.qoder.com.cn"
+		}
+	})
+});
+function invalidConfig(message, field) {
+	return new QMindError("INVALID_ARGUMENT", message, { ...field === void 0 ? {} : { details: { field } } });
+}
+function normalizeQMindOrigin(rawValue, field) {
+	let url;
+	try {
+		url = new URL(rawValue);
+	} catch {
+		throw invalidConfig(`${field} must be a valid HTTP(S) origin`, field);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:" || url.username.length > 0 || url.password.length > 0 || url.pathname !== "/" || url.search.length > 0 || url.hash.length > 0) throw invalidConfig(`${field} must contain only an HTTP(S) scheme and authority`, field);
+	return url.origin;
+}
+/**
+* Resolves one registered product/environment without fallback. The default Host config loader
+* invokes this lazily after explicit overrides; fixed-product callers select the target up front.
+*/
+function resolveQMindProductEndpoints(productId, presetName, field = "env") {
+	const presets = Object.hasOwn(PRODUCT_PRESETS, productId) ? PRODUCT_PRESETS[productId] : void 0;
+	if (presets === void 0) throw invalidConfig(`no QMind endpoints are registered for product ${JSON.stringify(productId)}`, field);
+	const preset = Object.hasOwn(presets, presetName) ? presets[presetName] : void 0;
+	if (preset === void 0) throw invalidConfig(`product ${JSON.stringify(productId)} has no ${JSON.stringify(presetName)} endpoints; set ${field} explicitly`, field);
+	return { ...preset };
+}
+function optionalTrimmed(value) {
+	const trimmed = value?.trim();
+	return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
+}
+function parseBoolean(value, field) {
+	const normalized = optionalTrimmed(value)?.toLowerCase();
+	if (normalized === void 0) return void 0;
+	if (normalized === "1" || normalized === "true") return true;
+	if (normalized === "0" || normalized === "false") return false;
+	throw invalidConfig(`${field} must be 1, 0, true, or false`, field);
+}
+function parsePositiveInteger(value, field) {
+	const normalized = optionalTrimmed(value);
+	if (normalized === void 0) return void 0;
+	const parsed = Number(normalized);
+	if (!Number.isSafeInteger(parsed) || parsed <= 0) throw invalidConfig(`${field} must be a positive safe integer`, field);
+	return parsed;
+}
+function qmindEnvironmentAssignment(line) {
+	const trimmed = line.trim();
+	if (trimmed.length === 0 || trimmed.startsWith("#")) return void 0;
+	const assignment = trimmed.startsWith("export ") ? trimmed.slice(7) : trimmed;
+	const separator = assignment.indexOf("=");
+	if (separator < 1) return void 0;
+	const key = assignment.slice(0, separator).trim();
+	if (!/^QMIND_[A-Z0-9_]+$/.test(key)) return void 0;
+	let value = assignment.slice(separator + 1).trim();
+	if (value.length >= 2 && (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'"))) value = value.slice(1, -1);
+	return [key, value];
+}
+async function mergedEnvironment(environment, legacyEnvironmentPath) {
+	const merged = { ...environment };
+	if (legacyEnvironmentPath === false) return merged;
+	let content;
+	try {
+		content = await readFile(legacyEnvironmentPath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return merged;
+		throw invalidConfig("unable to read the legacy QMind environment file");
+	}
+	for (const line of content.split(/\r?\n/)) {
+		const parsed = qmindEnvironmentAssignment(line);
+		if (parsed === void 0) continue;
+		const [key, value] = parsed;
+		if (merged[key] === void 0) merged[key] = value;
+	}
+	return merged;
+}
+async function fileConfiguration(homeDirectory, fixedEndpoints = false) {
+	try {
+		return fileConfigSchema.parse(JSON.parse(await readFile(join(homeDirectory, "config.json"), "utf8")));
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		if (fixedEndpoints && error instanceof z.ZodError) {
+			const field = error.issues.find((issue) => issue.path[0] === "sash_url" || issue.path[0] === "dashboard_url")?.path[0];
+			if (field !== void 0) throw invalidEndpointHint(`config.json ${String(field)}`);
+		}
+		throw invalidConfig("stored QMind configuration is invalid");
+	}
+}
+function defaultProcessEnvironment() {
+	return process.env;
+}
+function invalidEndpointHint(field) {
+	return invalidConfig(`${field} is invalid or conflicts with the selected target; remove ${field} and select the target with --env or paired --sash/--dashboard`, field);
+}
+function validateFixedEndpoints(options, environment, file) {
+	const target = options.fixedEndpoints;
+	if (target === void 0) return;
+	const checkOrigin = (raw, expected, field, deprecated = true) => {
+		if (raw === void 0) return;
+		let normalized;
+		try {
+			normalized = normalizeQMindOrigin(raw.trim(), field);
+		} catch {
+			throw invalidEndpointHint(field);
+		}
+		if (normalized !== expected) throw invalidEndpointHint(field);
+		if (deprecated) options.reporter?.warn(`warning: ${field} is deprecated and does not select a target; remove ${field}`);
+	};
+	checkOrigin(environment.QMIND_SASH_URL, target.sashOrigin, "QMIND_SASH_URL");
+	checkOrigin(environment.QMIND_DASHBOARD_URL, target.dashboardOrigin, "QMIND_DASHBOARD_URL");
+	checkOrigin(file.sash_url, target.sashOrigin, "config.json sash_url");
+	checkOrigin(file.dashboard_url, target.dashboardOrigin, "config.json dashboard_url");
+	checkOrigin(options.credentialSashOrigin, target.sashOrigin, "credentials.json sash_url", false);
+	if (environment.QMIND_ENV !== void 0) {
+		let legacy;
+		try {
+			legacy = resolveQMindProductEndpoints(options.productId ?? "", environment.QMIND_ENV.trim());
+		} catch {
+			throw invalidEndpointHint("QMIND_ENV");
+		}
+		if (legacy.sashOrigin !== target.sashOrigin || legacy.dashboardOrigin !== target.dashboardOrigin) throw invalidEndpointHint("QMIND_ENV");
+		options.reporter?.warn("warning: QMIND_ENV is deprecated and does not select a target; remove QMIND_ENV");
+	}
+}
+async function loadQMindCliConfig(options = {}) {
+	const initialEnvironment = options.environment ?? defaultProcessEnvironment();
+	const baseHome = options.homeDirectory ?? homedir();
+	const environment = await mergedEnvironment(initialEnvironment, options.legacyEnvironmentPath === void 0 ? join(baseHome, ".qmind-env") : options.legacyEnvironmentPath);
+	const configuredHome = optionalTrimmed(environment.QMIND_HOME);
+	const homeDirectory = resolve(options.homeDirectory ?? configuredHome ?? join(baseHome, ".qmind"));
+	const file = await fileConfiguration(homeDirectory, options.fixedEndpoints !== void 0);
+	validateFixedEndpoints(options, environment, file);
+	const flags = options.flags ?? {};
+	const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY === true;
+	const presetName = optionalTrimmed(environment.QMIND_ENV) ?? "prod";
+	const productId = optionalTrimmed(options.productId);
+	const defaultOrigin = (field) => {
+		const preset = productId === void 0 ? PRESETS[presetName] ?? PRESETS.prod : resolveQMindProductEndpoints(productId, presetName, field);
+		return field === "sash" ? preset.sashOrigin : preset.dashboardOrigin;
+	};
+	if (options.fixedEndpoints === void 0 && productId === void 0 && !(presetName in PRESETS)) options.reporter?.warn(`warning: unknown QMIND_ENV ${JSON.stringify(presetName)}, falling back to prod`);
+	const sashOrigin = normalizeQMindOrigin(options.fixedEndpoints?.sashOrigin ?? optionalTrimmed(flags.sash) ?? optionalTrimmed(environment.QMIND_SASH_URL) ?? optionalTrimmed(file.sash_url) ?? optionalTrimmed(options.credentialSashOrigin) ?? defaultOrigin("sash"), "sash");
+	const dashboardOrigin = normalizeQMindOrigin(options.fixedEndpoints?.dashboardOrigin ?? optionalTrimmed(flags.dashboard) ?? optionalTrimmed(environment.QMIND_DASHBOARD_URL) ?? optionalTrimmed(file.dashboard_url) ?? defaultOrigin("dashboard"), "dashboard");
+	const runtime = Object.freeze({
+		client: optionalTrimmed(flags.client) ?? optionalTrimmed(environment.QMIND_CLIENT) ?? optionalTrimmed(file.client) ?? "qmind",
+		dashboardOrigin,
+		homeDirectory,
+		nonInteractive: flags.nonInteractive === true || parseBoolean(environment.QMIND_NON_INTERACTIVE, "QMIND_NON_INTERACTIVE") === true || !stdinIsTTY,
+		sashOrigin,
+		updatePublicKey: optionalTrimmed(environment.QMIND_UPDATE_PUBLIC_KEY) ?? optionalTrimmed(file.update_public_key) ?? ""
+	});
+	return {
+		debug: parseBoolean(environment.QMIND_DEBUG, "QMIND_DEBUG") ?? false,
+		environment,
+		proxyFromEnvironment: parseBoolean(environment.QMIND_PROXY_FROM_ENV, "QMIND_PROXY_FROM_ENV") ?? file.proxy_from_env ?? true,
+		requestTimeoutMs: parsePositiveInteger(environment.QMIND_REQUEST_TIMEOUT_MS, "QMIND_REQUEST_TIMEOUT_MS") ?? file.request_timeout_ms ?? 3e4,
+		runtime,
+		streamIdleTimeoutMs: parsePositiveInteger(environment.QMIND_STREAM_IDLE_TIMEOUT_MS, "QMIND_STREAM_IDLE_TIMEOUT_MS") ?? file.stream_idle_timeout_ms ?? 12e4,
+		...(() => {
+			const tlsCaFile = optionalTrimmed(environment.QMIND_TLS_CA_FILE) ?? optionalTrimmed(file.tls_ca_file);
+			return tlsCaFile === void 0 ? {} : { tlsCaFile };
+		})(),
+		tlsRejectUnauthorized: parseBoolean(environment.QMIND_TLS_REJECT_UNAUTHORIZED, "QMIND_TLS_REJECT_UNAUTHORIZED") ?? file.tls_reject_unauthorized ?? true,
+		token: optionalTrimmed(flags.token) ?? optionalTrimmed(environment.QMIND_TOKEN) ?? ""
+	};
+}
+//#endregion
+//#region ../node-host/src/credentials.ts
+const serializedCredentialsSchema = z.object({
+	device_token: z.string().default(""),
+	expires_at: z.string().default(""),
+	refresh_token: z.string().default(""),
+	refresh_token_expires_at: z.string().default(""),
+	sash_url: z.string().default(""),
+	saved_at: z.string().default(""),
+	schema_version: z.number().int().positive().optional()
+}).passthrough();
+function storedCredentialsInvalid() {
+	return new QMindError("AUTH_REQUIRED", "stored QMind credentials are invalid");
+}
+function isMissing(error) {
+	return error.code === "ENOENT";
+}
+function isValidOptionalTimestamp(value) {
+	return value.length === 0 || Number.isFinite(Date.parse(value));
+}
+function normalizeStoredCredentials(value) {
+	let parsed;
+	try {
+		parsed = serializedCredentialsSchema.parse(value);
+	} catch {
+		throw storedCredentialsInvalid();
+	}
+	if (parsed.schema_version !== void 0 && parsed.schema_version > 2 || parsed.device_token.length === 0 && parsed.refresh_token.length === 0 || !isValidOptionalTimestamp(parsed.expires_at) || !isValidOptionalTimestamp(parsed.refresh_token_expires_at)) throw storedCredentialsInvalid();
+	return {
+		deviceToken: parsed.device_token,
+		expiresAt: parsed.expires_at,
+		refreshToken: parsed.refresh_token,
+		refreshTokenExpiresAt: parsed.refresh_token_expires_at,
+		sashOrigin: parsed.sash_url,
+		savedAt: parsed.saved_at,
+		schemaVersion: parsed.schema_version ?? 1
+	};
+}
+function serializedCredentials(credentials, now) {
+	return `${JSON.stringify({
+		device_token: credentials.deviceToken,
+		expires_at: credentials.expiresAt,
+		refresh_token: credentials.refreshToken,
+		refresh_token_expires_at: credentials.refreshTokenExpiresAt,
+		sash_url: credentials.sashOrigin,
+		saved_at: new Date(now).toISOString().replace(/\.\d{3}Z$/, "Z"),
+		schema_version: 2
+	}, null, 2)}\n`;
+}
+function sameCredentials(left, right) {
+	return left !== void 0 && right !== void 0 && left.deviceToken === right.deviceToken && left.expiresAt === right.expiresAt && left.refreshToken === right.refreshToken && left.refreshTokenExpiresAt === right.refreshTokenExpiresAt && left.sashOrigin === right.sashOrigin && left.schemaVersion === right.schemaVersion;
+}
+async function secureDirectory(path) {
+	await mkdir(path, {
+		mode: 448,
+		recursive: true
+	});
+	const info = await lstat(path);
+	if (!info.isDirectory() || info.isSymbolicLink()) throw storedCredentialsInvalid();
+	if (process.platform !== "win32") await chmod(path, 448);
+}
+async function secureRegularFile(path) {
+	const info = await lstat(path);
+	if (!info.isFile() || info.isSymbolicLink()) throw storedCredentialsInvalid();
+	if (process.platform !== "win32" && (info.mode & 63) !== 0) await chmod(path, 384);
+}
+async function replaceFileAtomically(tempPath, targetPath) {
+	try {
+		await rename(tempPath, targetPath);
+		return;
+	} catch (error) {
+		if (process.platform !== "win32") throw error;
+	}
+	const backupPath = `${targetPath}.${randomBytes(6).toString("hex")}.old`;
+	let backedUp = false;
+	try {
+		try {
+			await rename(targetPath, backupPath);
+			backedUp = true;
+		} catch (error) {
+			if (!isMissing(error)) throw error;
+		}
+		await rename(tempPath, targetPath);
+		if (backedUp) await rm(backupPath, { force: true });
+	} catch (error) {
+		if (backedUp) await rename(backupPath, targetPath).catch(() => void 0);
+		throw error;
+	}
+}
+async function optionalSecret(operation, fallback) {
+	try {
+		return await operation();
+	} catch {
+		return fallback;
+	}
+}
+function createNoopQMindSecretStore() {
+	return Object.freeze({
+		async delete() {},
+		async get() {},
+		async set(_token) {}
+	});
+}
+function createFileCredentialVault(options) {
+	const credentialsPath = join(options.homeDirectory, "credentials.json");
+	const legacyBackupPath = `${credentialsPath}.v1.bak`;
+	const secretStore = options.secretStore ?? createNoopQMindSecretStore();
+	const now = options.now ?? Date.now;
+	const loadUnlocked = async () => {
+		let serialized;
+		try {
+			await secureRegularFile(credentialsPath);
+			serialized = JSON.parse(await readFile(credentialsPath, "utf8"));
+		} catch (error) {
+			if (isMissing(error)) return void 0;
+			if (error instanceof QMindError) throw error;
+			throw storedCredentialsInvalid();
+		}
+		const credentials = normalizeStoredCredentials(serialized);
+		const keychainToken = await optionalSecret(() => secretStore.get(), void 0);
+		return keychainToken === void 0 || keychainToken.length === 0 ? credentials : {
+			...credentials,
+			deviceToken: keychainToken
+		};
+	};
+	const withLock = async (operation) => {
+		await secureDirectory(options.homeDirectory);
+		const release = await lockfile.lock(options.homeDirectory, {
+			lockfilePath: join(options.homeDirectory, ".credentials.lock"),
+			realpath: false,
+			retries: {
+				factor: 1.5,
+				maxTimeout: 100,
+				minTimeout: 20,
+				retries: 8
+			},
+			stale: 1e4
+		});
+		try {
+			return await operation();
+		} finally {
+			await release();
+		}
+	};
+	const persist = async (credentials, saveOptions = {}) => {
+		const tempPath = `${credentialsPath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+		try {
+			if (saveOptions.migrateLegacy === true) try {
+				await secureRegularFile(credentialsPath);
+				await copyFile(credentialsPath, legacyBackupPath);
+				if (process.platform !== "win32") await chmod(legacyBackupPath, 384);
+			} catch (error) {
+				if (!isMissing(error)) throw error;
+			}
+			await writeFile(tempPath, serializedCredentials(credentials, now()), {
+				flag: "wx",
+				mode: 384
+			});
+			if (process.platform !== "win32") await chmod(tempPath, 384);
+			await replaceFileAtomically(tempPath, credentialsPath);
+			if (process.platform !== "win32") await chmod(credentialsPath, 384);
+			await optionalSecret(() => secretStore.set(credentials.deviceToken), void 0);
+		} finally {
+			await rm(tempPath, { force: true });
+		}
+	};
+	const deleteUnlocked = async () => {
+		await Promise.all([rm(credentialsPath, { force: true }), rm(legacyBackupPath, { force: true })]);
+		await optionalSecret(() => secretStore.delete(), void 0);
+	};
+	return Object.freeze({
+		async compareAndSwap(expected, credentials, saveOptions = {}) {
+			return await withLock(async () => {
+				if (!sameCredentials(await loadUnlocked(), expected)) return false;
+				await persist(credentials, saveOptions);
+				return true;
+			});
+		},
+		async delete() {
+			await withLock(deleteUnlocked);
+		},
+		async deleteIf(expected) {
+			return await withLock(async () => {
+				if (!sameCredentials(await loadUnlocked(), expected)) return false;
+				await deleteUnlocked();
+				return true;
+			});
+		},
+		async load() {
+			return await loadUnlocked();
+		},
+		async save(credentials, saveOptions = {}) {
+			await withLock(async () => persist(credentials, saveOptions));
+		}
+	});
+}
+//#endregion
+//#region ../node-host/src/files.ts
+function safeQMindDownloadName(title, fallback) {
+	const normalized = [...title.normalize("NFKC")].map((character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		return codePoint <= 31 || codePoint === 127 ? "_" : character;
+	}).join("").replace(/[\\/]/g, "_").replace(/^\.+$/, "").trim().slice(0, 240);
+	const safe = basename(normalized);
+	if (safe.length > 0 && safe !== "." && safe !== "..") return safe;
+	return basename(fallback.replace(/[\\/]/g, "_")) || "download";
+}
+async function commitQMindTemporaryFile(temporary, path, overwrite) {
+	if (!overwrite) {
+		await link(temporary, path).catch((error) => {
+			if (error.code === "EEXIST") throw new QMindError("CONFLICT", `target already exists: ${path}`);
+			throw error;
+		});
+		await rm(temporary, { force: true });
+		return;
+	}
+	if (process.platform !== "win32") {
+		await rename(temporary, path);
+		return;
+	}
+	const backup = `${path}.${randomBytes(8).toString("hex")}.old`;
+	let backedUp = false;
+	try {
+		try {
+			await rename(path, backup);
+			backedUp = true;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await rename(temporary, path);
+		if (backedUp) await rm(backup, { force: true });
+	} catch (error) {
+		if (backedUp) await rename(backup, path).catch(() => void 0);
+		throw error;
+	}
+}
+/** Atomic write with a no-clobber default. Temporary files are always cleaned. */
+async function atomicQMindWrite(path, content, overwrite = false) {
+	await mkdir(dirname(path), { recursive: true });
+	const temporary = join(dirname(path), `.${basename(path)}.${randomBytes(8).toString("hex")}.tmp`);
+	try {
+		await writeFile(temporary, content, {
+			flag: "wx",
+			mode: 420
+		});
+		await commitQMindTemporaryFile(temporary, path, overwrite);
+	} catch (error) {
+		await rm(temporary, { force: true });
+		throw error;
+	}
+}
+//#endregion
+//#region ../node-host/src/node-transport.ts
+const RETRYABLE_STATUS = /* @__PURE__ */ new Set([
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+const CREDENTIAL_HEADERS = /* @__PURE__ */ new Set([
+	"authorization",
+	"cookie",
+	"proxy-authorization",
+	"x-csrf-token",
+	"x-xsrf-token"
+]);
+const SSE_MAX_BUFFER_SIZE = 8388608;
+function invalidArgument(message, field) {
+	return new QMindError("INVALID_ARGUMENT", message, { details: { field } });
+}
+function positiveInteger(value, fallback, field) {
+	if (value === void 0) return fallback;
+	if (!Number.isSafeInteger(value) || value <= 0) throw invalidArgument(`${field} must be a positive safe integer`, field);
+	return value;
+}
+function nonNegativeInteger(value, fallback, field) {
+	if (value === void 0) return fallback;
+	if (!Number.isSafeInteger(value) || value < 0) throw invalidArgument(`${field} must be a non-negative safe integer`, field);
+	return value;
+}
+function normalizeOrigin(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw invalidArgument("origin must be a valid HTTP(S) origin", "origin");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:" || url.username.length > 0 || url.password.length > 0 || url.pathname !== "/" || url.search.length > 0 || url.hash.length > 0) throw invalidArgument("origin must contain only an HTTP(S) scheme and authority", "origin");
+	return url;
+}
+function environmentValue(environment, ...keys) {
+	for (const key of keys) {
+		const value = environment[key]?.trim();
+		if (value !== void 0 && value.length > 0) return value;
+	}
+}
+function tlsConnectOptions(options, withTls) {
+	const timeout = positiveInteger(options.connectTimeoutMs, 1e4, "connectTimeoutMs");
+	if (!withTls) return { timeout };
+	const ca = options.tls?.ca;
+	return {
+		...ca === void 0 ? {} : { ca: typeof ca === "string" ? ca : [...ca] },
+		rejectUnauthorized: options.tls?.rejectUnauthorized ?? true,
+		timeout
+	};
+}
+function createDispatchers(options) {
+	const environment = options.environment ?? process.env;
+	if (options.proxyFromEnvironment === false) return {
+		host: new Agent({ connect: tlsConnectOptions(options, true) }),
+		signed: new Agent({ connect: tlsConnectOptions(options, true) })
+	};
+	const httpProxy = environmentValue(environment, "HTTP_PROXY", "http_proxy");
+	const httpsProxy = environmentValue(environment, "HTTPS_PROXY", "https_proxy");
+	const noProxy = environmentValue(environment, "NO_PROXY", "no_proxy");
+	if (httpProxy === void 0 && httpsProxy === void 0) return {
+		host: new Agent({ connect: tlsConnectOptions(options, true) }),
+		signed: new Agent({ connect: tlsConnectOptions(options, true) })
+	};
+	const proxy = {
+		httpProxy: httpProxy ?? "",
+		httpsProxy: httpsProxy ?? "",
+		noProxy: noProxy ?? ""
+	};
+	return {
+		host: new EnvHttpProxyAgent({
+			...proxy,
+			requestTls: tlsConnectOptions(options, true)
+		}),
+		signed: new EnvHttpProxyAgent({
+			...proxy,
+			requestTls: tlsConnectOptions(options, true)
+		})
+	};
+}
+function headersToRecord(headers) {
+	const result = {};
+	for (const [name, value] of Object.entries(headers)) {
+		if (value === void 0) continue;
+		result[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+	}
+	return result;
+}
+function normalizedRequestHeaders(headers) {
+	const result = {};
+	for (const [name, value] of Object.entries(headers ?? {})) result[name.toLowerCase()] = value;
+	return result;
+}
+function parseRawBody(rawBody) {
+	if (rawBody.trim().length === 0) return void 0;
+	try {
+		return JSON.parse(rawBody);
+	} catch {
+		return rawBody;
+	}
+}
+async function wireResponse(response) {
+	const rawBody = await response.body.text();
+	return {
+		body: parseRawBody(rawBody),
+		headers: headersToRecord(response.headers),
+		rawBody,
+		status: response.statusCode
+	};
+}
+function assertWireRequest(request) {
+	if (request.timeoutMs !== void 0) positiveInteger(request.timeoutMs, request.timeoutMs, "timeoutMs");
+	if (request.destination.kind === "host") {
+		if (!request.destination.path.startsWith("/") || request.destination.path.startsWith("//")) throw new QMindError("HOST_POLICY_ERROR", "host destination must be root-relative");
+		return;
+	}
+	let url;
+	try {
+		url = new URL(request.destination.url);
+	} catch {
+		throw new QMindError("HOST_POLICY_ERROR", "signed destination must be valid HTTPS");
+	}
+	if (url.protocol !== "https:" || url.username.length > 0 || url.password.length > 0) throw new QMindError("HOST_POLICY_ERROR", "signed destination must be credential-free HTTPS");
+	for (const name of Object.keys(request.headers ?? {})) if (CREDENTIAL_HEADERS.has(name.toLowerCase())) throw new QMindError("HOST_POLICY_ERROR", "host credentials cannot reach a signed URL", { details: { header: name.toLowerCase() } });
+}
+function sourceFailure(message, source, yieldedBytes) {
+	return new QMindError("HOST_POLICY_ERROR", message, { details: {
+		filename: source.filename,
+		size: source.size,
+		...yieldedBytes === void 0 ? {} : { yieldedBytes }
+	} });
+}
+function assertSource(source) {
+	if (!Number.isSafeInteger(source.size) || source.size <= 0 || typeof source.open !== "function") throw sourceFailure("binary source metadata is invalid", source);
+}
+async function* sourceBytes(source, signal, onProgress) {
+	assertSource(source);
+	let bytes = 0;
+	for await (const chunk of source.open()) {
+		if (signal?.aborted === true) throw signal.reason;
+		if (!(chunk instanceof Uint8Array)) throw sourceFailure("binary source yielded a non-Uint8Array chunk", source, bytes);
+		bytes += chunk.byteLength;
+		if (bytes > source.size) throw sourceFailure("binary source yielded more bytes than declared", source, bytes);
+		yield chunk;
+		onProgress?.(bytes);
+	}
+	if (bytes !== source.size) throw sourceFailure("binary source yielded fewer bytes than declared", source, bytes);
+}
+function quoteDisposition(value) {
+	return value.replace(/["\r\n]/g, "_");
+}
+function multipartPart(name, value, boundary) {
+	return `--${boundary}\r\nContent-Disposition: form-data; name="${quoteDisposition(name)}"\r\n\r\n${value}\r\n`;
+}
+function multipartPreamble(source, boundary) {
+	return `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${quoteDisposition(source.filename)}"\r\nContent-Type: ${source.mimeType}\r\n\r\n`;
+}
+function byteLength(value) {
+	return Buffer.byteLength(value, "utf8");
+}
+function encodeBody(request, boundary) {
+	const initialHeaders = normalizedRequestHeaders(request.headers);
+	const body = request.body;
+	if (body === void 0) return { headers: initialHeaders };
+	if (body.kind === "json") {
+		initialHeaders["content-type"] ??= "application/json";
+		return {
+			body: JSON.stringify(body.value),
+			headers: initialHeaders
+		};
+	}
+	if (body.kind === "binary") {
+		assertSource(body.source);
+		initialHeaders["content-type"] ??= body.source.mimeType;
+		initialHeaders["content-length"] = String(body.source.size);
+		return {
+			body: Readable.from(sourceBytes(body.source, request.signal, body.onProgress)),
+			headers: initialHeaders
+		};
+	}
+	const multipartBody = body;
+	assertSource(multipartBody.file);
+	const fieldParts = Object.entries(multipartBody.fields).map(([name, value]) => multipartPart(name, value, boundary));
+	const preamble = multipartPreamble(multipartBody.file, boundary);
+	const closing = `\r\n--${boundary}--\r\n`;
+	const contentLength = fieldParts.reduce((total, part) => total + byteLength(part), 0) + byteLength(preamble) + multipartBody.file.size + byteLength(closing);
+	async function* multipart() {
+		for (const part of fieldParts) yield Buffer.from(part);
+		yield Buffer.from(preamble);
+		yield* sourceBytes(multipartBody.file, request.signal, multipartBody.onProgress);
+		yield Buffer.from(closing);
+	}
+	initialHeaders["content-type"] = `multipart/form-data; boundary=${boundary}`;
+	initialHeaders["content-length"] = String(contentLength);
+	return {
+		body: Readable.from(multipart()),
+		headers: initialHeaders
+	};
+}
+function isTimeoutCause(cause) {
+	const code = cause.code;
+	const name = cause.name;
+	return code === "QMIND_REQUEST_TIMEOUT" || code === "UND_ERR_CONNECT_TIMEOUT" || code === "UND_ERR_HEADERS_TIMEOUT" || code === "UND_ERR_BODY_TIMEOUT" || name === "TimeoutError";
+}
+function safeCause(cause) {
+	const record = cause;
+	return {
+		...typeof record.name === "string" ? { name: record.name } : {},
+		...typeof record.code === "string" ? { code: record.code } : {}
+	};
+}
+function transportFailure(request, cause, deadlineExpired = false) {
+	if (cause instanceof QMindError) return cause;
+	if (request.signal?.aborted === true) return new QMindError("ABORTED", "QMind request was aborted");
+	if (deadlineExpired || isTimeoutCause(cause)) return new QMindError("TIMEOUT", "QMind request timed out", { cause: safeCause(cause) });
+	return new QMindError("NETWORK_ERROR", "QMind network request failed", { cause: safeCause(cause) });
+}
+function requestDeadline(signal, milliseconds) {
+	const controller = new AbortController();
+	let timedOut = false;
+	const timeout = setTimeout(() => {
+		timedOut = true;
+		const error = Object.assign(/* @__PURE__ */ new Error("QMind request deadline expired"), {
+			code: "QMIND_REQUEST_TIMEOUT",
+			name: "TimeoutError"
+		});
+		controller.abort(error);
+	}, milliseconds);
+	timeout.unref();
+	const onAbort = () => controller.abort(signal?.reason);
+	if (signal?.aborted === true) onAbort();
+	else signal?.addEventListener("abort", onAbort, { once: true });
+	const clearDeadline = () => clearTimeout(timeout);
+	return {
+		clearTimeout: clearDeadline,
+		dispose() {
+			clearDeadline();
+			signal?.removeEventListener("abort", onAbort);
+		},
+		signal: controller.signal,
+		get timedOut() {
+			return timedOut;
+		}
+	};
+}
+function abortableSleep(milliseconds, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted === true) {
+			reject(signal.reason);
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, milliseconds);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function requestUrl(origin, request) {
+	return request.destination.kind === "host" ? new URL(request.destination.path, origin) : new URL(request.destination.url);
+}
+function debugRequest(options, request, url) {
+	options.debugLog?.(`[qmind-debug] ${request.method} ${url.origin}${url.pathname}`);
+}
+async function* decodedEvents(body, request, disposeSignal) {
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	const pending = [];
+	let done = false;
+	let parserFailure;
+	const parser = createParser({
+		maxBufferSize: SSE_MAX_BUFFER_SIZE,
+		onError(error) {
+			if (error.type === "max-buffer-size-exceeded") parserFailure = error;
+		},
+		onEvent(event) {
+			if (event.data.trim() === "[DONE]") done = true;
+			else pending.push(event.data);
+		}
+	});
+	const drain = function* () {
+		while (pending.length > 0) {
+			const value = pending.shift();
+			if (value !== void 0) yield value;
+		}
+	};
+	try {
+		for await (const chunk of body) {
+			parser.feed(decoder.decode(chunk, { stream: true }));
+			if (parserFailure !== void 0) throw new QMindError("STREAM_ERROR", "SSE parser buffer limit exceeded", { details: { limitBytes: SSE_MAX_BUFFER_SIZE } });
+			yield* drain();
+			if (done) return;
+		}
+		parser.feed(decoder.decode());
+		parser.reset({ consume: true });
+		if (parserFailure !== void 0) throw new QMindError("STREAM_ERROR", "SSE parser buffer limit exceeded", { details: { limitBytes: SSE_MAX_BUFFER_SIZE } });
+		yield* drain();
+	} catch (cause) {
+		if (cause instanceof QMindError) throw cause;
+		if (request.signal?.aborted === true) throw new QMindError("ABORTED", "QMind stream was aborted");
+		if (isTimeoutCause(cause)) throw new QMindError("TIMEOUT", "QMind stream timed out", { cause: safeCause(cause) });
+		throw new QMindError("STREAM_ERROR", "QMind SSE stream failed", { cause: safeCause(cause) });
+	} finally {
+		disposeSignal();
+		body.destroy();
+	}
+}
+function createQMindNodeTransport(options) {
+	const origin = normalizeOrigin(options.origin);
+	const requestTimeoutMs = positiveInteger(options.requestTimeoutMs, 3e4, "requestTimeoutMs");
+	const streamIdleTimeoutMs = positiveInteger(options.streamIdleTimeoutMs, 12e4, "streamIdleTimeoutMs");
+	const maxRetries = nonNegativeInteger(options.maxRetries, 2, "maxRetries");
+	const dispatchers = createDispatchers(options);
+	const dispatcherFor = (request) => request.destination.kind === "host" ? dispatchers.host : dispatchers.signed;
+	return Object.freeze({
+		async close() {
+			const unique = /* @__PURE__ */ new Set([dispatchers.host, dispatchers.signed]);
+			await Promise.all([...unique].map(async (dispatcher) => dispatcher.close()));
+		},
+		async downloadToFile(download) {
+			const request$1 = {
+				destination: {
+					kind: "signed",
+					url: download.url
+				},
+				idempotent: true,
+				method: "GET",
+				...download.signal === void 0 ? {} : { signal: download.signal }
+			};
+			assertWireRequest(request$1);
+			const url = requestUrl(origin, request$1);
+			await mkdir(dirname(download.targetPath), { recursive: true });
+			if (download.overwrite !== true) try {
+				await stat(download.targetPath);
+				throw new QMindError("CONFLICT", `target already exists: ${download.targetPath}`);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+			const temporary = join(dirname(download.targetPath), `.${basename(download.targetPath)}.${randomBytes(8).toString("hex")}.tmp`);
+			let response;
+			try {
+				response = await request(url, {
+					bodyTimeout: requestTimeoutMs,
+					dispatcher: dispatchers.signed,
+					headersTimeout: requestTimeoutMs,
+					idempotent: true,
+					method: "GET",
+					...download.signal === void 0 ? {} : { signal: download.signal }
+				});
+				if (response.statusCode < 200 || response.statusCode >= 300) {
+					const decoded = await wireResponse(response);
+					throw new QMindError("REMOTE_ERROR", "download request failed", {
+						...decoded.rawBody === void 0 ? {} : { rawBody: decoded.rawBody },
+						status: decoded.status
+					});
+				}
+				await pipeline(response.body, createWriteStream(temporary, {
+					flags: "wx",
+					mode: 384
+				}));
+				const size = (await stat(temporary)).size;
+				await chmod(temporary, 420);
+				await commitQMindTemporaryFile(temporary, download.targetPath, download.overwrite === true);
+				return size;
+			} catch (cause) {
+				response?.body.destroy();
+				await rm(temporary, { force: true });
+				if (cause instanceof QMindError) throw cause;
+				throw transportFailure(request$1, cause);
+			}
+		},
+		async request(request$2) {
+			assertWireRequest(request$2);
+			const url = requestUrl(origin, request$2);
+			const attempts = request$2.idempotent ? maxRetries + 1 : 1;
+			let lastFailure;
+			let lastDeadlineExpired = false;
+			for (let attempt = 0; attempt < attempts; attempt += 1) {
+				const deadline = requestDeadline(request$2.signal, request$2.timeoutMs ?? requestTimeoutMs);
+				try {
+					debugRequest(options, request$2, url);
+					const encoded = encodeBody(request$2, `----qmind-${randomBytes(18).toString("hex")}`);
+					const response = await request(url, {
+						...encoded.body === void 0 ? {} : { body: encoded.body },
+						bodyTimeout: request$2.timeoutMs ?? requestTimeoutMs,
+						dispatcher: dispatcherFor(request$2),
+						headers: encoded.headers,
+						headersTimeout: request$2.timeoutMs ?? requestTimeoutMs,
+						idempotent: request$2.idempotent,
+						method: request$2.method,
+						signal: deadline.signal
+					});
+					if (attempt + 1 < attempts && RETRYABLE_STATUS.has(response.statusCode)) {
+						await response.body.dump();
+						await abortableSleep(250 * 2 ** attempt, request$2.signal);
+						continue;
+					}
+					return await wireResponse(response);
+				} catch (cause) {
+					lastFailure = cause;
+					lastDeadlineExpired = deadline.timedOut;
+					if (attempt + 1 < attempts && request$2.signal?.aborted !== true) {
+						await abortableSleep(250 * 2 ** attempt, request$2.signal);
+						continue;
+					}
+				} finally {
+					deadline.dispose();
+				}
+			}
+			throw transportFailure(request$2, lastFailure, lastDeadlineExpired);
+		},
+		async stream(request$3) {
+			assertWireRequest(request$3);
+			const url = requestUrl(origin, request$3);
+			debugRequest(options, request$3, url);
+			const encoded = encodeBody(request$3, `----qmind-${randomBytes(18).toString("hex")}`);
+			let response;
+			const deadline = requestDeadline(request$3.signal, request$3.timeoutMs ?? requestTimeoutMs);
+			try {
+				response = await request(url, {
+					...encoded.body === void 0 ? {} : { body: encoded.body },
+					bodyTimeout: streamIdleTimeoutMs,
+					dispatcher: dispatchers.host,
+					headers: {
+						accept: "text/event-stream",
+						...encoded.headers
+					},
+					headersTimeout: request$3.timeoutMs ?? requestTimeoutMs,
+					idempotent: request$3.idempotent,
+					method: request$3.method,
+					signal: deadline.signal
+				});
+			} catch (cause) {
+				deadline.dispose();
+				throw transportFailure(request$3, cause, deadline.timedOut);
+			}
+			deadline.clearTimeout();
+			const headers = headersToRecord(response.headers);
+			if (response.statusCode < 200 || response.statusCode >= 300 || !headers["content-type"]?.toLowerCase().includes("text/event-stream")) try {
+				return {
+					...await wireResponse(response),
+					kind: "response"
+				};
+			} finally {
+				deadline.dispose();
+			}
+			return {
+				events: decodedEvents(response.body, request$3, deadline.dispose),
+				headers,
+				kind: "events",
+				status: response.statusCode
+			};
+		}
+	});
+}
+const MIME_TYPES = Object.freeze({
+	".csv": "text/csv",
+	".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	".gif": "image/gif",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".md": "text/markdown",
+	".mdx": "text/markdown",
+	".pdf": "application/pdf",
+	".png": "image/png",
+	".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	".svg": "image/svg+xml",
+	".txt": "text/plain",
+	".webp": "image/webp",
+	".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+});
+function detectQMindMimeType(filename) {
+	return MIME_TYPES[extname(filename).toLowerCase()] ?? "application/octet-stream";
+}
+async function createQMindFileSource(path, options = {}) {
+	let info;
+	try {
+		info = await stat(path);
+	} catch {
+		throw invalidArgument("source path must reference a readable file", "path");
+	}
+	if (!info.isFile() || info.size <= 0) throw invalidArgument("source path must reference a non-empty regular file", "path");
+	const filename = options.filename?.trim() || basename(path);
+	const mimeType = options.mimeType?.trim() || detectQMindMimeType(filename);
+	return Object.freeze({
+		filename,
+		mimeType,
+		async *open() {
+			for await (const chunk of createReadStream(path)) yield chunk;
+		},
+		size: info.size
+	});
+}
+//#endregion
+//#region ../node-host/src/host.ts
+function defaultReporter() {
+	return Object.freeze({
+		info(message) {
+			console.error(message);
+		},
+		warn(message) {
+			console.error(message);
+		}
+	});
+}
+function defaultBrowser() {
+	return Object.freeze({ async open(url) {
+		(await open(url, { wait: false })).unref();
+	} });
+}
+async function tlsAuthority(path) {
+	if (path === void 0) return void 0;
+	try {
+		return await readFile(path, "utf8");
+	} catch {
+		throw new QMindError("HOST_POLICY_ERROR", "unable to read the configured TLS CA file", { details: { field: "tlsCaFile" } });
+	}
+}
+function configurationOptions(options, reporter) {
+	return {
+		...options.credentialSashOrigin === void 0 ? {} : { credentialSashOrigin: options.credentialSashOrigin },
+		...options.environment === void 0 ? {} : { environment: options.environment },
+		...options.flags === void 0 ? {} : { flags: options.flags },
+		...options.fixedEndpoints === void 0 ? {} : { fixedEndpoints: options.fixedEndpoints },
+		...options.homeDirectory === void 0 ? {} : { homeDirectory: options.homeDirectory },
+		...options.legacyEnvironmentPath === void 0 ? {} : { legacyEnvironmentPath: options.legacyEnvironmentPath },
+		...options.productId === void 0 ? {} : { productId: options.productId },
+		...reporter === void 0 ? {} : { reporter },
+		...options.stdinIsTTY === void 0 ? {} : { stdinIsTTY: options.stdinIsTTY }
+	};
+}
+async function createQMindCliHost(options = {}) {
+	const reporter = options.adapters?.reporter ?? defaultReporter();
+	const clock = options.adapters?.clock ?? createSystemClock();
+	const vault = createFileCredentialVault({
+		homeDirectory: (await loadQMindCliConfig(configurationOptions(options))).runtime.homeDirectory,
+		now: () => clock.now(),
+		secretStore: options.adapters?.secretStore ?? createNoopQMindSecretStore()
+	});
+	let credentials;
+	try {
+		credentials = await vault.load();
+	} catch (error) {
+		if (options.credentialReadFailure !== "unauthenticated") throw error;
+		reporter.warn("QMind credential vault is unavailable; authentication is required.");
+		credentials = void 0;
+	}
+	const resolved = await loadQMindCliConfig({
+		...configurationOptions(options, reporter),
+		...options.adapters?.requestCredential === void 0 && credentials?.sashOrigin ? { credentialSashOrigin: credentials.sashOrigin } : {},
+		reporter
+	});
+	const ca = await tlsAuthority(resolved.tlsCaFile);
+	const nodeOptions = {
+		...options.connectTimeoutMs === void 0 ? {} : { connectTimeoutMs: options.connectTimeoutMs },
+		...resolved.debug ? { debugLog: (message) => reporter.info(message) } : {},
+		environment: resolved.environment,
+		...options.maxRetries === void 0 ? {} : { maxRetries: options.maxRetries },
+		origin: resolved.runtime.sashOrigin,
+		proxyFromEnvironment: resolved.proxyFromEnvironment,
+		requestTimeoutMs: resolved.requestTimeoutMs,
+		streamIdleTimeoutMs: resolved.streamIdleTimeoutMs,
+		tls: {
+			...ca === void 0 ? {} : { ca },
+			rejectUnauthorized: resolved.tlsRejectUnauthorized
+		}
+	};
+	const ownedTransport = options.adapters?.transport === void 0 ? createQMindNodeTransport(nodeOptions) : void 0;
+	const rawTransport = options.adapters?.transport ?? ownedTransport;
+	if (rawTransport === void 0) throw new QMindError("HOST_POLICY_ERROR", "unable to initialize the QMind transport");
+	const auth = createQMindCliAuthManager({
+		browser: options.adapters?.browser ?? defaultBrowser(),
+		clock,
+		config: resolved.runtime,
+		credentials,
+		explicitToken: resolved.token,
+		...options.loginCommand === void 0 ? {} : { loginCommand: options.loginCommand },
+		reporter,
+		transport: rawTransport,
+		vault
+	});
+	const client = createQMindClient({
+		access: "sash",
+		client: resolved.runtime.client,
+		transport: createAuthenticatedQMindTransport(rawTransport, auth, options.adapters?.requestCredential)
+	});
+	return Object.freeze({
+		client,
+		async close() {
+			await ownedTransport?.close();
+		},
+		config: resolved.runtime,
+		createFileSource: createQMindFileSource,
+		async downloadToFile(downloadOptions) {
+			const downloader = options.adapters?.downloader ?? ownedTransport;
+			if (downloader === void 0) throw new QMindError("UNSUPPORTED_OPERATION", "the injected CLI transport does not provide file downloads");
+			return await downloader.downloadToFile(downloadOptions);
+		},
+		login: auth.login,
+		logout: auth.logout
+	});
+}
+//#endregion
+//#region src/argv.ts
+const SHORT_OPTIONS = /* @__PURE__ */ new Set([
+	"-h",
+	"-V",
+	"-o",
+	"-q"
+]);
+/**
+* Preserve the historical Go CLI spelling where long options used one dash.
+* The delimiter is an intentional hard boundary: everything after `--` is a
+* positional value and must remain byte-for-byte unchanged.
+*/
+function normalizeLegacyArgv(argv) {
+	let positionalOnly = false;
+	return argv.map((argument) => {
+		if (argument === "--") {
+			positionalOnly = true;
+			return argument;
+		}
+		if (positionalOnly || SHORT_OPTIONS.has(argument) || argument.startsWith("--")) return argument;
+		if (/^-[A-Za-z][A-Za-z0-9-]+(?:=.*)?$/.test(argument)) return `-${argument}`;
+		return argument;
+	});
+}
+/** Runtime errors use the JSON error envelope only when the caller explicitly
+* selected JSON, except folder sync whose compatibility default is JSON. */
+function requestsJsonOutput(argv) {
+	let explicitFormat;
+	let positionalOnly = false;
+	for (let index = 0; index < argv.length; index += 1) {
+		const argument = argv[index];
+		if (argument === "--") {
+			positionalOnly = true;
+			continue;
+		}
+		if (positionalOnly) continue;
+		if (argument === "--format" || argument === "-format") {
+			explicitFormat = argv[index + 1];
+			index += 1;
+			continue;
+		}
+		const match = argument?.match(/^--?format=(.*)$/);
+		if (match !== null && match !== void 0) explicitFormat = match[1];
+	}
+	if (explicitFormat !== void 0) return explicitFormat === "json";
+	return argv[0] === "upload-folder" || argv[0] === "sync";
+}
+//#endregion
+//#region src/build-info.ts
+const QMIND_CLI_VERSION = "3.0.0";
+const QMIND_CLI_BUILD_TIME = "2026-09-01T07:33:25.000Z";
+function qmindCliPlatform() {
+	return process.platform === "win32" ? "windows" : process.platform;
+}
+function qmindCliArchitecture() {
+	return process.arch === "x64" ? "amd64" : process.arch;
+}
+//#endregion
+//#region src/distributions.ts
+/** Canonical runtime and release identity for every public CLI distribution. */
+const CLI_DISTRIBUTIONS = Object.freeze({
+	global: {
+		id: "global",
+		command: "qmind",
+		package: "@qoder-ai/qmind-cli",
+		productId: "qoder",
+		gitTagSlug: "qmind-cli",
+		readmeDirectory: ".",
+		productNames: {
+			en: "Qoder Global",
+			zhCN: "Qoder Global"
+		}
+	},
+	cn: {
+		id: "cn",
+		command: "qmind-cn",
+		package: "@qodercn-ai/qmind-cli",
+		productId: "qoder-cn",
+		gitTagSlug: "qmind-cli-cn",
+		readmeDirectory: "readmes/cn",
+		productNames: {
+			en: "Qoder China",
+			zhCN: "Qoder 中国版"
+		}
+	}
+});
+//#endregion
+//#region src/config.ts
+function cliHostConfiguration(distribution, flags, environment, stateRoot) {
+	const { productId, command } = CLI_DISTRIBUTIONS[distribution];
+	const custom = flags.sash !== void 0 || flags.dashboard !== void 0;
+	if (custom && (typeof flags.sash !== "string" || typeof flags.dashboard !== "string" || flags.env !== void 0)) throw new QMindError("INVALID_ARGUMENT", "--sash and --dashboard must be supplied together and cannot be combined with --env");
+	const preset = typeof flags.env === "string" ? flags.env.trim() : "prod";
+	const endpoints = custom ? {
+		dashboardOrigin: normalizeQMindOrigin(String(flags.dashboard).trim(), "--dashboard"),
+		sashOrigin: normalizeQMindOrigin(String(flags.sash).trim(), "--sash")
+	} : resolveQMindProductEndpoints(productId, preset);
+	const target = custom ? `custom-${createHash("sha256").update(JSON.stringify([endpoints.dashboardOrigin, endpoints.sashOrigin])).digest("hex")}` : preset;
+	return {
+		environment: {
+			...environment,
+			QMIND_TOKEN: target === "prod" ? environment.QMIND_TOKEN : environment.QMIND_DEBUG_TOKEN
+		},
+		flags,
+		fixedEndpoints: endpoints,
+		homeDirectory: join(resolve(stateRoot ?? (environment.QMIND_HOME?.trim() || join(homedir(), ".qmind"))), "cli", distribution, target),
+		legacyEnvironmentPath: false,
+		loginCommand: `${command} login${custom ? ` --sash ${endpoints.sashOrigin} --dashboard ${endpoints.dashboardOrigin}` : target === "prod" ? "" : ` --env ${target}`}`,
+		productId
+	};
+}
+//#endregion
+//#region src/folder-sync.ts
+const QMIND_FOLDER_SYNC_DEFAULT_EXTENSIONS = Object.freeze([
+	".mdx",
+	".md",
+	".pdf",
+	".txt",
+	".docx",
+	".pptx",
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".svg",
+	".webp"
+]);
+function posix(path) {
+	return path.split(sep).join("/");
+}
+function qmindFolderSyncIndexKey(parentId, title) {
+	return `${parentId}\u0000${title}`;
+}
+function normalizeExtensions(values) {
+	return new Set(values.map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0).map((value) => value.startsWith(".") ? value : `.${value}`));
+}
+function validateMapping(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new QMindError("INVALID_ARGUMENT", "directory ID mapping must be a JSON object");
+	const result = {};
+	for (const [path, id] of Object.entries(value)) {
+		if (typeof id !== "string" || id.trim().length === 0) throw new QMindError("INVALID_ARGUMENT", "directory ID mapping values must be non-empty strings");
+		result[posix(path)] = id.trim();
+	}
+	return result;
+}
+async function sha256(path) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(path)) hash.update(chunk);
+	return hash.digest("hex");
+}
+function createNodeQMindFolderSyncFileSystem() {
+	return Object.freeze({
+		async isDirectory(path) {
+			return (await stat(path).catch(() => void 0))?.isDirectory() === true;
+		},
+		async readMapping(path) {
+			try {
+				return validateMapping(JSON.parse(await readFile(path, "utf8")));
+			} catch (error) {
+				if (error instanceof QMindError) throw error;
+				throw new QMindError("INVALID_ARGUMENT", `unable to read directory ID mapping: ${path}`);
+			}
+		},
+		async scan(baseDirectory, options) {
+			const directories = [];
+			const files = [];
+			let skipped = 0;
+			const isIgnored = options.ignorePatterns.length === 0 ? () => false : picomatch([...options.ignorePatterns], { dot: true });
+			const visit = async (directory) => {
+				const entries = await readdir(directory, { withFileTypes: true });
+				entries.sort((left, right) => left.name.localeCompare(right.name));
+				for (const entry of entries) {
+					const absolute = join(directory, entry.name);
+					const path = posix(relative(baseDirectory, absolute));
+					if (entry.name.startsWith(".") || isIgnored(path)) {
+						skipped += entry.isFile() ? 1 : 0;
+						continue;
+					}
+					if (entry.isDirectory()) {
+						directories.push(path);
+						await visit(absolute);
+					} else if (entry.isFile()) {
+						if (options.extensions.has(extname(entry.name).toLowerCase())) files.push(path);
+						else skipped += 1;
+					}
+				}
+			};
+			await visit(baseDirectory);
+			directories.sort((left, right) => left.split("/").length - right.split("/").length || left.localeCompare(right));
+			files.sort((left, right) => left.localeCompare(right));
+			return {
+				directories,
+				files,
+				skipped
+			};
+		},
+		sha256,
+		async writeMapping(path, mapping) {
+			await mkdir(dirname(path), { recursive: true });
+			await writeFile(path, `${JSON.stringify(mapping, null, 2)}\n`, { mode: 384 });
+		}
+	});
+}
+async function shouldReplaceQMindFolderFile(mode, existing, localPath, fileSystem = createNodeQMindFolderSyncFileSystem()) {
+	if (mode === "skip") return false;
+	if (mode === "overwrite") return true;
+	const metadata = existing.metadata ?? {};
+	const remoteHash = metadata.fileSha256 ?? metadata.rawFileSha256 ?? metadata.sha256;
+	if (typeof remoteHash !== "string" || !/^[a-f0-9]{64}$/i.test(remoteHash)) return true;
+	return (await fileSystem.sha256(localPath)).toLowerCase() !== remoteHash.toLowerCase();
+}
+function retryable(error) {
+	if (!(error instanceof QMindError)) return true;
+	if (error.code === "FILE_TOO_LARGE" || error.code === "INVALID_ARGUMENT" || error.code === "AUTH_REQUIRED" || error.code === "FORBIDDEN") return false;
+	return error.status === void 0 || error.status === 408 || error.status === 429 || error.status >= 500;
+}
+async function withUploadRetry(task, sleep) {
+	let lastFailure;
+	for (let attempt = 0; attempt < 3; attempt += 1) try {
+		return await task();
+	} catch (error) {
+		lastFailure = error;
+		if (!retryable(error) || attempt === 2) break;
+		await sleep(250 * 2 ** attempt);
+	}
+	throw lastFailure;
+}
+function defaultSleep(milliseconds) {
+	return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}
+function mappingPath(baseDirectory, cacheDirectory) {
+	const cache = cacheDirectory ?? process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+	const name = createHash("sha1").update(baseDirectory).digest("hex").slice(0, 16);
+	return join(cache, "qmind", "dir-ids", `${name}.json`);
+}
+function addFailure(stats, field, path) {
+	(stats[field] ??= []).push(path);
+}
+function publicStats(stats) {
+	return Object.freeze({
+		...stats,
+		...stats.failed_dirs === void 0 ? {} : { failed_dirs: Object.freeze(stats.failed_dirs) },
+		...stats.failed_files === void 0 ? {} : { failed_files: Object.freeze(stats.failed_files) },
+		...stats.failed_deletes === void 0 ? {} : { failed_deletes: Object.freeze(stats.failed_deletes) }
+	});
+}
+async function synchronizeQMindFolder(host, options) {
+	const notebookId = options.notebookId.trim();
+	if (notebookId.length === 0) throw new QMindError("INVALID_ARGUMENT", "notebookId is required");
+	const fileSystem = options.fileSystem ?? createNodeQMindFolderSyncFileSystem();
+	const baseDirectory = resolve(options.baseDirectory);
+	if (!await fileSystem.isDirectory(baseDirectory)) throw new QMindError("INVALID_ARGUMENT", `${baseDirectory} is not a directory`);
+	const mode = options.mode ?? "skip";
+	if (options.skipUpload === true && options.delete === true) throw new QMindError("INVALID_ARGUMENT", "delete cannot be combined with skipUpload because local files would not enter the mirror plan");
+	const requestedConcurrency = options.concurrency ?? 3;
+	if (!Number.isSafeInteger(requestedConcurrency) || requestedConcurrency < 1) throw new QMindError("INVALID_ARGUMENT", "concurrency must be a positive integer");
+	const concurrency = Math.min(10, requestedConcurrency);
+	const diagnostics = [];
+	if (requestedConcurrency > 10) diagnostics.push(`warning: concurrency ${requestedConcurrency} exceeds maximum (10); clamped to 10`);
+	const extensions = normalizeExtensions(options.extensions ?? QMIND_FOLDER_SYNC_DEFAULT_EXTENSIONS);
+	const tree = await fileSystem.scan(baseDirectory, {
+		extensions,
+		ignorePatterns: options.ignorePatterns ?? []
+	});
+	const remote = await host.client.listAllSources(notebookId);
+	const remoteIndex = new Map(remote.map((source) => [qmindFolderSyncIndexKey(source.parentSourceId, source.title), source]));
+	const remoteById = new Map(remote.map((source) => [source.id, source]));
+	const stats = {
+		dirs_created: 0,
+		dirs_reused: 0,
+		dirs_failed: 0,
+		dirs_refresh_failed: 0,
+		files_uploaded: 0,
+		files_skipped: options.skipUpload === true ? 0 : tree.skipped,
+		files_already_exist: 0,
+		files_failed: 0,
+		...options.delete === true ? {
+			delete_failed: 0,
+			dirs_deleted: 0,
+			files_deleted: 0
+		} : {},
+		...options.dryRun === true ? { dry_run: true } : {}
+	};
+	const configuredMapping = options.directoryIdsPath === void 0 ? {} : await fileSystem.readMapping(options.directoryIdsPath);
+	const directoryIds = {};
+	const desiredKeys = /* @__PURE__ */ new Set();
+	for (const directory of tree.directories) {
+		const parentPath = posix(dirname(directory)) === "." ? "" : posix(dirname(directory));
+		const parentId = directoryIds[parentPath] ?? "";
+		if (parentPath.length > 0 && parentId.length === 0) {
+			stats.dirs_failed += 1;
+			addFailure(stats, "failed_dirs", directory);
+			continue;
+		}
+		const title = basename(directory);
+		const key = qmindFolderSyncIndexKey(parentId, title);
+		desiredKeys.add(key);
+		const mappedId = configuredMapping[directory];
+		const mapped = mappedId === void 0 ? void 0 : remoteById.get(mappedId);
+		const existing = mappedId === void 0 || mapped === void 0 ? remoteIndex.get(key) : mapped;
+		if (existing?.isDir === true && existing.parentSourceId === parentId && existing.title === title) {
+			directoryIds[directory] = existing.id;
+			stats.dirs_reused += 1;
+			continue;
+		}
+		if (existing !== void 0) {
+			stats.dirs_failed += 1;
+			addFailure(stats, "failed_dirs", directory);
+			continue;
+		}
+		if (options.dryRun === true) {
+			directoryIds[directory] = `dry-run:${directory}`;
+			stats.dirs_created += 1;
+			continue;
+		}
+		try {
+			const created = await host.client.createDirectory(notebookId, {
+				parentSourceId: parentId,
+				path: title,
+				title
+			});
+			directoryIds[directory] = created.id;
+			remoteIndex.set(key, created);
+			remoteById.set(created.id, created);
+			stats.dirs_created += 1;
+		} catch {
+			stats.dirs_failed += 1;
+			addFailure(stats, "failed_dirs", directory);
+		}
+	}
+	let savedMappingPath;
+	if (options.directoryIdsPath === void 0 && options.dryRun !== true) {
+		savedMappingPath = options.saveDirectoryIdsPath ?? mappingPath(baseDirectory, options.cacheDirectory);
+		await fileSystem.writeMapping(savedMappingPath, directoryIds);
+		diagnostics.push(`directory mapping saved: ${savedMappingPath}`);
+	}
+	if (options.skipUpload !== true) {
+		const limit = pLimit(concurrency);
+		await Promise.all(tree.files.map((file) => limit(async () => {
+			const absolute = join(baseDirectory, file);
+			const parentPath = posix(dirname(file)) === "." ? "" : posix(dirname(file));
+			const parentId = directoryIds[parentPath] ?? "";
+			if (parentPath.length > 0 && parentId.length === 0) {
+				stats.files_failed += 1;
+				addFailure(stats, "failed_files", file);
+				return;
+			}
+			const title = basename(file);
+			const key = qmindFolderSyncIndexKey(parentId, title);
+			desiredKeys.add(key);
+			const existing = remoteIndex.get(key);
+			if (existing?.isDir === true) {
+				stats.files_failed += 1;
+				addFailure(stats, "failed_files", file);
+				return;
+			}
+			if (existing !== void 0 && !await shouldReplaceQMindFolderFile(mode, existing, absolute, fileSystem)) {
+				stats.files_already_exist += 1;
+				return;
+			}
+			if (options.dryRun === true) {
+				stats.files_uploaded += 1;
+				return;
+			}
+			try {
+				const hash = await fileSystem.sha256(absolute);
+				const uploaded = await withUploadRetry(async () => {
+					const binary = await host.createFileSource(absolute);
+					return await host.client.uploadSource(notebookId, binary, {
+						parentSourceId: parentId,
+						path: file,
+						sha256: hash,
+						title
+					});
+				}, options.sleep ?? defaultSleep);
+				if (existing !== void 0) await host.client.deleteSource(notebookId, existing.id);
+				remoteIndex.set(key, uploaded);
+				remoteById.set(uploaded.id, uploaded);
+				stats.files_uploaded += 1;
+			} catch {
+				stats.files_failed += 1;
+				addFailure(stats, "failed_files", file);
+			}
+		})));
+	}
+	if (options.dryRun !== true) for (const [directory, id] of Object.entries(directoryIds)) {
+		if (id.startsWith("dry-run:")) continue;
+		try {
+			await host.client.updateSource(notebookId, id, {
+				isDir: true,
+				title: basename(directory)
+			});
+		} catch {
+			stats.dirs_refresh_failed += 1;
+		}
+	}
+	const preDeleteFailures = stats.files_failed + stats.dirs_failed;
+	if (options.delete === true && preDeleteFailures === 0) {
+		const deletions = remote.filter((source) => !desiredKeys.has(qmindFolderSyncIndexKey(source.parentSourceId, source.title))).sort((left, right) => {
+			if (left.isDir !== right.isDir) return left.isDir ? 1 : -1;
+			return right.path.split("/").length - left.path.split("/").length;
+		});
+		for (const source of deletions) try {
+			if (options.dryRun !== true) await host.client.deleteSource(notebookId, source.id);
+			if (source.isDir) stats.dirs_deleted = (stats.dirs_deleted ?? 0) + 1;
+			else stats.files_deleted = (stats.files_deleted ?? 0) + 1;
+		} catch {
+			stats.delete_failed = (stats.delete_failed ?? 0) + 1;
+			(stats.failed_deletes ??= []).push(source.path || source.title);
+		}
+	}
+	const exitCode = stats.files_failed > 0 || stats.dirs_failed > 0 || stats.dirs_refresh_failed > 0 || (stats.delete_failed ?? 0) > 0 ? 1 : 0;
+	return {
+		diagnostics: Object.freeze(diagnostics),
+		exitCode,
+		...savedMappingPath === void 0 ? {} : { mappingPath: savedMappingPath },
+		stats: publicStats(stats)
+	};
+}
+//#endregion
+//#region src/output.ts
+var TextWriter = class {
+	#chunks = [];
+	line(value = "") {
+		this.#chunks.push(`${value}\n`);
+	}
+	write(value) {
+		this.#chunks.push(value);
+	}
+	toString() {
+		return this.#chunks.join("");
+	}
+};
+function parseQMindCliOutputFormat(value) {
+	if (value === "json" || value === "agent" || value === "ndjson") return value;
+	return "table";
+}
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue(value) {
+	return value === void 0 || value === null ? "" : String(value);
+}
+function numberValue(value) {
+	const parsed = Number(value ?? 0);
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+function boolValue(value) {
+	return value === true;
+}
+function oneLine(value) {
+	return stringValue(value).replace(/[\n\t]/g, " ").trim().split(/\s+/).filter(Boolean).join(" ");
+}
+function unescapeText(value) {
+	return decodeHTML(stringValue(value));
+}
+function truncate(value, width) {
+	const characters = [...stringValue(value)];
+	if (characters.length <= width) return characters.join("");
+	if (width <= 3) return characters.slice(0, width).join("");
+	return `${characters.slice(0, width - 3).join("")}...`;
+}
+function pad(value, width) {
+	const text = stringValue(value);
+	return `${text}${" ".repeat(Math.max(0, width - [...text].length))}`;
+}
+function table(writer, headers, rows, widths, separatorWidth) {
+	writer.line(headers.map((value, index) => pad(value, widths[index] ?? 0)).join("  "));
+	writer.line("-".repeat(separatorWidth));
+	for (const values of rows) writer.line(values.map((value, index) => pad(value, widths[index] ?? 0)).join("  "));
+}
+function goTimestamp(value) {
+	if (value === void 0 || value === null || value === "") return null;
+	const text = stringValue(value);
+	const milliseconds = Date.parse(text);
+	if (!Number.isFinite(milliseconds)) return null;
+	const fraction = text.match(/\.(\d{1,9})/)?.[1] ?? "";
+	return {
+		nanos: fraction.length > 0 ? Number(fraction.padEnd(9, "0")) : milliseconds % 1e3 * 1e6,
+		seconds: Math.floor(milliseconds / 1e3)
+	};
+}
+function timestamp(value) {
+	const parsed = goTimestamp(value);
+	if (parsed === null || parsed.seconds === 0) return "-";
+	return (/* @__PURE__ */ new Date(parsed.seconds * 1e3)).toISOString().replace(".000Z", "Z");
+}
+function optionalMap(value) {
+	const result = record(value);
+	return Object.keys(result).length === 0 ? void 0 : result;
+}
+function optionalStrings(value) {
+	return Array.isArray(value) && value.length > 0 ? value.map(stringValue) : void 0;
+}
+function pagination(value) {
+	if (value === void 0 || value === null) return "";
+	const page = record(value);
+	if ([
+		page.totalSize,
+		page.currentPage,
+		page.lastPage,
+		page.pageSize
+	].every((item) => numberValue(item) === 0)) return "";
+	return `  (server totalSize=${numberValue(page.totalSize)}, page=${numberValue(page.currentPage)}/${numberValue(page.lastPage)}, pageSize=${numberValue(page.pageSize)})`;
+}
+function goNotebook(value) {
+	const source = record(value);
+	const settings = optionalMap(source.settings);
+	return {
+		id: stringValue(source.id),
+		orgId: stringValue(source.orgId),
+		userId: stringValue(source.userId),
+		title: stringValue(source.title),
+		description: stringValue(source.description),
+		client: stringValue(source.client),
+		status: stringValue(source.status),
+		...settings === void 0 ? {} : { settings },
+		createdAt: goTimestamp(source.createdAt),
+		updatedAt: goTimestamp(source.updatedAt)
+	};
+}
+function goNotebookList(value) {
+	return {
+		notebooks: value.notebooks.map(goNotebook),
+		totalSize: numberValue(value.totalSize),
+		currentPage: numberValue(value.currentPage),
+		pageSize: numberValue(value.pageSize)
+	};
+}
+function goPage(value) {
+	if (value === void 0 || value === null) return void 0;
+	const source = record(value);
+	return {
+		prevPage: numberValue(source.prevPage),
+		currentPage: numberValue(source.currentPage),
+		nextPage: numberValue(source.nextPage),
+		lastPage: numberValue(source.lastPage),
+		pageSize: numberValue(source.pageSize),
+		totalSize: numberValue(source.totalSize),
+		...source.nextToken ? { nextToken: stringValue(source.nextToken) } : {}
+	};
+}
+function goSource(value) {
+	const source = record(value);
+	const metadata = optionalMap(source.metadata);
+	return {
+		id: stringValue(source.id),
+		orgId: stringValue(source.orgId),
+		userId: stringValue(source.userId),
+		notebookId: stringValue(source.notebookId),
+		title: stringValue(source.title),
+		sourceType: stringValue(source.sourceType),
+		uri: stringValue(source.uri),
+		status: stringValue(source.status),
+		errorMessage: stringValue(source.errorMessage),
+		parentSourceId: stringValue(source.parentSourceId),
+		path: stringValue(source.path),
+		isDir: boolValue(source.isDir),
+		...metadata === void 0 ? {} : { metadata },
+		originUrl: stringValue(source.originUrl),
+		createdAt: goTimestamp(source.createdAt),
+		updatedAt: goTimestamp(source.updatedAt)
+	};
+}
+function goSourceList(value) {
+	const pages = goPage(value.pages);
+	return {
+		sources: value.sources.map(goSource),
+		...pages === void 0 ? {} : { pages },
+		totalSize: numberValue(value.totalSize),
+		currentPage: numberValue(value.currentPage),
+		pageSize: numberValue(value.pageSize)
+	};
+}
+function goCardLink(value) {
+	const source = record(value);
+	return {
+		linkType: stringValue(source.linkType),
+		targetId: stringValue(source.targetId),
+		...source.targetTitle ? { targetTitle: stringValue(source.targetTitle) } : {},
+		...source.description ? { description: stringValue(source.description) } : {}
+	};
+}
+function goCard(value) {
+	const source = record(value);
+	const keywords = optionalStrings(source.keywords);
+	const links = Array.isArray(source.links) && source.links.length > 0 ? source.links.map(goCardLink) : void 0;
+	return {
+		id: stringValue(source.id),
+		...source.knowledgeId ? { knowledgeId: stringValue(source.knowledgeId) } : {},
+		orgId: stringValue(source.orgId),
+		...source.notebookId ? { notebookId: stringValue(source.notebookId) } : {},
+		source: stringValue(source.source),
+		...source.cardType ? { cardType: stringValue(source.cardType) } : {},
+		...source.category ? { category: stringValue(source.category) } : {},
+		...source.repo ? { repo: stringValue(source.repo) } : {},
+		title: stringValue(source.title),
+		content: stringValue(source.content),
+		...keywords === void 0 ? {} : { keywords },
+		...links === void 0 ? {} : { links },
+		...source.extra ? { extra: stringValue(source.extra) } : {},
+		createdAt: goTimestamp(source.createdAt),
+		updatedAt: goTimestamp(source.updatedAt)
+	};
+}
+function goCardList(value) {
+	return {
+		cards: value.cards.map(goCard),
+		totalSize: numberValue(value.totalSize),
+		currentPage: numberValue(value.currentPage),
+		pageSize: numberValue(value.pageSize)
+	};
+}
+function goRetrieve(value) {
+	return {
+		chunks: value.chunks.map((chunk) => ({
+			sourceId: chunk.sourceId,
+			sourceTitle: chunk.sourceTitle,
+			sourceUri: chunk.sourceUri,
+			chunkId: chunk.chunkId,
+			chunkIndex: chunk.chunkIndex,
+			content: chunk.content,
+			tokenCount: chunk.tokenCount,
+			...chunk.metadata === void 0 ? {} : { metadata: chunk.metadata },
+			score: chunk.score,
+			...chunk.originUrl === void 0 ? {} : { originUrl: chunk.originUrl }
+		})),
+		citations: value.citations.map((citation) => ({
+			sourceId: citation.sourceId,
+			sourceTitle: citation.sourceTitle,
+			sourceUri: citation.sourceUri,
+			chunkId: citation.chunkId,
+			chunkIndex: citation.chunkIndex,
+			snippet: citation.snippet,
+			...citation.metadata === void 0 ? {} : { metadata: citation.metadata },
+			...citation.originUrl === void 0 ? {} : { originUrl: citation.originUrl }
+		})),
+		promptContext: value.promptContext,
+		total: value.total,
+		reranked: value.reranked,
+		cards: value.cards.map((card) => ({
+			id: card.id,
+			title: card.title,
+			content: card.content,
+			...card.category === void 0 ? {} : { category: card.category },
+			...card.cardType === void 0 ? {} : { cardType: card.cardType },
+			keywords: card.keywords,
+			...card.links.length === 0 ? {} : { links: card.links },
+			score: card.score,
+			depth: card.depth
+		}))
+	};
+}
+function agentField(writer, name, value) {
+	if (value === void 0 || value === null) return;
+	const text = stringValue(value);
+	if (text === "" || text === "-") return;
+	writer.line(`${name}: ${oneLine(text)}`);
+}
+function agentText(writer, name, value) {
+	const text = stringValue(value);
+	if (text.length === 0) return;
+	writer.line(`${name}: |-`);
+	for (const line of text.split("\n")) writer.line(`  ${line}`);
+}
+function agentHeader(writer, kind, total) {
+	writer.line(`kind: ${kind}`);
+	writer.line(`total: ${total}`);
+}
+function renderAgentNotebook(writer, value, index = 0) {
+	writer.line("---");
+	agentField(writer, "type", "notebook");
+	if (index > 0) agentField(writer, "index", index);
+	agentField(writer, "id", value.id);
+	agentField(writer, "orgId", value.orgId);
+	agentField(writer, "userId", value.userId);
+	agentField(writer, "status", value.status);
+	agentField(writer, "title", value.title);
+	agentField(writer, "createdAt", timestamp(value.createdAt));
+	agentField(writer, "updatedAt", timestamp(value.updatedAt));
+	agentText(writer, "description", value.description);
+}
+function renderAgentSource(writer, value, index = 0) {
+	writer.line("---");
+	agentField(writer, "type", "source");
+	if (index > 0) agentField(writer, "index", index);
+	agentField(writer, "id", value.id);
+	agentField(writer, "notebookId", value.notebookId);
+	agentField(writer, "sourceType", value.sourceType);
+	agentField(writer, "status", value.status);
+	agentField(writer, "title", value.title);
+	agentField(writer, "uri", value.uri);
+	agentField(writer, "path", value.path);
+	agentField(writer, "isDir", value.isDir);
+	agentField(writer, "parentSourceId", value.parentSourceId);
+	agentField(writer, "createdAt", timestamp(value.createdAt));
+	agentField(writer, "updatedAt", timestamp(value.updatedAt));
+	agentText(writer, "error", value.errorMessage);
+}
+function renderAgentCard(writer, value, index, score) {
+	writer.line("---");
+	agentField(writer, "type", "card");
+	if (index > 0) agentField(writer, "index", index);
+	if (score !== void 0) agentField(writer, "score", score.toFixed(4));
+	agentField(writer, "id", value.id);
+	agentField(writer, "knowledgeId", value.knowledgeId);
+	agentField(writer, "notebookId", value.notebookId);
+	agentField(writer, "source", value.source);
+	agentField(writer, "cardType", value.cardType);
+	agentField(writer, "category", value.category);
+	agentField(writer, "repo", value.repo);
+	agentField(writer, "title", value.title);
+	if (value.keywords.length > 0) agentField(writer, "keywords", value.keywords.join(", "));
+	agentField(writer, "createdAt", timestamp(value.createdAt));
+	agentField(writer, "updatedAt", timestamp(value.updatedAt));
+	agentText(writer, "content", value.content);
+	if (value.links.length > 0) {
+		writer.line("links:");
+		for (const link of value.links) {
+			writer.line(`  - targetId: ${link.targetId}`);
+			agentField(writer, "    linkType", link.linkType);
+			agentField(writer, "    description", link.description);
+		}
+	}
+}
+function json(value, pretty) {
+	return `${JSON.stringify(value, null, pretty ? 2 : 0)}\n`;
+}
+function renderNotebook(value, format) {
+	if (format === "json") return json(goNotebook(value), true);
+	if (format === "ndjson") return json(goNotebook(value), false);
+	const writer = new TextWriter();
+	if (format === "agent") renderAgentNotebook(writer, value);
+	else {
+		writer.line(`ID:          ${value.id}`);
+		writer.line(`Title:       ${value.title}`);
+		writer.line(`Status:      ${value.status}`);
+		writer.line(`OrgID:       ${value.orgId}`);
+		writer.line(`UserID:      ${value.userId}`);
+		writer.line(`CreatedAt:   ${timestamp(value.createdAt)}`);
+		writer.line(`UpdatedAt:   ${timestamp(value.updatedAt)}`);
+		if (value.description.length > 0) writer.line(`\n${value.description}`);
+	}
+	return writer.toString();
+}
+function renderNotebookList(value, format) {
+	if (format === "json") return json(goNotebookList(value), true);
+	if (format === "ndjson") return value.notebooks.map((item) => json(goNotebook(item), false)).join("");
+	const writer = new TextWriter();
+	if (format === "agent") {
+		agentHeader(writer, "notebooks", value.notebooks.length);
+		value.notebooks.forEach((item, index) => renderAgentNotebook(writer, item, index + 1));
+	} else if (value.notebooks.length === 0) writer.line("No notebooks found.");
+	else {
+		writer.line(`Total: ${value.notebooks.length}`);
+		writer.line();
+		table(writer, [
+			"ID",
+			"STATUS",
+			"TITLE",
+			"USER",
+			"UPDATED"
+		], value.notebooks.map((item) => [
+			truncate(item.id, 36),
+			truncate(item.status, 10),
+			truncate(item.title, 28),
+			truncate(item.userId, 18),
+			timestamp(item.updatedAt)
+		]), [
+			36,
+			10,
+			28,
+			18,
+			20
+		], 120);
+	}
+	return writer.toString();
+}
+function renderSource(value, format) {
+	if (format === "json") return json(goSource(value), true);
+	if (format === "ndjson") return json(goSource(value), false);
+	const writer = new TextWriter();
+	if (format === "agent") renderAgentSource(writer, value);
+	else {
+		writer.line(`ID:          ${value.id}`);
+		writer.line(`NotebookID:  ${value.notebookId}`);
+		writer.line(`Title:       ${value.title}`);
+		writer.line(`Type:        ${value.sourceType}`);
+		writer.line(`Status:      ${value.status}`);
+		writer.line(`URI:         ${value.uri}`);
+		if (value.path.length > 0) writer.line(`Path:        ${value.path}`);
+		if (value.errorMessage.length > 0) writer.line(`Error:       ${value.errorMessage}`);
+		writer.line(`UpdatedAt:   ${timestamp(value.updatedAt)}`);
+	}
+	return writer.toString();
+}
+function renderSourceList(value, format) {
+	if (format === "json") return json(goSourceList(value), true);
+	if (format === "ndjson") return value.sources.map((item) => json(goSource(item), false)).join("");
+	const writer = new TextWriter();
+	if (format === "agent") {
+		agentHeader(writer, "sources", value.sources.length);
+		const summary = pagination(value.pages);
+		if (summary.length > 0) writer.line(`pagination:${summary}`);
+		value.sources.forEach((item, index) => renderAgentSource(writer, item, index + 1));
+	} else if (value.sources.length === 0) writer.line("No sources found.");
+	else {
+		writer.line(`Total: ${value.sources.length}${pagination(value.pages)}`);
+		writer.line();
+		table(writer, [
+			"ID",
+			"TYPE",
+			"STATUS",
+			"TITLE",
+			"URI"
+		], value.sources.map((item) => [
+			truncate(item.id, 36),
+			truncate(item.sourceType, 10),
+			truncate(item.status, 10),
+			truncate(item.title, 30),
+			truncate(item.uri || item.path, 28)
+		]), [
+			36,
+			10,
+			10,
+			30,
+			28
+		], 120);
+	}
+	return writer.toString();
+}
+function renderCardList(value, format) {
+	if (format === "json") return json(goCardList(value), true);
+	if (format === "ndjson") return value.cards.map((item) => json(goCard(item), false)).join("");
+	const writer = new TextWriter();
+	if (format === "agent") {
+		agentHeader(writer, "cards", value.totalSize || value.cards.length);
+		value.cards.forEach((item, index) => renderAgentCard(writer, item, index + 1));
+	} else if (value.cards.length === 0) writer.line("No cards found.");
+	else {
+		writer.line(`Total: ${value.totalSize || value.cards.length}`);
+		writer.line();
+		table(writer, [
+			"ID",
+			"TYPE",
+			"CATEGORY",
+			"TITLE",
+			"LINKS",
+			"UPDATED"
+		], value.cards.map((item) => [
+			truncate(item.id, 36),
+			truncate(item.cardType, 8),
+			truncate(item.category, 16),
+			truncate(item.title, 30),
+			item.links.length,
+			timestamp(item.updatedAt)
+		]), [
+			36,
+			8,
+			16,
+			30,
+			5,
+			20
+		], 125);
+	}
+	return writer.toString();
+}
+function renderRetrieve(value, format) {
+	if (format === "json") return json(goRetrieve(value), true);
+	if (format === "ndjson") return [...value.chunks.map((item) => ({
+		kind: "chunk",
+		...item
+	})), ...value.cards.map((item) => ({
+		kind: "card",
+		...item
+	}))].map((item) => json(item, false)).join("");
+	const writer = new TextWriter();
+	if (format === "agent") {
+		agentHeader(writer, "notebookContext", value.total);
+		agentField(writer, "reranked", value.reranked);
+		value.chunks.forEach((chunk, index) => {
+			writer.line("---");
+			agentField(writer, "type", "chunk");
+			agentField(writer, "index", index + 1);
+			agentField(writer, "chunkId", chunk.chunkId);
+			agentField(writer, "chunkIndex", chunk.chunkIndex);
+			agentField(writer, "sourceId", chunk.sourceId);
+			agentField(writer, "sourceTitle", chunk.sourceTitle);
+			agentField(writer, "sourceUri", chunk.sourceUri);
+			agentField(writer, "score", chunk.score.toFixed(4));
+			agentField(writer, "tokenCount", chunk.tokenCount);
+			agentText(writer, "content", unescapeText(chunk.content));
+		});
+		value.cards.forEach((card, index) => {
+			writer.line("---");
+			agentField(writer, "type", "retrievedCard");
+			agentField(writer, "index", index + 1);
+			agentField(writer, "id", card.id);
+			agentField(writer, "title", card.title);
+			agentField(writer, "category", card.category);
+			agentField(writer, "cardType", card.cardType);
+			agentField(writer, "score", card.score.toFixed(4));
+			agentField(writer, "depth", card.depth);
+			if (card.keywords.length > 0) agentField(writer, "keywords", card.keywords.join(", "));
+			agentText(writer, "content", unescapeText(card.content));
+		});
+		value.citations.forEach((citation, index) => {
+			writer.line("---");
+			agentField(writer, "type", "citation");
+			agentField(writer, "index", index + 1);
+			agentField(writer, "sourceId", citation.sourceId);
+			agentField(writer, "sourceTitle", citation.sourceTitle);
+			agentField(writer, "chunkId", citation.chunkId);
+			agentText(writer, "snippet", unescapeText(citation.snippet));
+		});
+		agentText(writer, "promptContext", unescapeText(value.promptContext));
+		return writer.toString();
+	}
+	writer.line(`Total chunks: ${value.total}  Reranked: ${value.reranked}`);
+	writer.line();
+	if (value.chunks.length > 0) {
+		writer.line("== Chunks ==");
+		table(writer, [
+			"SCORE",
+			"CHUNK_ID",
+			"IDX",
+			"SOURCE",
+			"CONTENT"
+		], value.chunks.map((chunk) => [
+			chunk.score.toFixed(2),
+			truncate(chunk.chunkId, 36),
+			chunk.chunkIndex,
+			truncate(chunk.sourceTitle, 30),
+			truncate(unescapeText(chunk.content).replace(/\n/g, " "), 50)
+		]), [
+			6,
+			36,
+			6,
+			30,
+			50
+		], 130);
+		writer.line();
+		value.chunks.forEach((chunk, index) => {
+			writer.line(`[${index + 1}] chunkId=${chunk.chunkId} sourceId=${chunk.sourceId} sourceTitle=${chunk.sourceTitle} score=${chunk.score.toFixed(4)} tokens=${chunk.tokenCount}`);
+			if (chunk.sourceUri.length > 0) writer.line(`    uri: ${chunk.sourceUri}`);
+			if (chunk.content.length > 0) writer.line(`    content: ${unescapeText(chunk.content)}`);
+			writer.line();
+		});
+	}
+	if (value.cards.length > 0) {
+		writer.line("== Cards ==");
+		table(writer, [
+			"SCORE",
+			"DEPTH",
+			"ID",
+			"CATEGORY",
+			"TITLE",
+			"CONTENT"
+		], value.cards.map((card) => [
+			card.score.toFixed(2),
+			card.depth,
+			truncate(card.id, 36),
+			truncate(card.category, 20),
+			truncate(card.title, 30),
+			truncate(unescapeText(card.content).replace(/\n/g, " "), 30)
+		]), [
+			6,
+			5,
+			36,
+			20,
+			30,
+			30
+		], 130);
+		writer.line();
+	}
+	if (value.citations.length > 0) {
+		writer.line("== Citations ==");
+		value.citations.forEach((citation, index) => {
+			writer.line(`[${index + 1}] sourceId=${citation.sourceId} sourceTitle=${citation.sourceTitle} chunkId=${citation.chunkId}`);
+			if (citation.snippet.length > 0) writer.line(`    snippet: ${oneLine(unescapeText(citation.snippet))}`);
+		});
+		writer.line();
+	}
+	if (value.promptContext.length > 0) writer.line(`== Prompt Context ==\n${unescapeText(value.promptContext)}`);
+	return writer.toString();
+}
+function renderQMindCliPresentation(presentation, format) {
+	switch (presentation.kind) {
+		case "notebook": return renderNotebook(presentation.value, format);
+		case "notebookList": return renderNotebookList(presentation.value, format);
+		case "source": return renderSource(presentation.value, format);
+		case "sourceList": return renderSourceList(presentation.value, format);
+		case "cardList": return renderCardList(presentation.value, format);
+		case "retrieve": return renderRetrieve(presentation.value, format);
+		case "imageUpload": return json({
+			uploadUrl: presentation.value.uploadUrl,
+			method: presentation.value.method,
+			...Object.keys(presentation.value.headers).length === 0 ? {} : { headers: presentation.value.headers },
+			ossKey: presentation.value.ossKey,
+			...presentation.value.expiresAt === void 0 ? {} : { expiresAt: presentation.value.expiresAt }
+		}, format !== "ndjson");
+		case "imageUrls": return json(presentation.value, format !== "ndjson");
+		case "json": return json(presentation.value, format !== "ndjson");
+		case "text": return presentation.value;
+	}
+}
+function renderQMindCliError(error, jsonOutput) {
+	const source = error instanceof QMindError ? {
+		code: error.code,
+		details: error.details,
+		message: error.message,
+		rawBody: error.rawBody,
+		requestId: error.requestId,
+		status: error.status,
+		upstreamCode: error.upstreamCode
+	} : {
+		code: "INTERNAL_ERROR",
+		details: void 0,
+		message: error instanceof Error ? error.message : String(error),
+		rawBody: void 0,
+		requestId: void 0,
+		status: void 0,
+		upstreamCode: void 0
+	};
+	const exitCode = source.code === "INVALID_ARGUMENT" ? 2 : 1;
+	if (!jsonOutput) return {
+		exitCode,
+		stderr: `error: ${source.message}\n`,
+		stdout: ""
+	};
+	return {
+		exitCode,
+		stderr: "",
+		stdout: json({ error: {
+			code: source.code,
+			message: source.message,
+			status: source.status,
+			errorCode: source.upstreamCode,
+			requestId: source.requestId,
+			rawBody: source.rawBody,
+			details: source.details
+		} }, true)
+	};
+}
+function compatibilityQuestionEvent(event) {
+	const goMessage = (message) => ({
+		id: message.id,
+		orgId: "",
+		userId: "",
+		notebookId: "",
+		chatSessionId: "",
+		role: message.role,
+		content: message.content,
+		sequence: 0,
+		model: "",
+		createdAt: null,
+		updatedAt: null,
+		sceneType: ""
+	});
+	switch (event.type) {
+		case "messageStart": return {
+			eventType: "message_start",
+			...event.userMessage === void 0 ? {} : { userMessage: goMessage(event.userMessage) },
+			...event.assistantMessageId === void 0 ? {} : { assistantMessageId: event.assistantMessageId },
+			...event.citations.length === 0 ? {} : { citations: event.citations },
+			...event.totalContextChunks === 0 ? {} : { totalContextChunks: event.totalContextChunks },
+			...event.reranked ? { reranked: true } : {}
+		};
+		case "toolCallStart": return {
+			eventType: "tool_call_start",
+			toolName: event.toolName,
+			toolArguments: event.toolArguments,
+			step: event.step
+		};
+		case "toolCallResult": return {
+			eventType: "tool_call_result",
+			toolName: event.toolName,
+			toolResult: event.toolResult,
+			step: event.step
+		};
+		case "delta": return {
+			eventType: "delta",
+			delta: event.delta
+		};
+		case "batchProgress": return {
+			eventType: "batch_progress",
+			metadata: event.metadata
+		};
+		case "heartbeat": return {
+			eventType: "heartbeat",
+			metadata: event.metadata
+		};
+		case "cancel": return {
+			eventType: "cancel",
+			canceled: true,
+			...event.cancelReason === void 0 ? {} : { cancelReason: event.cancelReason }
+		};
+		case "messageComplete": return {
+			eventType: "message_complete",
+			...event.assistantMessage === void 0 ? {} : { assistantMessage: goMessage(event.assistantMessage) },
+			...event.citations.length === 0 ? {} : { citations: event.citations },
+			...event.promptContext.length === 0 ? {} : { promptContext: event.promptContext },
+			...event.totalContextChunks === 0 ? {} : { totalContextChunks: event.totalContextChunks },
+			...event.reranked ? { reranked: true } : {},
+			...event.canceled ? { canceled: true } : {},
+			...event.cancelReason === void 0 ? {} : { cancelReason: event.cancelReason },
+			...Object.keys(event.metadata).length === 0 ? {} : { metadata: event.metadata }
+		};
+		case "error": return {
+			eventType: "error",
+			errorMessage: event.message
+		};
+	}
+}
+function batchProgress(metadata) {
+	const value = (key, fallback = "?") => metadata[key] || fallback;
+	const index = () => {
+		const raw = metadata.batchIndex;
+		const parsed = Number(raw);
+		return Number.isInteger(parsed) ? String(parsed + 1) : raw || "?";
+	};
+	switch (metadata.phase) {
+		case "plan": return `[compile] 📋 plan: ${value("totalBatches")} batches, ${value("totalSources")} sources, ${value("totalBytes")} bytes`;
+		case "batch_start": return `[compile] ▶ batch ${index()}/${value("totalBatches")} start (sources=${value("batchSources")}, bytes=${value("batchBytes")}, prepared=${value("preparedCardsTotal", "0")})`;
+		case "batch_done": return `[compile] ✔ batch ${index()}/${value("totalBatches")} done (+${value("preparedCardsDelta", "0")} cards, total=${value("preparedCardsTotal", "0")}, steps=${value("batchStepsUsed")}, ${value("elapsedMs")}ms)`;
+		case "persist_start": return `[compile] 💾 persist start (drafts=${value("draftsTotal")})`;
+		case "persist_done": return metadata.saved === "true" ? `[compile] ✅ persisted ${value("upsertedCards", "0")} cards (failed=${value("failedCards", "0")})` : `[compile] ⚠️  persist failed: ${metadata.persistError || "not persisted"} (drafts retained for fallback save)`;
+		default: return;
+	}
+}
+/** Stateful only for terminal layout; it never owns the SDK stream or writes I/O. */
+function createQMindCliStreamRenderer(format) {
+	let hasDelta = false;
+	return {
+		finish() {
+			if (!hasDelta) return "";
+			hasDelta = false;
+			return "\n";
+		},
+		push(event) {
+			const compatible = compatibilityQuestionEvent(event);
+			if (format === "json") return json(compatible, true);
+			if (format === "ndjson") return json(compatible, false);
+			const writer = new TextWriter();
+			const breakDelta = () => {
+				if (hasDelta) writer.line();
+				hasDelta = false;
+			};
+			switch (event.type) {
+				case "toolCallStart":
+					breakDelta();
+					if (format === "agent") writer.line(`[tool] ${event.toolName}`);
+					else {
+						writer.line(`[step ${event.step}] tool: ${event.toolName}`);
+						if (event.toolArguments.length > 0) writer.line(`         args: ${event.toolArguments}`);
+					}
+					break;
+				case "toolCallResult":
+					if (format !== "agent") writer.line(`         result: ${truncate(event.toolResult, 120)}`);
+					break;
+				case "batchProgress": {
+					breakDelta();
+					const line = batchProgress(event.metadata);
+					if (line !== void 0) writer.line(line);
+					break;
+				}
+				case "delta":
+					writer.write(event.delta);
+					hasDelta = true;
+					break;
+				case "messageComplete":
+					breakDelta();
+					if (format === "agent" && event.assistantMessage?.content !== void 0) writer.line(event.assistantMessage.content);
+					if (format !== "agent" && event.citations.length > 0) {
+						writer.line();
+						writer.line("Citations:");
+						event.citations.forEach((citation, index) => writer.line(`  [${index + 1}] ${citation}`));
+					}
+					break;
+				case "cancel":
+					breakDelta();
+					writer.line(`[canceled] ${event.cancelReason ?? ""}`.trimEnd());
+					break;
+				case "error":
+					breakDelta();
+					writer.line(`error: ${event.message}`);
+			}
+			return writer.toString();
+		}
+	};
+}
+//#endregion
+//#region src/application.ts
+const distribution = CLI_DISTRIBUTIONS["cn"];
+function processIO() {
+	return Object.freeze({
+		stdinIsTTY: process.stdin.isTTY === true,
+		stderrIsTTY: process.stderr.isTTY === true,
+		stderr(value) {
+			process.stderr.write(value);
+		},
+		stdout(value) {
+			process.stdout.write(value);
+		}
+	});
+}
+function interactiveConfirm(io) {
+	return Object.freeze({ async confirm(message) {
+		if (!io.stdinIsTTY || !io.stderrIsTTY) return false;
+		const prompt = createInterface({
+			input: process.stdin,
+			output: process.stderr
+		});
+		try {
+			return (await prompt.question(message)).trim().toLowerCase() === "y";
+		} finally {
+			prompt.close();
+		}
+	} });
+}
+function stringOption(options, key) {
+	const value = options[key];
+	return typeof value === "string" ? value : void 0;
+}
+function optionalString(options, key) {
+	const value = stringOption(options, key)?.trim();
+	return value === void 0 || value.length === 0 ? void 0 : value;
+}
+function requiredString(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new QMindError("INVALID_ARGUMENT", `${label} is required`);
+	return value;
+}
+function integer(value) {
+	if (!/^[+-]?\d+$/.test(value)) throw new QMindError("INVALID_ARGUMENT", `invalid integer value: ${JSON.stringify(value)}`);
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed)) throw new QMindError("INVALID_ARGUMENT", `integer value is out of range: ${value}`);
+	return parsed;
+}
+function numberOption(options, key, fallback) {
+	const value = options[key];
+	return typeof value === "number" ? value : fallback;
+}
+function positiveNumberOption(options, key, fallback) {
+	const value = numberOption(options, key, fallback);
+	return value > 0 ? value : void 0;
+}
+function splitCsv(value) {
+	return value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
+}
+function formatOf(options) {
+	return parseQMindCliOutputFormat(String(options.format ?? "table"));
+}
+function commonFlags(options) {
+	const client = optionalString(options, "client");
+	const dashboard = stringOption(options, "dashboard");
+	const sash = stringOption(options, "sash");
+	const env = stringOption(options, "env");
+	const token = optionalString(options, "token");
+	return {
+		...client === void 0 ? {} : { client },
+		...env === void 0 ? {} : { env },
+		...dashboard === void 0 ? {} : { dashboard },
+		...options.nonInteractive === true ? { nonInteractive: true } : {},
+		...sash === void 0 ? {} : { sash },
+		...token === void 0 ? {} : { token }
+	};
+}
+async function hostFor(context, options) {
+	if (context.host !== void 0) return context.host;
+	const configuration = cliHostConfiguration("cn", commonFlags(options), context.hostOptions.environment ?? process.env, context.hostOptions.homeDirectory);
+	const adapters = {
+		...context.hostOptions.adapters,
+		secretStore: createNoopQMindSecretStore(),
+		reporter: context.hostOptions.adapters?.reporter ?? {
+			info(message) {
+				context.io.stderr(`${message}\n`);
+			},
+			warn(message) {
+				context.io.stderr(`${message}\n`);
+			}
+		}
+	};
+	context.host = await context.hostFactory({
+		...context.hostOptions,
+		...configuration,
+		adapters,
+		stdinIsTTY: context.io.stdinIsTTY
+	});
+	return context.host;
+}
+function render(context, options, presentation) {
+	context.io.stdout(renderQMindCliPresentation(presentation, formatOf(options)));
+}
+function withCommon(command, output = true) {
+	command.option("--token <token>", "Bearer access token").option("--env <name>", "product environment: prod (default), test, or daily where supported").option("--sash <url>", "custom debug Sash origin (requires --dashboard; excludes --env)").option("--dashboard <url>", "custom debug Dashboard origin (requires --sash; excludes --env)").option("--org <id>", "organization ID (deprecated and ignored)").option("--client <name>", "originating client identifier").option("--non-interactive", "never open a browser when credentials are missing");
+	if (output) command.option("--format <format>", "output format: table | json | agent | ndjson", "table");
+	return command;
+}
+function registerCardQueryCommand(context, command) {
+	withCommon(command).option("--nb <id>", "notebook ID (required)").option("-q, --query <query>", "search query", "").option("--cat <category>", "category filter", "").option("--page <number>", "page number", integer, 0).option("--page-size <number>", "page size", integer, 20).action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const page = positiveNumberOption(raw, "page", 0);
+		const pageSize = positiveNumberOption(raw, "pageSize", 20);
+		render(context, raw, {
+			kind: "cardList",
+			value: await host.client.listCards(requiredString(raw.nb, "--nb"), {
+				category: String(raw.cat ?? ""),
+				...page === void 0 ? {} : { page },
+				...pageSize === void 0 ? {} : { pageSize },
+				query: String(raw.query ?? "")
+			})
+		});
+	});
+}
+function registerCoreCommands(context, program) {
+	withCommon(program.command("login").description("Authorize via browser and save credentials"), false).option("--client-id <id>", "OAuth App client_id").action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const clientId = optionalString(raw, "clientId");
+		const result = await host.login({ ...clientId === void 0 ? {} : { clientId } });
+		context.io.stdout(`Logged in successfully [${result.sashOrigin} -> ${host.config.dashboardOrigin}]\nToken saved to ${host.config.homeDirectory}/credentials.json\nDevice token expires at: ${result.expiresAt}\n`);
+	});
+	withCommon(program.command("logout").description("Remove saved credentials"), false).action(async (raw) => {
+		await (await hostFor(context, raw)).logout();
+		context.io.stdout("Logged out. Credentials removed.\n");
+	});
+	const notebook = program.command("notebook").description("Manage notebooks");
+	withCommon(notebook.command("create").description("Create a notebook")).option("--title <title>", "notebook title (required)").option("--desc <description>", "notebook description", "").action(async (raw) => {
+		render(context, raw, {
+			kind: "notebook",
+			value: await (await hostFor(context, raw)).client.createNotebook({
+				description: String(raw.desc ?? ""),
+				title: requiredString(raw.title, "--title")
+			})
+		});
+	});
+	withCommon(notebook.command("list").description("List notebooks")).option("--filter-client <name>", "filter by originating client", "").action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const client = optionalString(raw, "filterClient");
+		render(context, raw, {
+			kind: "notebookList",
+			value: await host.client.listNotebooks(client === void 0 ? {} : { client })
+		});
+	});
+	withCommon(notebook.command("get <notebook_id>").description("Get a notebook")).action(async (notebookId, raw) => {
+		render(context, raw, {
+			kind: "notebook",
+			value: await (await hostFor(context, raw)).client.getNotebook(notebookId)
+		});
+	});
+	withCommon(notebook.command("delete <notebook_id>").description("Delete a notebook"), false).action(async (notebookId, raw) => {
+		await (await hostFor(context, raw)).client.deleteNotebook(notebookId);
+		context.io.stdout("deleted\n");
+	});
+	const cards = program.command("cards").description("Manage notebook cards");
+	for (const action of ["list", "search"]) {
+		const description = action === "search" ? "Search notebook cards" : "List notebook cards";
+		registerCardQueryCommand(context, cards.command(action).description(description));
+		registerCardQueryCommand(context, program.command(action).description(`${description} (alias for cards ${action})`));
+	}
+	withCommon(program.command("retrieve [query]").description("Retrieve notebook context without an LLM call")).option("--nb <id>", "notebook ID (required)").option("-q, --query <query>", "retrieval query").option("--sources <ids>", "comma-separated source IDs", "").option("--top-k <number>", "top-k for retrieval", integer, 0).option("--max-results <number>", "maximum context results", integer, 0).action(async (query, raw) => {
+		render(context, raw, {
+			kind: "retrieve",
+			value: await (await hostFor(context, raw)).client.retrieve(requiredString(raw.nb, "--nb"), {
+				maxResults: numberOption(raw, "maxResults", 0),
+				query: requiredString(raw.query || query, "--query or positional query"),
+				sourceIds: splitCsv(stringOption(raw, "sources")),
+				topK: numberOption(raw, "topK", 0)
+			})
+		});
+	});
+}
+function registerSourceCommands(context, program) {
+	const source = program.command("source").description("Manage notebook sources");
+	withCommon(source.command("create").description("Create a source record")).option("--nb <id>", "notebook ID (required)").option("--title <title>", "source title (required)").option("--type <type>", "source type", "").option("--parent <id>", "parent source ID", "").option("--path <path>", "source path", "").option("--is-dir", "create a directory source").option("--status <status>", "source status", "").action(async (raw) => {
+		render(context, raw, {
+			kind: "source",
+			value: await (await hostFor(context, raw)).client.createSource(requiredString(raw.nb, "--nb"), {
+				isDir: raw.isDir === true ? true : void 0,
+				parentSourceId: String(raw.parent ?? ""),
+				path: String(raw.path ?? ""),
+				sourceType: String(raw.type ?? ""),
+				status: String(raw.status ?? ""),
+				title: requiredString(raw.title, "--title")
+			})
+		});
+	});
+	withCommon(source.command("mkdir").description("Create a directory source")).option("--nb <id>", "notebook ID (required)").option("--title <title>", "folder name (required)").option("--parent <id>", "parent source ID", "").option("--path <path>", "source path", "").action(async (raw) => {
+		render(context, raw, {
+			kind: "source",
+			value: await (await hostFor(context, raw)).client.createDirectory(requiredString(raw.nb, "--nb"), {
+				parentSourceId: String(raw.parent ?? ""),
+				path: String(raw.path ?? ""),
+				title: requiredString(raw.title, "--title")
+			})
+		});
+	});
+	withCommon(source.command("list").description("List sources")).option("--nb <id>", "notebook ID (required)").option("--page <number>", "page number", integer, 0).option("--page-size <number>", "page size", integer, 0).option("--all", "fetch and merge every page").option("--max-pages <number>", "all-pages safety limit", integer, 1e4).action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const notebookId = requiredString(raw.nb, "--nb");
+		let value;
+		if (raw.all === true) {
+			const pageSize = positiveNumberOption(raw, "pageSize", 0) ?? 100;
+			value = { sources: await host.client.listAllSources(notebookId, {
+				maxPages: numberOption(raw, "maxPages", 1e4),
+				pageSize
+			}) };
+		} else {
+			const page = positiveNumberOption(raw, "page", 0);
+			const pageSize = positiveNumberOption(raw, "pageSize", 0);
+			value = await host.client.listSources(notebookId, {
+				...page === void 0 ? {} : { page },
+				...pageSize === void 0 ? {} : { pageSize }
+			});
+		}
+		render(context, raw, {
+			kind: "sourceList",
+			value
+		});
+	});
+	withCommon(source.command("get <source_id>").description("Get a source")).option("--nb <id>", "notebook ID (required)").action(async (sourceId, raw) => {
+		render(context, raw, {
+			kind: "source",
+			value: await (await hostFor(context, raw)).client.getSource(requiredString(raw.nb, "--nb"), sourceId)
+		});
+	});
+	withCommon(source.command("upload").description("Upload a local file")).option("--nb <id>", "notebook ID (required)").option("--file <path>", "local file path (required)").option("--title <title>", "source title", "").option("--type <type>", "source type", "").option("--parent <id>", "parent source ID", "").option("--path <path>", "source path", "").action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const file = requiredString(raw.file, "--file");
+		render(context, raw, {
+			kind: "source",
+			value: await host.client.uploadSource(requiredString(raw.nb, "--nb"), await host.createFileSource(file), {
+				...optionalString(raw, "title") === void 0 ? {} : { title: optionalString(raw, "title") },
+				...optionalString(raw, "type") === void 0 ? {} : { sourceType: optionalString(raw, "type") },
+				...optionalString(raw, "parent") === void 0 ? {} : { parentSourceId: optionalString(raw, "parent") },
+				...optionalString(raw, "path") === void 0 ? {} : { path: optionalString(raw, "path") }
+			})
+		});
+	});
+	withCommon(source.command("download <source_id>").description("Download the original source file"), false).option("--nb <id>", "notebook ID (required)").option("-o, --output <path>", "output file path").option("--overwrite", "replace an existing target").action(async (sourceId, raw) => {
+		const host = await hostFor(context, raw);
+		const record = await host.client.getSource(requiredString(raw.nb, "--nb"), sourceId);
+		if (record.originUrl === void 0 || record.originUrl.length === 0) throw new QMindError("NOT_FOUND", "source has no downloadable original file");
+		const output = optionalString(raw, "output") ?? safeQMindDownloadName(record.title, sourceId);
+		const bytes = await host.downloadToFile({
+			overwrite: raw.overwrite === true,
+			targetPath: output,
+			url: record.originUrl
+		});
+		context.io.stderr(`Downloaded ${output} (${bytes} bytes)\n`);
+	});
+	withCommon(source.command("mv <source_id>").alias("move").description("Move or rename a source")).option("--nb <id>", "notebook ID (required)").option("--parent <id>", "new parent; pass an empty string for root").option("--path <path>", "new source path").option("--rename <title>", "new source title").option("--status <status>", "new source status").action(async (sourceId, raw) => {
+		const patch = {
+			...raw.parent === void 0 ? {} : { parentSourceId: String(raw.parent) },
+			...raw.path === void 0 ? {} : { path: String(raw.path) },
+			...raw.rename === void 0 ? {} : { title: String(raw.rename) },
+			...raw.status === void 0 ? {} : { status: String(raw.status) }
+		};
+		if (Object.keys(patch).length === 0) throw new QMindError("INVALID_ARGUMENT", "at least one of --parent, --path, --rename or --status is required");
+		render(context, raw, {
+			kind: "source",
+			value: await (await hostFor(context, raw)).client.moveSource(requiredString(raw.nb, "--nb"), sourceId, patch)
+		});
+	});
+	withCommon(source.command("content <source_id>").description("Read parsed source content"), false).option("--nb <id>", "notebook ID (required)").option("--download <path>", "save content to a file").option("--no-overwrite", "refuse to replace an existing file").action(async (sourceId, raw) => {
+		const content = await (await hostFor(context, raw)).client.getSourceContent(requiredString(raw.nb, "--nb"), sourceId);
+		const path = optionalString(raw, "download");
+		if (path === void 0) context.io.stdout(content.content);
+		else {
+			await atomicQMindWrite(path, content.content, raw.overwrite !== false);
+			context.io.stdout(`content saved to ${path}\n`);
+		}
+	});
+	withCommon(source.command("delete <source_id>").description("Delete a source"), false).option("--nb <id>", "notebook ID (required)").option("--force", "skip directory cascade confirmation").action(async (sourceId, raw) => {
+		const host = await hostFor(context, raw);
+		const notebookId = requiredString(raw.nb, "--nb");
+		if (raw.force !== true) {
+			const record = await host.client.getSource(notebookId, sourceId).catch(() => void 0);
+			if (record?.isDir === true && !await context.confirm.confirm(`warning: source ${JSON.stringify(record.title)} is a directory. Deleting it will cascade-delete ALL children.\nType 'y' to proceed: `)) {
+				context.io.stderr("aborted\n");
+				context.exitCode = 1;
+				return;
+			}
+		}
+		await host.client.deleteSource(notebookId, sourceId);
+		context.io.stdout("deleted\n");
+	});
+	withCommon(source.command("import-site").description("Import a complete web site")).option("--nb <id>", "notebook ID (required)").option("--url <url>", "site root URL (required)").option("--title <title>", "source title").option("--parent <id>", "parent source ID", "").option("--path-prefix <path>", "path prefix", "").option("--max-pages <number>", "maximum page count", integer, 50).option("--sitemap <url>", "sitemap URL", "").option("--include <patterns>", "comma-separated include patterns", "").option("--exclude <patterns>", "comma-separated exclude patterns", "").option("--compile-after-refresh", "enqueue compilation after import").action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const rootUrl = requiredString(raw.url, "--url");
+		const value = await host.client.importSite(requiredString(raw.nb, "--nb"), {
+			compileAfterRefresh: raw.compileAfterRefresh === true,
+			excludePaths: splitCsv(stringOption(raw, "exclude")),
+			includePaths: splitCsv(stringOption(raw, "include")),
+			maxPages: numberOption(raw, "maxPages", 50),
+			parentSourceId: String(raw.parent ?? ""),
+			pathPrefix: String(raw.pathPrefix ?? ""),
+			rootUrl,
+			sitemapUrl: optionalString(raw, "sitemap"),
+			title: optionalString(raw, "title")
+		});
+		const format = formatOf(raw);
+		if (format === "json" || format === "ndjson") render(context, raw, {
+			kind: "source",
+			value
+		});
+		else context.io.stdout(`Site source created: ${value.id}\n  title : ${value.title}\n  status: ${value.status}\n  site  : ${rootUrl}\n\nSite import is running asynchronously. Use '${distribution.command} source list' to check imported pages.\n`);
+	});
+	const image = program.command("image").description("Notebook image presign operations");
+	withCommon(image.command("presign-upload").description("Presign or upload a notebook image"), false).option("--nb <id>", "notebook ID (required)").option("--source <id>", "source ID (required)").option("--filename <name>", "image filename (required unless --file is set)").option("--mime <type>", "MIME type (required unless --file is set)").option("--size <bytes>", "file size", integer, 0).option("--file <path>", "local image to upload").action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const notebookId = requiredString(raw.nb, "--nb");
+		const sourceId = requiredString(raw.source, "--source");
+		const file = optionalString(raw, "file");
+		const filename = optionalString(raw, "filename");
+		const mimeType = optionalString(raw, "mime");
+		const value = file === void 0 ? await host.client.presignImageUpload(notebookId, sourceId, {
+			filename: requiredString(filename, "--filename"),
+			mimeType: requiredString(mimeType, "--mime"),
+			size: numberOption(raw, "size", 0)
+		}) : await host.client.uploadImage(notebookId, sourceId, await host.createFileSource(file, {
+			...filename === void 0 ? {} : { filename },
+			...mimeType === void 0 ? {} : { mimeType }
+		}));
+		if (file !== void 0) context.io.stderr(`uploaded ${file} -> ossKey=${value.ossKey}\n`);
+		context.io.stdout(renderQMindCliPresentation({
+			kind: "imageUpload",
+			value
+		}, "json"));
+	});
+	withCommon(image.command("presign-urls").description("Create inline preview URLs"), false).option("--nb <id>", "notebook ID (required)").option("--keys <keys>", "comma-separated OSS keys (required)").action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const keys = splitCsv(requiredString(raw.keys, "--keys"));
+		const value = await host.client.presignImageUrls(requiredString(raw.nb, "--nb"), keys);
+		context.io.stdout(renderQMindCliPresentation({
+			kind: "imageUrls",
+			value
+		}, "json"));
+	});
+}
+async function renderAgentRun(context, host, notebookId, raw, input) {
+	const run = await host.client.startAgentRun(notebookId, input);
+	const renderer = createQMindCliStreamRenderer(formatOf(raw));
+	for await (const event of run.events) {
+		if (event.type === "error") throw new QMindError("STREAM_ERROR", event.message);
+		context.io.stdout(renderer.push(event));
+	}
+	context.io.stdout(renderer.finish());
+}
+function registerSceneCommands(context, program) {
+	withCommon(program.command("rag [question]").description("Ask a question using notebook RAG")).option("--nb <id>", "notebook ID (required)").option("-q, --query <query>", "question").option("--top-k <number>", "top-k for retrieval", integer, 0).option("--max-results <number>", "maximum context results", integer, 0).action(async (question, raw) => {
+		await renderAgentRun(context, await hostFor(context, raw), requiredString(raw.nb, "--nb"), raw, {
+			maxResults: numberOption(raw, "maxResults", 0),
+			question: requiredString(raw.query || question, "--query or positional question"),
+			scene: "rag",
+			topK: numberOption(raw, "topK", 0)
+		});
+	});
+	for (const [name, scene] of [["compile", "compilation"], ["lint", "lint"]]) withCommon(program.command(name).description(`Run notebook ${scene}`)).option("--nb <id>", "notebook ID (required)").action(async (raw) => {
+		await renderAgentRun(context, await hostFor(context, raw), requiredString(raw.nb, "--nb"), raw, { scene });
+	});
+}
+function registerTaskCommands(context, program) {
+	const task = program.command("task").description("Manage notebook task runs");
+	withCommon(task.command("create").description("Create a notebook task run")).option("--nb <id>", "notebook ID (required)").option("--scene <scene>", "task scene: compilation | source_refresh | condensation | lint").option("--trigger <trigger>", "task trigger", "manual").option("--sources <ids>", "comma-separated source IDs", "").action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const sourceIds = splitCsv(stringOption(raw, "sources"));
+		render(context, raw, {
+			kind: "json",
+			value: await host.client.createTaskRun(requiredString(raw.nb, "--nb"), {
+				...sourceIds.length === 0 ? {} : { config: { sourceIds } },
+				sceneType: requiredString(raw.scene, "--scene"),
+				trigger: String(raw.trigger ?? "manual")
+			})
+		});
+	});
+	withCommon(task.command("list").description("List notebook task runs")).option("--nb <id>", "notebook ID (required)").option("--scene <scene>", "filter by scene", "").option("--trigger <trigger>", "filter by trigger", "").option("--status <status>", "filter by status", "").option("--parent-run <id>", "filter by parent run ID", "").option("--scheduled-task <id>", "filter by scheduled task ID", "").option("--page <number>", "page number", integer, 0).option("--page-size <number>", "page size", integer, 20).action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const status = optionalString(raw, "status");
+		render(context, raw, {
+			kind: "json",
+			value: await host.client.listTaskRuns(requiredString(raw.nb, "--nb"), {
+				page: numberOption(raw, "page", 0),
+				pageSize: numberOption(raw, "pageSize", 20),
+				parentRunId: String(raw.parentRun ?? ""),
+				sceneType: String(raw.scene ?? ""),
+				scheduledTaskId: String(raw.scheduledTask ?? ""),
+				...status === void 0 ? {} : { status },
+				trigger: String(raw.trigger ?? "")
+			})
+		});
+	});
+	withCommon(task.command("get <run_id>").description("Get a notebook task run")).option("--nb <id>", "notebook ID (required)").action(async (runId, raw) => {
+		render(context, raw, {
+			kind: "json",
+			value: await (await hostFor(context, raw)).client.getTaskRun(requiredString(raw.nb, "--nb"), runId)
+		});
+	});
+}
+function syncText(stats) {
+	return `[upload-folder] 完成: 创建目录 ${stats.dirs_created} (复用 ${stats.dirs_reused}, 失败 ${stats.dirs_failed}), 上传文件 ${stats.files_uploaded}, 已存在跳过 ${stats.files_already_exist}, 不支持或忽略 ${stats.files_skipped}, 失败 ${stats.files_failed}, 时间戳刷新失败 ${stats.dirs_refresh_failed}` + (stats.files_deleted === void 0 ? "" : `, 删除文件 ${stats.files_deleted}, 删除目录 ${stats.dirs_deleted ?? 0}, 删除失败 ${stats.delete_failed ?? 0}`) + "\n";
+}
+function registerSyncCommand(context, program) {
+	withCommon(program.command("upload-folder").alias("sync").description("Synchronize a local folder"), false).option("--nb <id>", "notebook ID (required)").option("--dir <path>", "local directory (required)").option("--extensions <list>", "comma-separated extensions").option("--dir-ids <path>", "existing directory ID mapping").option("--skip-upload", "only refresh directory timestamps").option("--concurrency <number>", "parallel uploads", integer, 3).option("--save-dir-ids <path>", "directory ID mapping output").option("--ignore <patterns...>", "glob patterns to exclude").option("--delete", "delete remote entries absent from the local mirror").option("--dry-run", "calculate changes without mutating remote or local state").option("--format <format>", "summary output format: json | text", "json").addOption(new Option("--mode <mode>", "existing-file behavior").choices([
+		"skip",
+		"overwrite",
+		"if-changed"
+	]).default("skip")).action(async (raw) => {
+		const host = await hostFor(context, raw);
+		const ignoreValues = Array.isArray(raw.ignore) ? raw.ignore.flatMap((value) => splitCsv(String(value))) : [];
+		const directoryIdsPath = optionalString(raw, "dirIds");
+		const saveDirectoryIdsPath = optionalString(raw, "saveDirIds");
+		const extensions = splitCsv(optionalString(raw, "extensions"));
+		const result = await synchronizeQMindFolder(host, {
+			baseDirectory: requiredString(raw.dir, "--dir"),
+			cacheDirectory: join(host.config.homeDirectory, "cache"),
+			concurrency: Math.max(1, numberOption(raw, "concurrency", 3)),
+			delete: raw.delete === true,
+			dryRun: raw.dryRun === true,
+			...extensions.length === 0 ? {} : { extensions },
+			ignorePatterns: ignoreValues,
+			mode: String(raw.mode ?? "skip"),
+			notebookId: requiredString(raw.nb, "--nb"),
+			skipUpload: raw.skipUpload === true,
+			...directoryIdsPath === void 0 ? {} : { directoryIdsPath },
+			...saveDirectoryIdsPath === void 0 ? {} : { saveDirectoryIdsPath }
+		});
+		result.diagnostics.forEach((message) => context.io.stderr(`[upload-folder] ${message}\n`));
+		if (String(raw.format ?? "json") === "text") context.io.stderr(syncText(result.stats));
+		else context.io.stdout(renderQMindCliPresentation({
+			kind: "json",
+			value: result.stats
+		}, "json"));
+		if (result.exitCode === 1) context.exitCode = 1;
+	});
+}
+function registerUpdateCommand(program) {
+	program.command("self-update").description("Show the supported qmind CLI upgrade path").option("--url <url>", "legacy update URL (ignored)").addOption(new Option("--channel <channel>", "legacy release channel (ignored)").choices([
+		"stable",
+		"beta",
+		"daily"
+	]).default("stable")).option("--public-key <key>", "legacy public key (ignored)").option("--check", "legacy check mode (ignored)").option("--force", "legacy reinstall mode (ignored)").option("--allow-downgrade", "legacy downgrade mode (ignored)").action(() => {
+		throw new QMindError("UNSUPPORTED_OPERATION", `self-update is unavailable for npm installs; run npm update --global ${distribution.package}`);
+	});
+}
+/** Internal parser adapter. Product consumers should call runQMindCli(). */
+function createQMindCliProgram(context) {
+	const program = new Command().name(distribution.command).description("QMind knowledge CLI").version(QMIND_CLI_VERSION).showHelpAfterError().exitOverride().configureOutput({
+		writeErr: (value) => context.io.stderr(value),
+		writeOut: (value) => context.io.stdout(value)
+	});
+	program.command("version").description("Print version and build information").action(() => {
+		context.io.stdout(`${distribution.command} ${QMIND_CLI_VERSION} (built ${QMIND_CLI_BUILD_TIME}, ${qmindCliPlatform()}/${qmindCliArchitecture()})\n`);
+	});
+	registerCoreCommands(context, program);
+	registerSourceCommands(context, program);
+	registerSceneCommands(context, program);
+	registerTaskCommands(context, program);
+	registerSyncCommand(context, program);
+	registerUpdateCommand(program);
+	return program;
+}
+async function runQMindCli(argv, options = {}) {
+	const io = options.io ?? processIO();
+	const context = {
+		confirm: options.confirm ?? interactiveConfirm(io),
+		exitCode: 0,
+		host: void 0,
+		hostFactory: options.hostFactory ?? createQMindCliHost,
+		hostOptions: options.hostOptions ?? {},
+		io
+	};
+	const normalized = normalizeLegacyArgv(argv);
+	const requiresLegacyAction = normalized.length === 0 || normalized.length === 1 && (/* @__PURE__ */ new Set([
+		"notebook",
+		"cards",
+		"source",
+		"image"
+	])).has(normalized[0] ?? "");
+	let exitCode;
+	try {
+		await createQMindCliProgram(context).parseAsync(normalized, { from: "user" });
+		exitCode = context.exitCode;
+	} catch (error) {
+		if (error instanceof CommanderError) exitCode = error.code === "commander.help" || error.code === "commander.helpDisplayed" || error.code === "commander.version" ? 0 : 2;
+		else {
+			const rendered = renderQMindCliError(error, requestsJsonOutput(normalized));
+			if (rendered.stdout.length > 0) io.stdout(rendered.stdout);
+			if (rendered.stderr.length > 0) io.stderr(rendered.stderr);
+			exitCode = rendered.exitCode;
+		}
+	}
+	if (exitCode === 0 && requiresLegacyAction) exitCode = 2;
+	try {
+		await context.host?.close();
+	} catch {
+		io.stderr("error: failed to close the QMind CLI host\n");
+		if (exitCode === 0) exitCode = 1;
+	}
+	return exitCode;
+}
+//#endregion
+//#region src/qmind.ts
+process.exitCode = await runQMindCli(process.argv.slice(2));
+//#endregion
+export {};