@qoder-ai/qmind-cli 1.1.0

package/dist/qmind.js

@@ -0,0 +1,4901 @@
+import { createInterface } from "node:readline/promises";
+import { z } from "zod";
+import { Command, CommanderError, Option } from "commander";
+import { createHash, randomBytes } from "node:crypto";
+import { chmod, copyFile, link, lstat, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { createReadStream, createWriteStream } from "node:fs";
+import { homedir } from "node:os";
+import pLimit from "p-limit";
+import picomatch from "picomatch";
+import open from "open";
+import lockfile from "proper-lockfile";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createParser } from "eventsource-parser";
+import { Agent, EnvHttpProxyAgent, request } from "undici";
+import { decodeHTML } from "entities";
+//#region ../sdk/src/errors.ts
+var QMindError = class extends Error {
+	access;
+	code;
+	details;
+	operation;
+	rawBody;
+	requestId;
+	status;
+	upstreamCode;
+	constructor(code, message, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "QMindError";
+		this.access = options.access;
+		this.code = code;
+		this.details = options.details;
+		this.operation = options.operation;
+		this.rawBody = options.rawBody;
+		this.requestId = options.requestId;
+		this.status = options.status;
+		this.upstreamCode = options.upstreamCode;
+	}
+};
+//#endregion
+//#region ../sdk/src/execution.ts
+const credentialHeaders = /* @__PURE__ */ new Set([
+	"authorization",
+	"cookie",
+	"proxy-authorization",
+	"x-csrf-token",
+	"x-xsrf-token"
+]);
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nestedRecord(value, key) {
+	const nested = value[key];
+	return isRecord$4(nested) ? nested : void 0;
+}
+function firstString(records, keys) {
+	for (const record of records) {
+		if (record === void 0) continue;
+		for (const key of keys) {
+			const value = record[key];
+			if (typeof value === "string" && value.length > 0) return value;
+		}
+	}
+}
+function headerValue(headers, name) {
+	const normalizedName = name.toLowerCase();
+	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === normalizedName && value.length > 0) return value;
+}
+function errorCodeForStatus$1(status) {
+	if (status === 401) return "AUTH_REQUIRED";
+	if (status === 403) return "FORBIDDEN";
+	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 httpError(access, operation, profile, response) {
+	const body = profile.unwrapError(response.body);
+	const root = isRecord$4(body) ? body : void 0;
+	const records = [
+		root,
+		root === void 0 ? void 0 : nestedRecord(root, "error"),
+		root === void 0 ? void 0 : nestedRecord(root, "details")
+	];
+	const upstreamCode = firstString(records, [
+		"errorCode",
+		"error_code",
+		"code"
+	]);
+	const requestId = firstString(records, ["requestId", "request_id"]) ?? headerValue(response.headers, "x-request-id") ?? headerValue(response.headers, "request-id");
+	const message = firstString(records, [
+		"message",
+		"errorMessage",
+		"error_message"
+	]) ?? `QMind request failed with HTTP ${response.status}`;
+	return new QMindError(errorCodeForStatus$1(response.status), message, {
+		access,
+		details: body,
+		operation,
+		...response.rawBody === void 0 ? {} : { rawBody: response.rawBody },
+		...requestId === void 0 ? {} : { requestId },
+		status: response.status,
+		...upstreamCode === void 0 ? {} : { upstreamCode }
+	});
+}
+function isAbortLike(cause) {
+	return isRecord$4(cause) && (cause.name === "AbortError" && typeof cause.name === "string" || cause.code === "ABORT_ERR");
+}
+function transportError(access, operation, request, cause) {
+	if (cause instanceof QMindError) return cause;
+	const aborted = request.signal?.aborted === true || isAbortLike(cause);
+	return new QMindError(aborted ? "ABORTED" : "NETWORK_ERROR", aborted ? "QMind request was aborted" : "QMind transport failed", {
+		access,
+		cause,
+		operation
+	});
+}
+function requestWasAborted(request) {
+	return request.signal?.aborted === true;
+}
+function assertWireRequestInvariant(request) {
+	if (!Number.isFinite(request.timeoutMs ?? 1) || (request.timeoutMs ?? 1) <= 0) throw new QMindError("INVALID_ARGUMENT", "timeoutMs must be a positive finite number", { details: { field: "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 a root-relative path", { details: { destination: request.destination.kind } });
+		return;
+	}
+	let url;
+	try {
+		url = new URL(request.destination.url);
+	} catch (cause) {
+		throw new QMindError("HOST_POLICY_ERROR", "signed destination must be a valid HTTPS URL", {
+			cause,
+			details: { destination: request.destination.kind }
+		});
+	}
+	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", { details: { destination: request.destination.kind } });
+	for (const header of Object.keys(request.headers ?? {})) if (credentialHeaders.has(header.toLowerCase())) throw new QMindError("HOST_POLICY_ERROR", "host credentials must never be sent to a signed destination", { details: {
+		destination: request.destination.kind,
+		header: header.toLowerCase()
+	} });
+}
+function assertCapability(profile, capability, operation) {
+	if (profile.capabilities[capability]) return;
+	throw new QMindError("UNSUPPORTED_OPERATION", `${operation} is not supported by the ${profile.access} access profile`, {
+		access: profile.access,
+		details: { capability },
+		operation
+	});
+}
+async function executeUnary(options) {
+	const { capability, operation, profile, request, schema, transport } = options;
+	assertCapability(profile, capability, operation);
+	assertWireRequestInvariant(request);
+	if (requestWasAborted(request)) throw new QMindError("ABORTED", "QMind request was aborted", {
+		access: profile.access,
+		operation
+	});
+	let response;
+	try {
+		response = await transport.request(request);
+	} catch (cause) {
+		throw transportError(profile.access, operation, request, cause);
+	}
+	if (response.status < 200 || response.status >= 300) throw httpError(profile.access, operation, profile, response);
+	const body = profile.unwrapSuccess(operation, response.body);
+	const parsed = schema.safeParse(body);
+	if (!parsed.success) throw new QMindError("PROTOCOL_ERROR", "server response does not match the QMind contract", {
+		access: profile.access,
+		details: { issues: parsed.error.issues },
+		operation,
+		...response.rawBody === void 0 ? {} : { rawBody: response.rawBody },
+		status: response.status
+	});
+	return parsed.data;
+}
+function streamContractError(profile, operation, message, details) {
+	return new QMindError("STREAM_ERROR", message, {
+		access: profile.access,
+		...details === void 0 ? {} : { details },
+		operation
+	});
+}
+function streamFailureResponse(response) {
+	return {
+		body: response.body,
+		headers: response.headers,
+		...response.rawBody === void 0 ? {} : { rawBody: response.rawBody },
+		status: response.status
+	};
+}
+async function* executeStream(options) {
+	const { capability, operation, profile, request, transport } = options;
+	assertCapability(profile, capability, operation);
+	assertWireRequestInvariant(request);
+	if (requestWasAborted(request)) throw new QMindError("ABORTED", "QMind request was aborted", {
+		access: profile.access,
+		operation
+	});
+	let response;
+	try {
+		response = await transport.stream(request);
+	} catch (cause) {
+		throw transportError(profile.access, operation, request, cause);
+	}
+	if (response.kind === "response") {
+		if (response.status >= 200 && response.status < 300) throw streamContractError(profile, operation, "stream handshake returned no event stream", { status: response.status });
+		throw httpError(profile.access, operation, profile, streamFailureResponse(response));
+	}
+	if (response.status < 200 || response.status >= 300) throw streamContractError(profile, operation, "stream handshake returned events for a failure status", { status: response.status });
+	let doneMarkerSeen = false;
+	let started = false;
+	let terminal = false;
+	try {
+		for await (const payload of response.events) {
+			if (requestWasAborted(request)) throw new QMindError("ABORTED", "QMind request was aborted", {
+				access: profile.access,
+				operation
+			});
+			if (payload.trim() === "[DONE]") {
+				if (doneMarkerSeen) throw streamContractError(profile, operation, "stream emitted more than one [DONE] marker");
+				doneMarkerSeen = true;
+				continue;
+			}
+			if (doneMarkerSeen) throw streamContractError(profile, operation, "stream emitted an event after [DONE]");
+			if (terminal) throw streamContractError(profile, operation, "stream emitted an event after messageComplete");
+			const event = profile.decodeStreamPayload(payload);
+			if (event.type === "error") throw streamContractError(profile, operation, event.message, { event });
+			if (event.type === "messageStart") {
+				if (started) throw streamContractError(profile, operation, "stream emitted duplicate messageStart");
+				started = true;
+			} else if (!started) throw streamContractError(profile, operation, "stream event arrived before messageStart", { eventType: event.type });
+			if (event.type === "messageComplete") terminal = true;
+			yield event;
+		}
+	} catch (cause) {
+		throw transportError(profile.access, operation, request, cause);
+	}
+	if (requestWasAborted(request)) throw new QMindError("ABORTED", "QMind request was aborted", {
+		access: profile.access,
+		operation
+	});
+	if (!terminal) throw streamContractError(profile, operation, "stream ended before messageComplete", {
+		doneMarkerSeen,
+		started
+	});
+}
+//#endregion
+//#region ../sdk/src/workflows.ts
+const QMIND_MULTIPART_UPLOAD_MAX_BYTES = 52428800;
+const QMIND_SOURCE_UPLOAD_MAX_BYTES = 524288e3;
+Object.freeze({
+	canceled: {
+		order: 2,
+		outcome: "canceled",
+		phase: "terminal",
+		terminal: true
+	},
+	failed: {
+		order: 2,
+		outcome: "failure",
+		phase: "terminal",
+		terminal: true
+	},
+	partial: {
+		order: 2,
+		outcome: "partial",
+		phase: "terminal",
+		terminal: true
+	},
+	pending: {
+		order: 0,
+		outcome: "none",
+		phase: "queued",
+		terminal: false
+	},
+	running: {
+		order: 1,
+		outcome: "none",
+		phase: "active",
+		terminal: false
+	},
+	success: {
+		order: 2,
+		outcome: "success",
+		phase: "terminal",
+		terminal: true
+	},
+	unknown: {
+		order: -1,
+		outcome: "none",
+		phase: "unknown",
+		terminal: false
+	}
+});
+function normalizeQMindTaskRunStatus(status) {
+	switch (status.trim().toLowerCase()) {
+		case "pending":
+		case "running":
+		case "success":
+		case "partial":
+		case "failed":
+		case "canceled": return status.trim().toLowerCase();
+		default: return "unknown";
+	}
+}
+//#endregion
+//#region ../sdk/src/schemas.ts
+const timestampSchema = z.union([z.string(), z.object({
+	nanos: z.number().int().optional(),
+	seconds: z.union([z.number(), z.string()])
+})]).nullable();
+const notebookOverviewSchema = z.object({
+	status: z.string().default("empty"),
+	summary: z.string().default(""),
+	topics: z.array(z.string()).nullish().transform((topics) => topics ?? [])
+});
+const notebookMaintenanceSchema = z.object({
+	lastRunAt: timestampSchema.optional(),
+	lastRunId: z.string().optional(),
+	status: z.string().default("idle")
+});
+const notebookAccessInfoSchema = z.object({
+	canDeleteNotebook: z.boolean(),
+	canEdit: z.boolean(),
+	canManageMembers: z.boolean(),
+	canManageTasks: z.boolean(),
+	currentUserPermission: z.string(),
+	memberCount: z.number().int().nonnegative()
+});
+const notebookSchema = z.object({
+	access: notebookAccessInfoSchema.nullable().optional(),
+	client: z.string().optional(),
+	createdAt: timestampSchema.optional(),
+	description: z.string().default(""),
+	id: z.string().min(1),
+	maintenance: notebookMaintenanceSchema.optional(),
+	materialCount: z.number().int().nonnegative().default(0),
+	orgId: z.string().default(""),
+	overview: notebookOverviewSchema.optional(),
+	settings: z.record(z.string(), z.unknown()).optional(),
+	sourceCount: z.number().int().nonnegative().default(0),
+	status: z.string().default("active"),
+	title: z.string(),
+	updatedAt: timestampSchema.optional(),
+	userId: z.string().default("")
+});
+const notebookListSchema = z.object({
+	currentPage: z.number().int().positive().optional(),
+	notebooks: z.array(notebookSchema),
+	pageSize: z.number().int().positive().optional(),
+	totalSize: z.number().int().nonnegative().default(0)
+});
+const wikiDocumentSchema = z.object({
+	contentHash: z.string().default(""),
+	contentUrl: z.string().min(1),
+	language: z.string().default("")
+});
+const wikiBranchSchema = z.object({
+	branch: z.string().min(1),
+	commitTimestamp: z.number().optional(),
+	documents: z.array(wikiDocumentSchema).default([]),
+	knowledgeCount: z.number().int().nonnegative().default(0),
+	repo: z.string().min(1),
+	repoUrl: z.string().optional(),
+	resultVersion: z.string().default("")
+});
+const wikiBranchListSchema = z.object({ branches: z.array(wikiBranchSchema) });
+const cardLinkSchema = z.object({
+	description: z.string().optional(),
+	linkType: z.string().default(""),
+	targetId: z.string().min(1),
+	targetTitle: z.string().optional()
+});
+const cardSchema = z.object({
+	cardType: z.string().optional(),
+	category: z.string().optional(),
+	content: z.string().default(""),
+	createdAt: timestampSchema.optional(),
+	extra: z.string().optional(),
+	id: z.string().min(1),
+	keywords: z.array(z.string()).default([]),
+	knowledgeId: z.string().optional(),
+	links: z.array(cardLinkSchema).default([]),
+	notebookId: z.string().optional(),
+	orgId: z.string().optional(),
+	repo: z.string().optional(),
+	score: z.number().optional(),
+	source: z.string().optional(),
+	title: z.string().default(""),
+	updatedAt: timestampSchema.optional()
+});
+const cardListSchema = z.object({
+	cards: z.array(cardSchema).nullish().transform((cards) => cards ?? []),
+	currentPage: z.number().int().positive().optional(),
+	pageSize: z.number().int().positive().optional(),
+	totalSize: z.number().int().nonnegative().default(0)
+});
+const sourcePageInfoSchema = z.object({
+	currentPage: z.number().int().positive().optional(),
+	lastPage: z.number().int().positive().optional(),
+	nextPage: z.number().int().positive().optional(),
+	nextToken: z.string().optional(),
+	pageSize: z.number().int().positive().optional(),
+	prevPage: z.number().int().positive().optional(),
+	totalSize: z.number().int().nonnegative().optional()
+});
+const sourceSchema = z.object({
+	childrenCount: z.number().int().nonnegative().optional(),
+	createdAt: timestampSchema.optional(),
+	errorMessage: z.string().default(""),
+	hasChildren: z.boolean().optional(),
+	id: z.string().min(1),
+	isDir: z.boolean().default(false),
+	metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+	notebookId: z.string().default(""),
+	orgId: z.string().default(""),
+	originUrl: z.string().optional(),
+	parentSourceId: z.string().default(""),
+	path: z.string().default(""),
+	sourceType: z.string().default(""),
+	status: z.string().default(""),
+	title: z.string().default(""),
+	updatedAt: timestampSchema.optional(),
+	uri: z.string().default(""),
+	userId: z.string().default("")
+});
+const sourceListSchema = z.object({
+	currentPage: z.number().int().positive().optional(),
+	pageSize: z.number().int().positive().optional(),
+	pages: sourcePageInfoSchema.optional(),
+	sources: z.array(sourceSchema),
+	totalSize: z.number().int().nonnegative().optional()
+});
+const sourceTreeNodeSchema = z.lazy(() => z.object({
+	files: z.array(sourceTreeNodeSchema).default([]),
+	id: z.string().min(1),
+	name: z.string().default(""),
+	path: z.string().default(""),
+	sourceType: z.string().default(""),
+	status: z.string().default(""),
+	type: z.enum(["file", "directory"])
+}));
+const sourceTreeSchema = z.object({
+	totalSize: z.number().int().nonnegative().default(0),
+	tree: z.array(sourceTreeNodeSchema)
+});
+const sourceContentSchema = z.object({
+	content: z.string(),
+	contentType: z.string().default("text/markdown"),
+	sourceId: z.string().default("")
+});
+const sourceImportResultSchema = z.object({
+	error: z.string().optional(),
+	source: sourceSchema.optional(),
+	url: z.string().default("")
+});
+const sourceImportResultsSchema = z.object({ results: z.array(sourceImportResultSchema) }).transform((value) => value.results);
+const batchMutationResultSchema = z.object({
+	failureCount: z.number().int().nonnegative().default(0),
+	successCount: z.number().int().nonnegative().default(0)
+});
+const voidResponseSchema = z.unknown().transform(() => void 0);
+const httpsUrlSchema = z.string().url().refine((value) => new URL(value).protocol === "https:", "expected an HTTPS URL");
+const imageUploadTicketSchema = z.object({
+	expiresAt: z.string().optional(),
+	headers: z.record(z.string(), z.string()).default({}),
+	method: z.literal("PUT").default("PUT"),
+	ossKey: z.string().min(1),
+	uploadUrl: httpsUrlSchema
+});
+const imageUrlsSchema = z.object({
+	expiresAt: z.string().optional(),
+	urls: z.record(z.string(), httpsUrlSchema)
+});
+const chatMessageSchema = z.object({
+	content: z.string().default(""),
+	id: z.string().min(1),
+	role: z.string().default("")
+});
+const streamWireEventSchema = z.object({
+	assistantMessage: chatMessageSchema.optional(),
+	assistantMessageId: z.string().optional(),
+	cancelReason: z.string().optional(),
+	canceled: z.boolean().optional(),
+	citations: z.array(z.string()).optional(),
+	delta: z.string().optional(),
+	errorMessage: z.string().optional(),
+	error: z.string().optional(),
+	eventType: z.string().optional(),
+	event_type: z.string().optional(),
+	metadata: z.record(z.string(), z.string()).optional(),
+	promptContext: z.string().optional(),
+	reranked: z.boolean().optional(),
+	step: z.number().int().optional(),
+	toolArguments: z.string().optional(),
+	toolDisplayName: z.string().optional(),
+	toolName: z.string().optional(),
+	toolResult: z.string().optional(),
+	totalContextChunks: z.number().int().nonnegative().optional(),
+	type: z.string().optional(),
+	userMessage: chatMessageSchema.optional()
+});
+const sourceUploadTicketSchema = z.object({
+	expiresAt: z.string().optional(),
+	headers: z.record(z.string(), z.string()).default({}),
+	method: z.literal("PUT").default("PUT"),
+	uploadUrl: httpsUrlSchema,
+	uri: z.string().min(1)
+});
+const chatSessionSchema = z.object({
+	createdAt: timestampSchema.optional(),
+	id: z.string().min(1),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	modelOverride: z.string().default(""),
+	notebookId: z.string().default(""),
+	orgId: z.string().default(""),
+	sceneType: z.string().default("rag"),
+	status: z.string().default("active"),
+	title: z.string().default(""),
+	updatedAt: timestampSchema.optional(),
+	userId: z.string().default("")
+});
+const notebookCitationSchema = z.object({
+	chunkId: z.string().default(""),
+	chunkIndex: z.number().int().nonnegative().default(0),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	originUrl: z.string().optional(),
+	snippet: z.string().default(""),
+	sourceId: z.string().default(""),
+	sourceTitle: z.string().default(""),
+	sourceUri: z.string().default("")
+});
+const notebookContextChunkSchema = z.object({
+	chunkId: z.string().default(""),
+	chunkIndex: z.number().int().nonnegative().default(0),
+	content: z.string().default(""),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	originUrl: z.string().optional(),
+	score: z.number().finite().default(0),
+	sourceId: z.string().default(""),
+	sourceTitle: z.string().default(""),
+	sourceUri: z.string().default(""),
+	tokenCount: z.number().int().nonnegative().default(0)
+});
+const retrievedCardLinkSchema = z.object({
+	description: z.string().optional(),
+	linkType: z.string().default(""),
+	targetId: z.string().min(1),
+	targetTitle: z.string().optional()
+});
+const retrievedCardSchema = z.object({
+	cardType: z.string().optional(),
+	category: z.string().optional(),
+	content: z.string().default(""),
+	depth: z.number().int().nonnegative().default(0),
+	id: z.string().min(1),
+	keywords: z.array(z.string()).default([]),
+	links: z.array(retrievedCardLinkSchema).default([]),
+	score: z.number().finite().default(0),
+	title: z.string().default("")
+});
+const retrieveResultSchema = z.object({
+	cards: z.array(retrievedCardSchema).default([]),
+	chunks: z.array(notebookContextChunkSchema).default([]),
+	citations: z.array(notebookCitationSchema).default([]),
+	promptContext: z.string().default(""),
+	reranked: z.boolean().default(false),
+	total: z.number().int().nonnegative().default(0)
+});
+const cancelQuestionResultSchema = z.object({ accepted: z.boolean() });
+const taskRunSchema = z.object({
+	assistantMessageId: z.string().optional(),
+	chatSessionId: z.string().optional(),
+	config: z.record(z.string(), z.unknown()).optional(),
+	createdAt: timestampSchema.optional(),
+	durationMs: z.number().int().nonnegative().optional(),
+	errorMessage: z.string().optional(),
+	finishedAt: timestampSchema.optional(),
+	id: z.string().min(1),
+	message: chatMessageSchema.optional(),
+	notebookId: z.string().default(""),
+	orgId: z.string().default(""),
+	parentRunId: z.string().optional(),
+	reportMarkdown: z.string().optional(),
+	sceneType: z.string().default(""),
+	scheduledTaskId: z.string().optional(),
+	startedAt: timestampSchema.optional(),
+	stats: z.record(z.string(), z.unknown()).optional(),
+	status: z.string().default(""),
+	trigger: z.string().default(""),
+	updatedAt: timestampSchema.optional(),
+	userId: z.string().default("")
+}).transform((value) => ({
+	...value,
+	rawStatus: value.status,
+	status: normalizeQMindTaskRunStatus(value.status)
+}));
+const taskRunListSchema = z.object({
+	currentPage: z.number().int().positive().optional(),
+	pageSize: z.number().int().positive().optional(),
+	runs: z.array(taskRunSchema).default([]),
+	totalSize: z.number().int().nonnegative().default(0)
+});
+//#endregion
+//#region ../sdk/src/operations/shared.ts
+function invalidArgument$1(message, field, details) {
+	return new QMindError("INVALID_ARGUMENT", message, { details: details ?? { field } });
+}
+function requiredString$2(value, field) {
+	if (typeof value !== "string" || value.trim().length === 0) throw invalidArgument$1(`${field} must be a non-empty string`, field);
+	return value.trim();
+}
+function optionalString$1(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw invalidArgument$1(`${field} must be a string`, field);
+	return value;
+}
+function optionalTrimmedString(value, field) {
+	const string = optionalString$1(value, field)?.trim();
+	return string === "" ? void 0 : string;
+}
+function optionalRecord(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw invalidArgument$1(`${field} must be an object`, field);
+	return value;
+}
+function optionalBoolean(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "boolean") throw invalidArgument$1(`${field} must be a boolean`, field);
+	return value;
+}
+function positiveInteger$1(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) throw invalidArgument$1(`${field} must be a positive integer`, field);
+	return value;
+}
+function nonNegativeInteger$1(value, field) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw invalidArgument$1(`${field} must be a non-negative integer`, field);
+	return value;
+}
+function pagination$1(input) {
+	const page = positiveInteger$1(input.page, "page");
+	const pageSize = positiveInteger$1(input.pageSize, "pageSize");
+	return {
+		...page === void 0 ? {} : { page },
+		...pageSize === void 0 ? {} : { pageSize }
+	};
+}
+function stringList(value, field, options = {}) {
+	if (!Array.isArray(value)) throw invalidArgument$1(`${field} must be an array`, field);
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of value) {
+		if (typeof item !== "string") throw invalidArgument$1(`${field} must contain only strings`, field);
+		const normalized = item.trim();
+		if (normalized.length === 0 || seen.has(normalized)) continue;
+		seen.add(normalized);
+		result.push(normalized);
+	}
+	if (options.min !== void 0 && result.length < options.min) throw invalidArgument$1(`${field} must contain at least ${options.min} item(s)`, field);
+	if (options.max !== void 0 && result.length > options.max) throw invalidArgument$1(`${field} must contain at most ${options.max} item(s)`, field);
+	return result;
+}
+function httpUrl(value, field) {
+	const raw = requiredString$2(value, field);
+	let url;
+	try {
+		url = new URL(raw);
+	} catch (cause) {
+		throw invalidArgument$1(`${field} must be a valid HTTP(S) URL`, field, {
+			cause,
+			field
+		});
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:" || url.host.length === 0) throw invalidArgument$1(`${field} must be a valid HTTP(S) URL`, field);
+	url.hash = "";
+	return url.toString();
+}
+function compactUndefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+function assertNonEmptyPatch(patch, field) {
+	if (Object.keys(patch).length > 0) return;
+	throw invalidArgument$1(`${field} must contain at least one change`, field);
+}
+function queryPath(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.length === 0 ? path : `${path}?${suffix}`;
+}
+function wireRequest(options) {
+	const timeoutMs = options.callOptions?.timeoutMs;
+	if (timeoutMs !== void 0 && (!Number.isFinite(timeoutMs) || timeoutMs <= 0)) throw invalidArgument$1("timeoutMs must be a positive finite number", "timeoutMs");
+	return {
+		...options.body === void 0 ? {} : { body: {
+			kind: "json",
+			value: options.body
+		} },
+		destination: {
+			kind: "host",
+			path: options.path
+		},
+		idempotent: options.idempotent,
+		method: options.method,
+		...options.callOptions?.signal === void 0 ? {} : { signal: options.callOptions.signal },
+		...timeoutMs === void 0 ? {} : { timeoutMs }
+	};
+}
+function call(context, options) {
+	return executeUnary({
+		capability: options.capability,
+		operation: options.operation,
+		profile: context.profile,
+		request: wireRequest(options),
+		schema: options.schema,
+		transport: context.transport
+	});
+}
+//#endregion
+//#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"),
+		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")],
+		["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 createAgentOperations(context) {
+	const createChatSession = (notebookId, input, options) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		return call(context, {
+			body: chatSessionBody(input),
+			callOptions: options,
+			capability: "chat",
+			idempotent: false,
+			method: "POST",
+			operation: "chatSessions.create",
+			path: context.profile.apiPath("notebooks", notebook, "chat-sessions"),
+			schema: chatSessionSchema
+		});
+	};
+	const streamQuestion = (notebookId, sessionId, input, options) => {
+		const notebook = requiredString$2(notebookId, "notebookId");
+		const session = requiredString$2(sessionId, "sessionId");
+		return executeStream({
+			capability: "chat",
+			operation: "chat.stream",
+			profile: context.profile,
+			request: {
+				body: {
+					kind: "json",
+					value: streamBody(input)
+				},
+				destination: {
+					kind: "host",
+					path: queryPath(context.profile.apiPath("notebooks", notebook, "chat-sessions", session, "messages", "stream"), [["client", context.client]])
+				},
+				idempotent: false,
+				method: "POST",
+				...callOptions(options)
+			},
+			transport: context.transport
+		});
+	};
+	return {
+		async cancelQuestion(notebookId, sessionId, input = {}, options) {
+			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: "chat",
+				idempotent: false,
+				method: "POST",
+				operation: "chat.cancel",
+				path: context.profile.apiPath("notebooks", notebook, "chat-sessions", session, "messages", "cancel"),
+				schema: cancelQuestionResultSchema
+			});
+		},
+		createChatSession,
+		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) {
+			return call(context, {
+				callOptions: options,
+				capability: "taskRuns.read",
+				idempotent: true,
+				method: "GET",
+				operation: "taskRuns.list",
+				path: taskRunListPath(context, requiredString$2(notebookId, "notebookId"), input),
+				schema: taskRunListSchema
+			});
+		},
+		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
+			});
+		},
+		async startAgentRun(notebookId, input, options) {
+			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 createChatSession(notebook, {
+				...modelOverride === void 0 ? {} : { modelOverride },
+				sceneType: scene,
+				...title === void 0 ? {} : { title }
+			}, options);
+			return {
+				events: streamQuestion(notebook, session.id, agentContent(input), options),
+				scene,
+				session
+			};
+		},
+		streamQuestion
+	};
+}
+//#endregion
+//#region ../sdk/src/operations/cards.ts
+function createCardOperations(context) {
+	return {
+		async batchDeleteCards(notebookId, cardIds, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				body: { cardIds: stringList(cardIds, "cardIds", { min: 1 }) },
+				callOptions: options,
+				capability: "cards.write",
+				idempotent: false,
+				method: "POST",
+				operation: "cards.batchDelete",
+				path: context.profile.apiPath("notebooks", notebook, "cards", "batch-delete"),
+				schema: batchMutationResultSchema
+			});
+		},
+		async deleteCard(notebookId, cardId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const card = requiredString$2(cardId, "cardId");
+			return call(context, {
+				callOptions: options,
+				capability: "cards.write",
+				idempotent: false,
+				method: "DELETE",
+				operation: "cards.delete",
+				path: context.profile.apiPath("notebooks", notebook, "cards", card),
+				schema: batchMutationResultSchema
+			});
+		},
+		async getCard(notebookId, cardId, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const card = requiredString$2(cardId, "cardId");
+			return call(context, {
+				callOptions: options,
+				capability: "cards.read",
+				idempotent: true,
+				method: "GET",
+				operation: "cards.get",
+				path: context.profile.apiPath("notebooks", notebook, "cards", card),
+				schema: cardSchema
+			});
+		},
+		async listCards(notebookId, input = {}, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			const normalizedPage = pagination$1(input);
+			const category = optionalTrimmedString(input.category, "category");
+			const query = optionalTrimmedString(input.query, "query");
+			return call(context, {
+				callOptions: options,
+				capability: "cards.read",
+				idempotent: true,
+				method: "GET",
+				operation: "cards.list",
+				path: queryPath(context.profile.apiPath("notebooks", notebook, "cards"), [
+					["category", category],
+					["query", query],
+					["page", normalizedPage.page],
+					["page_size", normalizedPage.pageSize]
+				]),
+				schema: cardListSchema
+			});
+		}
+	};
+}
+//#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,
+					userId: context.userId.length === 0 ? void 0 : context.userId
+				}),
+				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 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 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 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 ? "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"),
+		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")
+	});
+}
+function sourcePatch(input) {
+	const patch = compactUndefined({
+		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");
+	return compactUndefined({
+		config: compactUndefined({
+			compileAfterRefresh: optionalBoolean(input?.compileAfterRefresh, "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 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");
+		return call(context, {
+			callOptions: options,
+			capability: "sources.read",
+			idempotent: true,
+			method: "GET",
+			operation,
+			path: queryPath(context.profile.apiPath("notebooks", notebook, "sources"), [
+				["view", view === "list" ? void 0 : view],
+				["parent_source_id", parentSourceId],
+				["page", normalizedPage.page],
+				["page_size", normalizedPage.pageSize],
+				["query", query]
+			]),
+			schema: sourceListSchema
+		});
+	};
+	const listSources = (notebookId, input, options) => readSourcePage(notebookId, input, options);
+	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");
+			return call(context, {
+				body: { sourceIds: stringList(sourceIds, "sourceIds", { min: 1 }) },
+				callOptions: options,
+				capability: "sources.write",
+				idempotent: false,
+				method: "POST",
+				operation: "sources.batchDelete",
+				path: context.profile.apiPath("notebooks", notebook, "sources", "batch-delete"),
+				schema: batchMutationResultSchema
+			});
+		},
+		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 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 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
+			});
+		},
+		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"),
+					urls
+				}),
+				callOptions: options,
+				capability: "sources.importWeb",
+				idempotent: false,
+				method: "POST",
+				operation: "sources.importWeb",
+				path: context.profile.apiPath("notebooks", notebook, "sources"),
+				schema: sourceImportResultsSchema
+			});
+		},
+		listAllSources,
+		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 presignImageUrls(notebookId, ossKeys, options) {
+			const notebook = requiredString$2(notebookId, "notebookId");
+			return call(context, {
+				body: { ossKeys: stringList(ossKeys, "ossKeys", {
+					max: 100,
+					min: 1
+				}) },
+				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) {
+	return {
+		body,
+		destination: {
+			kind: "host",
+			path
+		},
+		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: true,
+	"cards.read": true,
+	"cards.write": true,
+	chat: true,
+	"featuredNotebooks.read": true,
+	"images.presignUpload": false,
+	"images.presignUrls": false,
+	members: true,
+	"notebooks.filterByClient": false,
+	"notebooks.read": true,
+	"notebooks.write": true,
+	"notes.read": true,
+	"notes.write": true,
+	retrieval: true,
+	scheduledTasks: true,
+	"sources.children": true,
+	"sources.importWeb": true,
+	"sources.read": true,
+	"sources.search": true,
+	"sources.tree": 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,
+	"featuredNotebooks.read": true,
+	"images.presignUpload": true,
+	"images.presignUrls": true,
+	members: true,
+	"notebooks.filterByClient": true,
+	"notebooks.read": true,
+	"notebooks.write": true,
+	"notes.read": true,
+	"notes.write": true,
+	retrieval: true,
+	scheduledTasks: true,
+	"sources.children": false,
+	"sources.importWeb": false,
+	"sources.read": true,
+	"sources.search": false,
+	"sources.tree": 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);
+		},
+		listNotebooksPath(input) {
+			return appendQuery(`${apiPrefix}/notebooks`, [
+				["page", input.page],
+				["page_size", input.pageSize],
+				["client", input.client]
+			]);
+		},
+		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";
+}
+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,
+		userId: optionalTrimmedString(options.userId, "userId") ?? ""
+	};
+	return Object.freeze({
+		access: profile.access,
+		capabilities: profile.capabilities,
+		...createNotebookOperations(context),
+		...createCardOperations(context),
+		...createSourceOperations(context),
+		...createTransferOperations(context),
+		...createAgentOperations(context),
+		supports(capability) {
+			return profile.capabilities[capability] === true;
+		}
+	});
+}
+//#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 = "1.1.0";
+const QMIND_CLI_BUILD_TIME = "development";
+const QMIND_CLI_UPDATE_BASE_URL = typeof __QMIND_CLI_UPDATE_BASE_URL__ === "string" ? __QMIND_CLI_UPDATE_BASE_URL__ : "https://qoder-ide-cn.oss-cn-hangzhou.aliyuncs.com/qmind/cli/";
+function qmindCliPlatform() {
+	return process.platform === "win32" ? "windows" : process.platform;
+}
+function qmindCliArchitecture() {
+	return process.arch === "x64" ? "amd64" : process.arch;
+}
+//#endregion
+//#region 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 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/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.delete();
+			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 legacy = credentials.schemaVersion !== 2;
+		const refreshed = {
+			...credentials,
+			deviceToken: parsed.data.device_token,
+			expiresAt: parsed.data.expires_at,
+			refreshToken: parsed.data.refresh_token ?? credentials.refreshToken,
+			refreshTokenExpiresAt: parsed.data.refresh_token_expires_at ?? credentials.refreshTokenExpiresAt,
+			sashOrigin: options.config.sashOrigin,
+			schemaVersion: 2
+		};
+		await options.vault.save(refreshed, { migrateLegacy: legacy });
+		credentials = refreshed;
+		token = refreshed.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 '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 src/authenticated-transport.ts
+function withBearer(request, token) {
+	return {
+		...request,
+		headers: {
+			...request.headers,
+			authorization: `Bearer ${token}`
+		}
+	};
+}
+function createAuthenticatedQMindTransport(transport, auth) {
+	return Object.freeze({
+		async request(request) {
+			if (request.destination.kind === "signed") return await transport.request(request);
+			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 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 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(),
+	user_id: 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"
+	}
+});
+function invalidConfig(message, field) {
+	return new QMindError("INVALID_ARGUMENT", message, { ...field === void 0 ? {} : { details: { field } } });
+}
+function normalizeOrigin$1(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;
+}
+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) {
+	try {
+		return fileConfigSchema.parse(JSON.parse(await readFile(join(homeDirectory, "config.json"), "utf8")));
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		throw invalidConfig("stored QMind configuration is invalid");
+	}
+}
+function defaultProcessEnvironment() {
+	return process.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);
+	const flags = options.flags ?? {};
+	const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY === true;
+	const presetName = optionalTrimmed(environment.QMIND_ENV) ?? "prod";
+	const preset = PRESETS[presetName] ?? PRESETS.prod;
+	if (!(presetName in PRESETS)) options.reporter?.warn(`warning: unknown QMIND_ENV ${JSON.stringify(presetName)}, falling back to prod`);
+	const sashOrigin = normalizeOrigin$1(optionalTrimmed(flags.sash) ?? optionalTrimmed(environment.QMIND_SASH_URL) ?? optionalTrimmed(file.sash_url) ?? optionalTrimmed(options.credentialSashOrigin) ?? preset.sashOrigin, "sash");
+	const dashboardOrigin = normalizeOrigin$1(optionalTrimmed(flags.dashboard) ?? optionalTrimmed(environment.QMIND_DASHBOARD_URL) ?? optionalTrimmed(file.dashboard_url) ?? preset.dashboardOrigin, "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) ?? "",
+		userId: optionalTrimmed(flags.user) ?? optionalTrimmed(environment.QMIND_USER_ID) ?? optionalTrimmed(file.user_id) ?? ""
+	});
+	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 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`;
+}
+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 createOptionalKeyringSecretStore() {
+	const entry = async () => {
+		const { Entry } = await import("@napi-rs/keyring");
+		return new Entry("qmind-cli", "device-token");
+	};
+	return Object.freeze({
+		async delete() {
+			await optionalSecret(async () => void (await entry()).deletePassword(), void 0);
+		},
+		async get() {
+			return await optionalSecret(async () => (await entry()).getPassword() ?? void 0, void 0);
+		},
+		async set(token) {
+			await optionalSecret(async () => void (await entry()).setPassword(token), void 0);
+		}
+	});
+}
+function createFileCredentialVault(options) {
+	const credentialsPath = join(options.homeDirectory, "credentials.json");
+	const legacyBackupPath = `${credentialsPath}.v1.bak`;
+	const secretStore = options.secretStore ?? createOptionalKeyringSecretStore();
+	const now = options.now ?? Date.now;
+	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();
+		}
+	};
+	return Object.freeze({
+		async delete() {
+			await withLock(async () => {
+				await Promise.all([rm(credentialsPath, { force: true }), rm(legacyBackupPath, { force: true })]);
+				await optionalSecret(() => secretStore.delete(), void 0);
+			});
+		},
+		async load() {
+			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
+			};
+		},
+		async save(credentials, saveOptions = {}) {
+			await withLock(async () => {
+				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 });
+				}
+			});
+		}
+	});
+}
+//#endregion
+//#region 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");
+	const proxy = {
+		...httpProxy === void 0 ? {} : { httpProxy },
+		...httpsProxy === void 0 ? {} : { httpsProxy },
+		...noProxy === void 0 ? {} : { 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 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 = { ...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 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.homeDirectory === void 0 ? {} : { homeDirectory: options.homeDirectory },
+		...options.legacyEnvironmentPath === void 0 ? {} : { legacyEnvironmentPath: options.legacyEnvironmentPath },
+		...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 ?? createOptionalKeyringSecretStore()
+	});
+	const credentials = await vault.load();
+	const resolved = await loadQMindCliConfig({
+		...configurationOptions(options, reporter),
+		...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,
+		reporter,
+		transport: rawTransport,
+		vault
+	});
+	const client = createQMindClient({
+		access: "sash",
+		client: resolved.runtime.client,
+		transport: createAuthenticatedQMindTransport(rawTransport, auth),
+		userId: resolved.runtime.userId
+	});
+	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/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;
+	if (typeof value === "object") {
+		const source = record(value);
+		return {
+			nanos: numberValue(source.nanos),
+			seconds: numberValue(source.seconds)
+		};
+	}
+	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
+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 = optionalString(options, "dashboard");
+	const sash = optionalString(options, "sash");
+	const token = optionalString(options, "token");
+	const user = optionalString(options, "user");
+	return {
+		...client === void 0 ? {} : { client },
+		...dashboard === void 0 ? {} : { dashboard },
+		...options.nonInteractive === true ? { nonInteractive: true } : {},
+		...sash === void 0 ? {} : { sash },
+		...token === void 0 ? {} : { token },
+		...user === void 0 ? {} : { user }
+	};
+}
+async function hostFor(context, options, environmentOverrides = {}) {
+	if (context.host !== void 0) return context.host;
+	const environment = {
+		...context.hostOptions.environment ?? process.env,
+		...environmentOverrides
+	};
+	const adapters = {
+		...context.hostOptions.adapters,
+		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,
+		adapters,
+		environment,
+		flags: commonFlags(options),
+		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("--sash <url>", "Sash server origin").option("--dashboard <url>", "Dashboard origin").option("--org <id>", "organization ID (deprecated and ignored)").option("--user <id>", "user ID (direct-mind mode)").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 'qmind 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("--env <name>", "environment preset").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 environment = optionalString(raw, "env");
+		const host = await hostFor(context, raw, environment === void 0 ? {} : { QMIND_ENV: environment });
+		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"),
+			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(context, program) {
+	program.command("self-update").description("Show the supported qmind CLI upgrade path").option("--url <url>", "channel manifest or CLI base URL", QMIND_CLI_UPDATE_BASE_URL).addOption(new Option("--channel <channel>", "release channel").choices([
+		"stable",
+		"beta",
+		"daily"
+	]).default("stable")).option("--public-key <key>", "Ed25519 public key file, PEM, or base64").option("--check", "only check and verify the available update").option("--force", "reinstall the same version").option("--allow-downgrade", "explicitly allow installing an older signed version").action(async (raw) => {
+		if (context.selfUpdater === void 0) throw new QMindError("UNSUPPORTED_OPERATION", "self-update is unavailable for npm installs; run npm update --global @qoder-ai/qmind-cli");
+		const result = await context.selfUpdater.update({
+			allowDowngrade: raw.allowDowngrade === true,
+			baseUrl: String(raw.url),
+			channel: String(raw.channel),
+			check: raw.check === true,
+			currentVersion: QMIND_CLI_VERSION,
+			force: raw.force === true,
+			publicKey: String(raw.publicKey ?? "")
+		});
+		if (result.updated) context.io.stdout(`[self-update] updated ${QMIND_CLI_VERSION} -> ${result.version}\n`);
+		else if (result.version === "1.1.0".replace(/^v/, "")) context.io.stdout(`[self-update] already current: ${result.version}\n`);
+		else context.io.stdout(`[self-update] verified available version: ${result.version}\n`);
+	});
+}
+/** Internal parser adapter. Product consumers should call runQMindCli(). */
+function createQMindCliProgram(context) {
+	const program = new Command().name("qmind").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(`qmind ${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(context, 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,
+		...options.selfUpdater === void 0 ? {} : { selfUpdater: options.selfUpdater }
+	};
+	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 {};