@perrylink/dsh-ticktick 0.1.2

package/lib/index.js

@@ -0,0 +1,1349 @@
+import { n as TICKTICK_SETTINGS_NS } from "./wire-C-vDxxnC.js";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import z from "@deepseek-ai/schemastery";
+import { RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region src/config.ts
+/**
+* Plugin configuration and its explicit resolve step. `resolveConfig`
+* re-judges every default and bound so programmatic construction that
+* bypasses Schemastery normalization still fails loud instead of running
+* with hidden defaults (the explicit-resolve contract).
+*
+* @module dsh-ticktick/config
+*/
+/** Default TickTick MCP endpoint (CN region). */
+const DEFAULT_MCP_URL = "https://mcp.dida365.com";
+/** Default per-tools/call deadline in milliseconds. */
+const DEFAULT_TOOL_CALL_TIMEOUT_MS = 3e4;
+/** Ceiling for one tool call: the endpoint may block on a slow server round. */
+const MAX_TOOL_CALL_TIMEOUT_MS = 3e5;
+/** Schemastery schema for loader-validated configuration. */
+const Config = z.object({
+	tokenFile: z.string().default(""),
+	mcpUrl: z.string().default(DEFAULT_MCP_URL),
+	toolCallTimeoutMs: z.number().min(1e3).max(MAX_TOOL_CALL_TIMEOUT_MS).default(DEFAULT_TOOL_CALL_TIMEOUT_MS),
+	protectedTaskIds: z.array(z.string()).default([]),
+	tools: z.object({
+		projects: z.string().default(""),
+		tasks: z.string().default(""),
+		create: z.string().default(""),
+		complete: z.string().default(""),
+		remove: z.string().default(""),
+		update: z.string().default(""),
+		move: z.string().default(""),
+		completed: z.string().default(""),
+		search: z.string().default(""),
+		getTask: z.string().default(""),
+		batchAdd: z.string().default("")
+	}).default({
+		projects: "",
+		tasks: "",
+		create: "",
+		complete: "",
+		remove: "",
+		update: "",
+		move: "",
+		completed: "",
+		search: "",
+		getTask: "",
+		batchAdd: ""
+	})
+});
+/**
+* Resolve raw config to the runtime policy, re-validating defaults and bounds.
+* @param config - raw loader config; `undefined` for a bare row.
+* @returns the frozen resolved config.
+*/
+function resolveConfig(config) {
+	const tokenFile = config?.tokenFile ?? "";
+	if (typeof tokenFile !== "string") throw new TypeError("dsh-ticktick: config.tokenFile must be a string");
+	const mcpUrl = config?.mcpUrl ?? "https://mcp.dida365.com";
+	if (typeof mcpUrl !== "string" || mcpUrl === "") throw new Error("dsh-ticktick: config.mcpUrl must be a non-empty string");
+	const toolCallTimeoutMs = config?.toolCallTimeoutMs ?? 3e4;
+	if (!Number.isFinite(toolCallTimeoutMs) || toolCallTimeoutMs < 1e3 || toolCallTimeoutMs > 3e5) throw new Error(`dsh-ticktick: config.toolCallTimeoutMs must be a finite number between 1000 and ${MAX_TOOL_CALL_TIMEOUT_MS}`);
+	const protectedTaskIds = (config?.protectedTaskIds ?? []).filter((id) => typeof id === "string" && id !== "");
+	const rawTools = config?.tools;
+	const pin = (key) => {
+		const value = rawTools?.[key];
+		return typeof value === "string" ? value : "";
+	};
+	return Object.freeze({
+		tokenFile,
+		mcpUrl,
+		toolCallTimeoutMs,
+		protectedTaskIds: Object.freeze(protectedTaskIds),
+		tools: Object.freeze({
+			projects: pin("projects"),
+			tasks: pin("tasks"),
+			create: pin("create"),
+			complete: pin("complete"),
+			remove: pin("remove"),
+			update: pin("update"),
+			move: pin("move"),
+			completed: pin("completed"),
+			search: pin("search"),
+			getTask: pin("getTask"),
+			batchAdd: pin("batchAdd")
+		})
+	});
+}
+//#endregion
+//#region src/domain.ts
+const PROJECTS_PATTERN = /(list|get)[^a-z0-9]*(project|projects)|(project|projects)[^a-z0-9]*(list|get)/i;
+const TASKS_PATTERN = /(undone|open)[^a-z0-9]*(task|tasks)|project[^a-z0-9]*(with|undone)[^a-z0-9]*(task|tasks)/i;
+const CREATE_PATTERN = /^(create|add|insert|new)[^a-z0-9]*(task|todo)|^(task|todo)[^a-z0-9]*(create|add|insert|new)/i;
+const COMPLETE_PATTERN = /^(complete|finish|done|close|check)[^a-z0-9]*(task|todo)|^(task|todo)[^a-z0-9]*(complete|finish|done|close|check)/i;
+const REMOVE_PATTERN = /^(delete|remove)[^a-z0-9]*(task|todo)|^(task|todo)[^a-z0-9]*(delete|remove)/i;
+const UPDATE_PATTERN = /^update[^a-z0-9]*(task|todo)|^(task|todo)[^a-z0-9]*update/i;
+const MOVE_PATTERN = /^move[^a-z0-9]*(task|todo)|^(task|todo)[^a-z0-9]*move/i;
+const COMPLETED_PATTERN = /completed[^a-z0-9]*(task|tasks)|completed_by/i;
+const SEARCH_PATTERN = /^search(_task)?$/i;
+const GET_TASK_PATTERN = /get[^a-z0-9]*task[^a-z0-9]*by[^a-z0-9]*id|^fetch$/i;
+const BATCH_ADD_PATTERN = /batch[^a-z0-9]*add[^a-z0-9]*(task|tasks)/i;
+/**
+* Pick the raw tool names for the eleven operations, honoring pins.
+* A pin that is not advertised falls back to pattern discovery, then to
+* the first advertised tool, then to the pin itself (an empty resolver
+* surfaces as a failed call, never a silent no-op).
+* @param tools - the advertised tool list.
+* @param pins - config-level name pins.
+* @returns the resolved names.
+*/
+function resolveTools(tools, pins) {
+	const pick = (pattern, pin) => {
+		if (pin !== "" && tools.some((tool) => tool.name === pin)) return pin;
+		return tools.find((tool) => pattern.test(tool.name))?.name ?? (pin !== "" ? pin : tools[0]?.name) ?? "";
+	};
+	const searchPin = pins.search;
+	const exactSearch = tools.find((tool) => tool.name === "search");
+	const search = searchPin !== "" && tools.some((tool) => tool.name === searchPin) ? searchPin : exactSearch?.name ?? pick(SEARCH_PATTERN, searchPin);
+	return {
+		projects: pick(PROJECTS_PATTERN, pins.projects),
+		tasks: pick(TASKS_PATTERN, pins.tasks),
+		create: pick(CREATE_PATTERN, pins.create),
+		complete: pick(COMPLETE_PATTERN, pins.complete),
+		remove: pick(REMOVE_PATTERN, pins.remove),
+		update: pick(UPDATE_PATTERN, pins.update),
+		move: pick(MOVE_PATTERN, pins.move),
+		completed: pick(COMPLETED_PATTERN, pins.completed),
+		search,
+		getTask: pick(GET_TASK_PATTERN, pins.getTask),
+		batchAdd: pick(BATCH_ADD_PATTERN, pins.batchAdd)
+	};
+}
+const VALUE_KEY = /title|content|text|subject|name|desc/i;
+const ID_KEY = /(^|_)(id|uuid)$|taskId|task_id/i;
+const PROJECT_KEY = /projectId|project_id/i;
+/** Parse the project entries out of a `list_projects` result (object or array payloads). */
+function normalizeProjects(result) {
+	const projects = [];
+	const seen = /* @__PURE__ */ new Set();
+	const accept = (record) => {
+		const id = record.id;
+		const name = record.name;
+		if (typeof id === "string" && typeof name === "string" && !seen.has(id)) {
+			seen.add(id);
+			projects.push({
+				id,
+				name
+			});
+		}
+	};
+	for (const block of result.content ?? []) {
+		if (block.type !== "text" || block.text === void 0) continue;
+		try {
+			const parsed = JSON.parse(block.text);
+			if (Array.isArray(parsed)) {
+				for (const entry of parsed) if (entry !== null && typeof entry === "object") accept(entry);
+			} else if (parsed !== null && typeof parsed === "object") accept(parsed);
+		} catch {}
+	}
+	return projects;
+}
+/** Walk a value for arrays whose elements look like task objects. */
+function findTaskArrays(value, depth) {
+	if (depth > 8 || value === null || typeof value !== "object") return [];
+	if (Array.isArray(value)) {
+		const elements = value.filter((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+		if (elements.length > 0 && elements.every((item) => {
+			return Object.keys(item).some((key) => VALUE_KEY.test(key));
+		})) return [value];
+		return value.flatMap((item) => findTaskArrays(item, depth + 1));
+	}
+	return Object.values(value).flatMap((item) => findTaskArrays(item, depth + 1));
+}
+/** Read the task id, title, done flag, project, due date, and sort order from one task-like record. */
+function readTask(record) {
+	const keys = Object.keys(record);
+	const titleKey = keys.find((key) => VALUE_KEY.test(key) && typeof record[key] === "string");
+	const idKey = keys.find((key) => ID_KEY.test(key));
+	if (titleKey === void 0 || idKey === void 0) return null;
+	const idValue = record[idKey];
+	if (typeof idValue !== "string" && typeof idValue !== "number") return null;
+	const projectKey = keys.find((key) => PROJECT_KEY.test(key));
+	const projectValue = projectKey === void 0 ? void 0 : record[projectKey];
+	const dueKey = keys.find((key) => /dueDate|due_date|deadline/i.test(key));
+	const dueValue = dueKey === void 0 ? void 0 : record[dueKey];
+	const sortKey = keys.find((key) => /sortOrder|sort_order/i.test(key));
+	const sortValue = sortKey === void 0 ? void 0 : record[sortKey];
+	const status = record.status;
+	const done = status === 2 || status === "2" || status === "completed" || record.completed === true || record.done === true || record.finished === true;
+	return {
+		id: String(idValue),
+		title: record[titleKey],
+		done,
+		...typeof projectValue === "string" ? { projectId: projectValue } : {},
+		...typeof dueValue === "string" && dueValue !== "" ? { dueDate: dueValue } : {},
+		...typeof sortValue === "number" ? { sortOrder: sortValue } : {}
+	};
+}
+/** Normalize a tools/call result into the stable task view. */
+function normalizeTasks(result) {
+	const sources = [result.structuredContent];
+	for (const block of result.content ?? []) if (block.type === "text" && block.text !== void 0) try {
+		sources.push(JSON.parse(block.text));
+	} catch {
+		sources.push(block.text);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const tasks = [];
+	for (const source of sources) {
+		if (source !== null && typeof source === "object" && !Array.isArray(source)) {
+			const record = source;
+			if (Object.keys(record).some((key) => /status|projectId|project_id|dueDate|due_date|sortOrder|sort_order/i.test(key))) {
+				const direct = readTask(record);
+				if (direct !== null && !seen.has(direct.id)) {
+					seen.add(direct.id);
+					tasks.push(direct);
+				}
+			}
+		}
+		for (const array of findTaskArrays(source, 0)) for (const item of array) {
+			const task = readTask(item);
+			if (task !== null && !seen.has(task.id)) {
+				seen.add(task.id);
+				tasks.push(task);
+			}
+		}
+	}
+	return tasks;
+}
+/**
+* Whether a project id names the virtual inbox. Measured wire fact: inbox
+* ids carry the literal 'inbox' (either exactly or inside an internal id),
+* while regular projects are hex ids.
+* @param projectId - the project id.
+* @returns true for inbox ids.
+*/
+function isInboxProject(projectId) {
+	return projectId === "inbox" || projectId.includes("inbox");
+}
+//#endregion
+//#region src/mcp.ts
+/**
+* Parse one MCP response body: the last SSE `data:` payload, or plain JSON.
+* @param body - raw response text.
+* @returns the parsed message, or `undefined` for an empty body.
+*/
+function parseMcpMessage(body) {
+	if (body.trim() === "") return void 0;
+	const dataLines = body.split(/\r?\n/).filter((line) => line.startsWith("data:"));
+	if (dataLines.length > 0) {
+		const last = dataLines[dataLines.length - 1].slice(5).trim();
+		return JSON.parse(last);
+	}
+	return JSON.parse(body);
+}
+/**
+* Streamable-HTTP MCP client with Bearer auth. Requests are simple POSTs;
+* notifications tolerate empty responses. A 429 response is retried once
+* after the server's Retry-After delay (bounded to one minute).
+*/
+var McpStreamableClient = class {
+	url;
+	token;
+	timeoutMs;
+	fetchFn;
+	sessionId;
+	protocolVersion;
+	nextId = 1;
+	/**
+	* @param url - MCP server URL (e.g. https://mcp.dida365.com).
+	* @param token - Bearer token (the TickTick API 口令).
+	* @param timeoutMs - per-request deadline in milliseconds.
+	* @param fetchFn - fetch implementation (defaults to global fetch).
+	*/
+	constructor(url, token, timeoutMs, fetchFn = fetch) {
+		this.url = url;
+		this.token = token;
+		this.timeoutMs = timeoutMs;
+		this.fetchFn = fetchFn;
+	}
+	/** Perform the initialize handshake and send the initialized notification. */
+	async initialize() {
+		const response = await this.send({
+			jsonrpc: "2.0",
+			id: this.nextId++,
+			method: "initialize",
+			params: {
+				protocolVersion: "2025-03-26",
+				capabilities: {},
+				clientInfo: {
+					name: "dsh-ticktick",
+					version: "0.1.0"
+				}
+			}
+		}, false);
+		const body = await response.text();
+		if (response.status !== 200) throw new Error(`ticktick MCP initialize: HTTP ${response.status}: ${body.slice(0, 200)}`);
+		this.sessionId = response.headers.get("mcp-session-id") ?? void 0;
+		const message = parseMcpMessage(body);
+		this.protocolVersion = message?.result?.protocolVersion;
+		if (this.protocolVersion === void 0) throw new Error(`ticktick MCP initialize: unexpected response: ${body.slice(0, 200)}`);
+		await this.post({
+			jsonrpc: "2.0",
+			method: "notifications/initialized"
+		});
+	}
+	/** Fetch the server's tool list. */
+	async listTools() {
+		return (await this.post({
+			jsonrpc: "2.0",
+			id: this.nextId++,
+			method: "tools/list",
+			params: {}
+		}))?.result?.tools ?? [];
+	}
+	/**
+	* Invoke one tool. A tool-level failure (the MCP result flag `isError`)
+	* throws with the server's message — TickTick reports validation failures
+	* that way, not as JSON-RPC errors.
+	* @param name - the raw MCP tool name.
+	* @param args - the tool arguments object.
+	* @returns the settled result (text blocks or structured content).
+	*/
+	async callTool(name, args) {
+		const message = await this.post({
+			jsonrpc: "2.0",
+			id: this.nextId++,
+			method: "tools/call",
+			params: {
+				name,
+				arguments: args
+			}
+		});
+		if (message?.error !== void 0) throw new Error(`ticktick MCP tools/call ${name}: ${JSON.stringify(message.error)}`);
+		if (message?.result?.isError === true) {
+			const text = message.result.content?.filter((block) => block.type === "text" && block.text !== void 0).map((block) => block.text).join("\n");
+			throw new Error(`ticktick MCP tools/call ${name}: ${text ?? "unknown tool error"}`);
+		}
+		return message?.result ?? {};
+	}
+	/**
+	* Send one request and parse the response message: a 429 is retried once
+	* after Retry-After, any other non-2xx status throws, and an empty body
+	* (notification success) parses to `undefined`.
+	* @param request - JSON-RPC payload.
+	* @param carryHeaders - include session/protocol headers (false for initialize).
+	* @returns the parsed message, or `undefined` for an empty body.
+	*/
+	async post(request, carryHeaders = true) {
+		const response = await this.send(request, carryHeaders);
+		const body = await response.text();
+		if (response.status !== 200 && response.status !== 202) throw new Error(`ticktick MCP request failed: HTTP ${response.status}: ${body.slice(0, 200)}`);
+		return parseMcpMessage(body);
+	}
+	/**
+	* Send one request, retrying once after Retry-After when the server
+	* answers 429.
+	* @param request - JSON-RPC payload.
+	* @param carryHeaders - include session/protocol headers (false for initialize).
+	* @returns the raw response (body not yet read).
+	*/
+	async send(request, carryHeaders = true) {
+		const headers = {
+			"content-type": "application/json",
+			accept: "application/json, text/event-stream",
+			authorization: `Bearer ${this.token}`
+		};
+		if (carryHeaders) {
+			if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
+			if (this.protocolVersion !== void 0) headers["mcp-protocol-version"] = this.protocolVersion;
+		}
+		const signal = AbortSignal.timeout(this.timeoutMs);
+		const send = async () => await this.fetchFn(this.url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(request),
+			signal
+		});
+		let response = await send();
+		if (response.status === 429) {
+			await delay(parseRetryAfter(response.headers.get("retry-after")), signal);
+			response = await send();
+		}
+		return response;
+	}
+};
+/** Parse a Retry-After header (seconds or HTTP date), bounded to 60s. */
+function parseRetryAfter(value) {
+	if (value === null) return 1e3;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds)) return Math.min(Math.max(seconds * 1e3, 0), 6e4);
+	const epoch = Date.parse(value);
+	if (Number.isFinite(epoch)) return Math.min(Math.max(epoch - Date.now(), 0), 6e4);
+	return 1e3;
+}
+/** Abortable delay (bounded by the request timeout signal). */
+function delay(ms, signal) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/service.ts
+/** The epoch sentinel TickTick documents for clearing a due date. */
+const EPOCH_SENTINEL = "1970-01-01T00:00:00.000+0000";
+/** update_task server-side crash signature (Bug A): project tasks only. */
+const UPDATE_CRASH_SIGNATURE = /expecting value|line 1 column 1|char 0|json/i;
+/** Whether an error message names an auth failure. */
+const AUTH_SIGNATURE = /401|unauthor|invalid token|token/i;
+/** Project one normalized task into the wire shape (`null` for absent fields). */
+function toWireTask(task) {
+	return {
+		id: task.id,
+		title: task.title,
+		done: task.done,
+		projectId: task.projectId ?? null,
+		dueDate: task.dueDate ?? null,
+		sortOrder: task.sortOrder ?? null
+	};
+}
+/**
+* Host service for the TickTick bridge: status plus the seven task
+* operations, exported over the `ticktick` Remote namespace (hand-written
+* `./typert` manifest, no decorators).
+*/
+var TicktickService = class extends TypertRemoteService {
+	config;
+	createClient;
+	/** The MCP client, lazily bootstrapped per token. */
+	client;
+	/** Resolved tool names for the bootstrapped client. */
+	resolver;
+	/** Token the current client was built for. */
+	tokenAtBoot;
+	/** Most recent bridge error message; `null` when the last call settled. */
+	lastError = null;
+	/** Whether the current token has produced a boot error (avoid hot loops). */
+	bootFailed = false;
+	/**
+	* @param ctx - owning Cordis context.
+	* @param config - runtime policy (token getter, endpoint, timeout, guards, pins).
+	* @param createClient - test seam: client factory (defaults to the real MCP client).
+	*/
+	constructor(ctx, config, createClient = (url, token, timeoutMs) => new McpStreamableClient(url, token, timeoutMs)) {
+		super(ctx, "ticktick");
+		this.config = config;
+		this.createClient = createClient;
+	}
+	/** Connection and configuration facts (no handshake forced). */
+	status() {
+		const resolver = this.resolver;
+		return {
+			configured: this.config.getToken() !== null,
+			connected: this.client !== void 0,
+			mcpUrl: this.config.mcpUrl,
+			lastError: this.lastError,
+			toolNames: {
+				projects: resolver?.projects ?? "",
+				tasks: resolver?.tasks ?? "",
+				create: resolver?.create ?? "",
+				complete: resolver?.complete ?? "",
+				remove: resolver?.remove ?? "",
+				update: resolver?.update ?? "",
+				move: resolver?.move ?? ""
+			}
+		};
+	}
+	/** Drop the bootstrapped client so the next call re-reads the token. */
+	reset() {
+		this.client = void 0;
+		this.resolver = void 0;
+		this.tokenAtBoot = void 0;
+		this.bootFailed = false;
+	}
+	/**
+	* One-shot connectivity check over a throwaway client (the cached bridge
+	* client is untouched): initialize + tool listing against the current
+	* token. Feeds the settings card's "test connection" button.
+	*/
+	async probe() {
+		const token = this.config.getToken();
+		if (token === null) return {
+			ok: false,
+			toolCount: 0,
+			error: "no token configured"
+		};
+		const client = this.createClient(this.config.mcpUrl, token, this.config.toolCallTimeoutMs);
+		try {
+			await client.initialize();
+			return {
+				ok: true,
+				toolCount: (await client.listTools()).length,
+				error: null
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				toolCount: 0,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	/** List the user's projects (the virtual inbox included). */
+	async projects() {
+		const { client, resolver } = await this.ensure();
+		return { projects: normalizeProjects(await this.call(client, resolver.projects, {})) };
+	}
+	/**
+	* Aggregate undone tasks: one project when named, else every project.
+	* Projects whose response fails server-side validation are skipped and
+	* reported as warnings; each project's chunk stays sorted by descending
+	* sortOrder (the measured list order).
+	*/
+	async tasks(projectId) {
+		const { client, resolver } = await this.ensure();
+		const projects = normalizeProjects(await this.call(client, resolver.projects, {})).filter((project) => projectId === void 0 || projectId === "" || project.id === projectId);
+		const tasks = [];
+		const warnings = [];
+		for (const project of projects) try {
+			const chunk = normalizeTasks(await this.call(client, resolver.tasks, { project_id: project.id })).map((task) => toWireTask(task.projectId === void 0 ? {
+				...task,
+				projectId: project.id
+			} : task)).sort((a, b) => (b.sortOrder ?? 0) - (a.sortOrder ?? 0));
+			tasks.push(...chunk);
+		} catch (error) {
+			warnings.push(`${project.name}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return {
+			tasks,
+			warnings
+		};
+	}
+	/**
+	* Completed tasks within a window (P2): `list_completed_tasks_by_date`
+	* with a startDate `days` back (default 30) and an optional project.
+	*/
+	async completed(projectId, days = 30) {
+		const { client, resolver } = await this.ensure();
+		if (resolver.completed === "") throw new RemoteError("ticktick/tool-error", "the MCP endpoint does not advertise a completed-tasks tool", { tool: "completed" });
+		const search = { startDate: (/* @__PURE__ */ new Date(Date.now() - days * 864e5)).toISOString().slice(0, 10) };
+		if (projectId !== void 0 && projectId !== "") search.projectIds = [projectId];
+		return {
+			tasks: normalizeTasks(await this.call(client, resolver.completed, { search })).map(toWireTask),
+			warnings: []
+		};
+	}
+	/** Full-text search over TickTick tasks (P2): `search` / `search_task`. */
+	async search(query) {
+		const clean = query.trim();
+		if (clean === "") throw new RemoteError("ticktick/bad-request", "query required", { field: "query" });
+		const { client, resolver } = await this.ensure();
+		if (resolver.search === "") throw new RemoteError("ticktick/tool-error", "the MCP endpoint does not advertise a search tool", { tool: "search" });
+		return {
+			tasks: normalizeTasks(await this.call(client, resolver.search, { query: clean })).map(toWireTask),
+			warnings: []
+		};
+	}
+	/** Batch-create tasks (P2): `batch_add_tasks` over the OpenTask rows. */
+	async batchAdd(tasks) {
+		const rows = tasks.map((task) => ({
+			...task,
+			title: task.title.trim()
+		})).filter((task) => task.title !== "");
+		if (rows.length === 0) throw new RemoteError("ticktick/bad-request", "at least one non-empty title required", { field: "tasks" });
+		const { client, resolver } = await this.ensure();
+		if (resolver.batchAdd === "") throw new RemoteError("ticktick/tool-error", "the MCP endpoint does not advertise a batch-add tool", { tool: "batchAdd" });
+		await this.call(client, resolver.batchAdd, { tasks: rows.map((row) => ({
+			title: row.title,
+			...row.projectId !== void 0 && row.projectId !== "" ? { projectId: row.projectId } : {},
+			...row.dueDate !== void 0 && row.dueDate !== "" ? { dueDate: row.dueDate } : {}
+		})) });
+		return { created: rows.length };
+	}
+	/** Create one task; a named project places it there, otherwise the Inbox. */
+	async add(title, projectId, dueDate) {
+		const clean = title.trim();
+		if (clean === "") throw new RemoteError("ticktick/bad-request", "title required", { field: "title" });
+		const { client, resolver } = await this.ensure();
+		const task = { title: clean };
+		if (projectId !== void 0 && projectId !== "") task.projectId = projectId;
+		if (dueDate !== void 0 && dueDate !== "") task.dueDate = dueDate;
+		const created = normalizeTasks(await this.call(client, resolver.create, { task }))[0];
+		let verifyWarning = null;
+		if (created !== void 0 && resolver.getTask !== "") try {
+			const rows = normalizeTasks(await this.call(client, resolver.getTask, { task_id: created.id }));
+			if (rows.length === 0) verifyWarning = "readback returned no task";
+			else if (rows[0].title !== clean) verifyWarning = `readback title mismatch: ${rows[0].title}`;
+		} catch {
+			verifyWarning = "readback failed (verification skipped)";
+		}
+		return {
+			task: created === void 0 ? null : toWireTask(created),
+			verifyWarning
+		};
+	}
+	/** Mark one task complete (TickTick needs both the project and the task id). */
+	async complete(id, projectId) {
+		this.requireIds(id, projectId);
+		const { client, resolver } = await this.ensure();
+		await this.call(client, resolver.complete, {
+			project_id: projectId,
+			task_id: id
+		});
+		return { ok: true };
+	}
+	/** Delete one task (TickTick needs both the project and the task id). */
+	async remove(id, projectId) {
+		this.requireIds(id, projectId);
+		const { client, resolver } = await this.ensure();
+		await this.call(client, resolver.remove, {
+			project_id: projectId,
+			task_id: id
+		});
+		return { ok: true };
+	}
+	/**
+	* Set (or clear) one task's due date. Inbox tasks update directly.
+	* Project tasks try the direct update first and fall back to the measured
+	* move-to-inbox → update → move-back detour when the server answers with
+	* its update_task crash signature.
+	*/
+	async setDue(id, projectId, dueDate) {
+		if (id === "") throw new RemoteError("ticktick/bad-request", "id required", { field: "id" });
+		this.assertNotProtected(id);
+		const effective = dueDate !== void 0 && dueDate !== "" ? dueDate : EPOCH_SENTINEL;
+		const { client, resolver } = await this.ensure();
+		if (!(projectId !== void 0 && projectId !== "" && !isInboxProject(projectId))) {
+			await this.call(client, resolver.update, {
+				task_id: id,
+				task: { dueDate: effective }
+			});
+			return { ok: true };
+		}
+		try {
+			await this.call(client, resolver.update, {
+				task_id: id,
+				task: { dueDate: effective }
+			});
+		} catch (error) {
+			if (!UPDATE_CRASH_SIGNATURE.test(error instanceof Error ? error.message : String(error))) throw error;
+			await this.call(client, resolver.move, { moves: [{
+				fromProjectId: projectId,
+				toProjectId: "inbox",
+				taskId: id
+			}] });
+			try {
+				await this.call(client, resolver.update, {
+					task_id: id,
+					task: { dueDate: effective }
+				});
+			} finally {
+				await this.call(client, resolver.move, { moves: [{
+					fromProjectId: "inbox",
+					toProjectId: projectId,
+					taskId: id
+				}] });
+			}
+		}
+		return { ok: true };
+	}
+	/**
+	* Move one task to a new position: inbox tasks take update_task with the
+	* new sortOrder; project tasks take a same-project move carrying the new
+	* sortOrder (the list order is descending sortOrder).
+	*/
+	async reorder(id, projectId, sortOrder) {
+		if (id === "") throw new RemoteError("ticktick/bad-request", "id required", { field: "id" });
+		if (!Number.isFinite(sortOrder) || !Number.isInteger(sortOrder)) throw new RemoteError("ticktick/bad-request", "sortOrder must be an integer", { field: "sortOrder" });
+		this.assertNotProtected(id);
+		const { client, resolver } = await this.ensure();
+		if (projectId !== void 0 && projectId !== "" && !isInboxProject(projectId)) await this.call(client, resolver.move, { moves: [{
+			fromProjectId: projectId,
+			toProjectId: projectId,
+			taskId: id,
+			sortOrder
+		}] });
+		else await this.call(client, resolver.update, {
+			task_id: id,
+			task: { sortOrder }
+		});
+		return { ok: true };
+	}
+	/** Reject a mutating operation naming an id on the protected list. */
+	assertNotProtected(id) {
+		if (this.config.protectedTaskIds.includes(id)) throw new RemoteError("ticktick/protected", `task ${id} is protected`, { taskId: id });
+	}
+	/** Validate the id pair required by complete/delete. */
+	requireIds(id, projectId) {
+		if (id === "") throw new RemoteError("ticktick/bad-request", "id required", { field: "id" });
+		if (projectId === "") throw new RemoteError("ticktick/bad-request", "projectId required", { field: "projectId" });
+		this.assertNotProtected(id);
+	}
+	/**
+	* Lazily bootstrap the MCP client and tool resolver for the active token.
+	* A token change or a 401-triggered reset rebuilds the client.
+	*/
+	async ensure() {
+		const token = this.config.getToken();
+		if (token === null) throw new RemoteError("ticktick/no-token", "no token: set it in the TickTick settings card or write the API 口令 to the token file", {});
+		if (this.client === void 0 || this.tokenAtBoot !== token || this.bootFailed) {
+			this.client = void 0;
+			this.resolver = void 0;
+			this.tokenAtBoot = void 0;
+			this.bootFailed = false;
+			const client = this.createClient(this.config.mcpUrl, token, this.config.toolCallTimeoutMs);
+			try {
+				await client.initialize();
+				const tools = await client.listTools();
+				this.resolver = resolveTools(tools, this.config.pins);
+				this.client = client;
+				this.tokenAtBoot = token;
+				this.lastError = null;
+			} catch (error) {
+				this.bootFailed = true;
+				this.lastError = error instanceof Error ? error.message : String(error);
+				throw new RemoteError("ticktick/tool-error", this.lastError, { tool: "initialize" }, { cause: error });
+			}
+		}
+		return {
+			client: this.client,
+			resolver: this.resolver
+		};
+	}
+	/**
+	* One tools/call with error mapping: tool-level failures carry their raw
+	* tool name; a 401 signature resets the client once so the next call
+	* re-reads the token file.
+	*/
+	async call(client, tool, args) {
+		try {
+			this.lastError = null;
+			return await client.callTool(tool, args);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.lastError = message;
+			if (AUTH_SIGNATURE.test(message)) this.reset();
+			throw new RemoteError("ticktick/tool-error", message, { tool }, { cause: error });
+		}
+	}
+};
+//#endregion
+//#region src/tools.ts
+/**
+* The curated model-facing tools of the TickTick bridge. All eight reuse the
+* host service's business methods, so the model and the widget share one
+* policy (protected ids, workarounds, error codes). Each `output.schema`
+* returns a structured JSON value — the Code Mode `await tools.ticktick_*`
+* surface derives from it — while `output.render` carries the human text.
+*
+* @module dsh-ticktick/tools
+*/
+/** Task wire projection shared by the add/tasks tools. */
+function taskWire(task) {
+	const due = task.dueDate === null ? "no due date" : task.dueDate;
+	return `${task.title} [${task.projectId ?? "?"}] due ${due}`;
+}
+/** Value schema of one task wire row. */
+const TASK_ROW_SCHEMA = {
+	type: "object",
+	properties: {
+		id: {
+			type: "string",
+			required: true
+		},
+		title: {
+			type: "string",
+			required: true
+		},
+		done: {
+			type: "boolean",
+			required: true
+		},
+		projectId: {
+			oneOf: [{ type: "string" }, { type: "null" }],
+			required: true
+		},
+		dueDate: {
+			oneOf: [{ type: "string" }, { type: "null" }],
+			required: true
+		},
+		sortOrder: {
+			oneOf: [{ type: "number" }, { type: "null" }],
+			required: true
+		}
+	},
+	additionalProperties: false
+};
+/** Value schema of an `{ ok: boolean }` mutation result. */
+const OK_RESULT_SCHEMA = {
+	type: "object",
+	properties: { ok: {
+		type: "boolean",
+		required: true
+	} },
+	additionalProperties: false
+};
+/**
+* Build the eight tools bound to one service instance.
+* @param service - the mounted TickTick service.
+* @returns the registered tool definitions.
+*/
+function buildTicktickTools(service) {
+	return [
+		defineTool({
+			name: "ticktick_status",
+			description: "Read the TickTick (Dida365) bridge connection state: token configured, client connected, endpoint, and last error.",
+			parameters: {},
+			output: {
+				schema: {
+					type: "object",
+					properties: {
+						configured: {
+							type: "boolean",
+							required: true
+						},
+						connected: {
+							type: "boolean",
+							required: true
+						},
+						mcpUrl: {
+							type: "string",
+							required: true
+						},
+						lastError: {
+							oneOf: [{ type: "string" }, { type: "null" }],
+							required: true
+						}
+					},
+					additionalProperties: false
+				},
+				render: (_args, value) => {
+					const status = value;
+					const line = status.configured ? status.connected ? `connected to ${status.mcpUrl}` : "configured but not connected" : "not configured (no token)";
+					return [{
+						type: "text",
+						text: status.lastError === null ? `TickTick bridge: ${line}` : `TickTick bridge: ${line}; last error: ${status.lastError}`
+					}];
+				}
+			},
+			async execute() {
+				const status = service.status();
+				return {
+					configured: status.configured,
+					connected: status.connected,
+					mcpUrl: status.mcpUrl,
+					lastError: status.lastError
+				};
+			}
+		}),
+		defineTool({
+			name: "ticktick_lists",
+			description: "List every TickTick list (project), including the virtual Inbox.",
+			parameters: {},
+			output: {
+				schema: {
+					type: "object",
+					properties: { projects: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							properties: {
+								id: {
+									type: "string",
+									required: true
+								},
+								name: {
+									type: "string",
+									required: true
+								}
+							},
+							additionalProperties: false
+						}
+					} },
+					additionalProperties: false
+				},
+				render: (_args, value) => {
+					const { projects } = value;
+					return [{
+						type: "text",
+						text: projects.length === 0 ? "no lists" : projects.map((p) => `${p.name} (${p.id})`).join("\n")
+					}];
+				}
+			},
+			async execute() {
+				return { projects: [...(await service.projects()).projects] };
+			}
+		}),
+		defineTool({
+			name: "ticktick_tasks",
+			description: "List undone TickTick tasks: one named list, or every list aggregated with per-list warnings for lists the server could not read.",
+			parameters: { projectId: {
+				type: "string",
+				description: "Optional list id (omit for every list)"
+			} },
+			output: {
+				schema: {
+					type: "object",
+					properties: {
+						tasks: {
+							type: "array",
+							required: true,
+							items: TASK_ROW_SCHEMA
+						},
+						warnings: {
+							type: "array",
+							required: true,
+							items: { type: "string" }
+						}
+					},
+					additionalProperties: false
+				},
+				render: (_args, value) => {
+					const { tasks, warnings } = value;
+					const lines = tasks.length === 0 ? ["no undone tasks"] : tasks.map(taskWire);
+					if (warnings.length > 0) lines.push(...warnings.map((w) => `warning: ${w}`));
+					return [{
+						type: "text",
+						text: lines.join("\n")
+					}];
+				}
+			},
+			async execute(args) {
+				const result = await service.tasks(args.projectId);
+				return {
+					tasks: [...result.tasks],
+					warnings: [...result.warnings]
+				};
+			}
+		}),
+		defineTool({
+			name: "ticktick_add",
+			description: "Create one TickTick task: a named list places it there, otherwise the Inbox.",
+			parameters: {
+				title: {
+					type: "string",
+					required: true,
+					description: "Task title"
+				},
+				projectId: {
+					type: "string",
+					description: "Optional list id (default Inbox)"
+				},
+				dueDate: {
+					type: "string",
+					description: "Optional ISO due date (e.g. 2026-09-05 or a full ISO date-time)"
+				}
+			},
+			output: {
+				schema: {
+					type: "object",
+					properties: {
+						task: {
+							oneOf: [TASK_ROW_SCHEMA, { type: "null" }],
+							required: true
+						},
+						verifyWarning: {
+							oneOf: [{ type: "string" }, { type: "null" }],
+							required: true
+						}
+					},
+					additionalProperties: false
+				},
+				render: (_args, value) => {
+					const { task, verifyWarning } = value;
+					const line = task === null ? "task created (server returned no echo)" : `created: ${taskWire(task)}`;
+					return [{
+						type: "text",
+						text: verifyWarning === null ? line : `${line}; verification warning: ${verifyWarning}`
+					}];
+				}
+			},
+			async execute(args) {
+				return service.add(args.title, args.projectId, args.dueDate);
+			}
+		}),
+		defineTool({
+			name: "ticktick_complete",
+			description: "Mark one TickTick task complete (both the task id and its list id are required).",
+			parameters: {
+				id: {
+					type: "string",
+					required: true,
+					description: "Task id"
+				},
+				projectId: {
+					type: "string",
+					required: true,
+					description: "Owning list id"
+				}
+			},
+			output: {
+				schema: OK_RESULT_SCHEMA,
+				render: (_args, value) => {
+					const { ok } = value;
+					return [{
+						type: "text",
+						text: ok ? "task completed" : "completion rejected"
+					}];
+				}
+			},
+			async execute(args) {
+				return service.complete(args.id, args.projectId);
+			}
+		}),
+		defineTool({
+			name: "ticktick_delete",
+			description: "Delete one TickTick task (both the task id and its list id are required).",
+			parameters: {
+				id: {
+					type: "string",
+					required: true,
+					description: "Task id"
+				},
+				projectId: {
+					type: "string",
+					required: true,
+					description: "Owning list id"
+				}
+			},
+			output: {
+				schema: OK_RESULT_SCHEMA,
+				render: (_args, value) => {
+					const { ok } = value;
+					return [{
+						type: "text",
+						text: ok ? "task deleted" : "delete rejected"
+					}];
+				}
+			},
+			async execute(args) {
+				return service.remove(args.id, args.projectId);
+			}
+		}),
+		defineTool({
+			name: "ticktick_due",
+			description: "Set or clear one TickTick task due date. Omit dueDate to clear. Project tasks fall back to a move-to-inbox detour when the server rejects the direct update.",
+			parameters: {
+				id: {
+					type: "string",
+					required: true,
+					description: "Task id"
+				},
+				projectId: {
+					type: "string",
+					description: "Owning list id (required for project tasks)"
+				},
+				dueDate: {
+					type: "string",
+					description: "ISO due date; omit to clear"
+				}
+			},
+			output: {
+				schema: OK_RESULT_SCHEMA,
+				render: (_args, value) => {
+					const { ok } = value;
+					return [{
+						type: "text",
+						text: ok ? "due date applied" : "due date rejected"
+					}];
+				}
+			},
+			async execute(args) {
+				return service.setDue(args.id, args.projectId, args.dueDate);
+			}
+		}),
+		defineTool({
+			name: "ticktick_reorder",
+			description: "Move one TickTick task to a new sortOrder (lists order by descending sortOrder; compute the target from the neighboring task).",
+			parameters: {
+				id: {
+					type: "string",
+					required: true,
+					description: "Task id"
+				},
+				projectId: {
+					type: "string",
+					description: "Owning list id (inbox tasks omit it)"
+				},
+				sortOrder: {
+					type: "integer",
+					required: true,
+					description: "Integer sortOrder to assign"
+				}
+			},
+			output: {
+				schema: OK_RESULT_SCHEMA,
+				render: (_args, value) => {
+					const { ok } = value;
+					return [{
+						type: "text",
+						text: ok ? "task reordered" : "reorder rejected"
+					}];
+				}
+			},
+			async execute(args) {
+				return service.reorder(args.id, args.projectId, args.sortOrder);
+			}
+		}),
+		defineTool({
+			name: "ticktick_completed",
+			description: "List TickTick tasks completed within a window (default the last 30 days), optionally narrowed to one list.",
+			parameters: {
+				projectId: {
+					type: "string",
+					description: "Optional list id (omit for every list)"
+				},
+				days: {
+					type: "integer",
+					description: "Window length in days (default 30)"
+				}
+			},
+			output: {
+				schema: {
+					type: "object",
+					properties: {
+						tasks: {
+							type: "array",
+							required: true,
+							items: TASK_ROW_SCHEMA
+						},
+						warnings: {
+							type: "array",
+							required: true,
+							items: { type: "string" }
+						}
+					},
+					additionalProperties: false
+				},
+				render: (_args, value) => {
+					const { tasks, warnings } = value;
+					const lines = tasks.length === 0 ? ["no completed tasks in the window"] : tasks.map(taskWire);
+					if (warnings.length > 0) lines.push(...warnings.map((w) => `warning: ${w}`));
+					return [{
+						type: "text",
+						text: lines.join("\n")
+					}];
+				}
+			},
+			async execute(args) {
+				const result = await service.completed(args.projectId, args.days);
+				return {
+					tasks: [...result.tasks],
+					warnings: [...result.warnings]
+				};
+			}
+		}),
+		defineTool({
+			name: "ticktick_search",
+			description: "Full-text search over TickTick tasks (the official search / search_task tool).",
+			parameters: { query: {
+				type: "string",
+				required: true,
+				description: "Search keyword"
+			} },
+			output: {
+				schema: {
+					type: "object",
+					properties: {
+						tasks: {
+							type: "array",
+							required: true,
+							items: TASK_ROW_SCHEMA
+						},
+						warnings: {
+							type: "array",
+							required: true,
+							items: { type: "string" }
+						}
+					},
+					additionalProperties: false
+				},
+				render: (_args, value) => {
+					const { tasks } = value;
+					return [{
+						type: "text",
+						text: (tasks.length === 0 ? ["no matches"] : tasks.map(taskWire)).join("\n")
+					}];
+				}
+			},
+			async execute(args) {
+				const result = await service.search(args.query);
+				return {
+					tasks: [...result.tasks],
+					warnings: [...result.warnings]
+				};
+			}
+		}),
+		defineTool({
+			name: "ticktick_batch_add",
+			description: "Create several TickTick tasks in one call (batch_add_tasks); rows carry title plus optional list id and ISO due date.",
+			parameters: { tasks: {
+				type: "array",
+				required: true,
+				description: "Task rows to create",
+				items: {
+					type: "object",
+					properties: {
+						title: {
+							type: "string",
+							required: true
+						},
+						projectId: { type: "string" },
+						dueDate: { type: "string" }
+					},
+					additionalProperties: false
+				}
+			} },
+			output: {
+				schema: {
+					type: "object",
+					properties: { created: {
+						type: "integer",
+						required: true
+					} },
+					additionalProperties: false
+				},
+				render: (_args, value) => {
+					const { created } = value;
+					return [{
+						type: "text",
+						text: `created ${created} task${created === 1 ? "" : "s"}`
+					}];
+				}
+			},
+			async execute(args) {
+				return service.batchAdd(args.tasks);
+			}
+		})
+	];
+}
+//#endregion
+//#region src/index.ts
+/**
+* `dsh-ticktick` — the TickTick (Dida365) task bridge for DeepSeek Harness.
+*
+* Host half: mounts the `ticktick` Remote service (status plus the seven
+* task operations over the official TickTick MCP endpoint), registers the
+* eight curated `ticktick_*` tools on the shared service, installs the
+* `ticktick` settings namespace (token / token file / endpoint / protected
+* ids) that the browser settings card edits, and announces the tool set in
+* one system-prompt section.
+*
+* The token is re-read per request: the settings card's secret field wins,
+* then the token file (`$DSH_HOME/.ticktick-token` by default). Writing the
+* file activates the bridge without a config change.
+*
+* Function plugin — no default export (the Loader unwraps
+* `exports.default ?? exports`).
+*
+* @module dsh-ticktick
+*/
+const name = "ticktick";
+/** Hard services: the tool registry and the prompt assembly. `settings` is an optional child. */
+const inject = ["tools", "systemPrompt"];
+/** Settings namespace the browser card edits (paired by this exact key). */
+const SETTINGS_NS = TICKTICK_SETTINGS_NS;
+/** Schemastery schema for the settings namespace (the card renders this). */
+const TicktickSettingsSchema = z.object({
+	token: z.string().role("secret").default(""),
+	tokenFile: z.string().default(""),
+	mcpUrl: z.string().default(DEFAULT_MCP_URL),
+	protectedTaskIds: z.array(z.string()).default([])
+});
+/** Default token file: `<DSH_HOME>/.ticktick-token` (or `~/.dsh/.ticktick-token`). */
+function defaultTokenFile() {
+	return join(process.env.DSH_HOME ?? join(homedir(), ".dsh"), ".ticktick-token");
+}
+/**
+* Resolve the current Bearer token: the settings card's secret wins, then
+* the DIDA365_TOKEN environment variable, then the configured token file.
+* @param settings - current settings layer.
+* @param resolved - loader config.
+* @returns the token, or `null` when unconfigured.
+*/
+function resolveToken(settings, resolved) {
+	if (settings.token !== "") return settings.token;
+	const env = process.env.DIDA365_TOKEN;
+	if (env !== void 0 && env.trim() !== "") return env.trim();
+	const file = settings.tokenFile !== "" ? settings.tokenFile : resolved.tokenFile !== "" ? resolved.tokenFile : defaultTokenFile();
+	if (!existsSync(file)) return null;
+	const token = readFileSync(file, "utf8").trim();
+	return token === "" ? null : token;
+}
+/**
+* Mount the bridge: the settings namespace, the Remote service, the eight
+* tools, and the usage announcement.
+*
+* @param ctx - context carrying tools + systemPrompt.
+* @param config - raw loader config; defaults applied through {@link resolveConfig}.
+*/
+async function apply(ctx, config) {
+	const resolved = resolveConfig(config);
+	let settingsSource = () => ({
+		token: "",
+		tokenFile: resolved.tokenFile,
+		mcpUrl: resolved.mcpUrl,
+		protectedTaskIds: [...resolved.protectedTaskIds]
+	});
+	let service;
+	ctx.inject(["settings"], (scope) => {
+		scope.settings.installSection(ctx, SETTINGS_NS, TicktickSettingsSchema, {
+			token: "",
+			tokenFile: resolved.tokenFile,
+			mcpUrl: resolved.mcpUrl,
+			protectedTaskIds: [...resolved.protectedTaskIds]
+		}, {
+			validate: (value) => {
+				if (value.mcpUrl.trim() === "") throw new Error("dsh-ticktick: mcpUrl must not be empty");
+			},
+			setSource: (source) => {
+				settingsSource = source;
+			},
+			onChange: () => {
+				service?.reset();
+			}
+		});
+	});
+	const serviceConfig = {
+		getToken: () => resolveToken(settingsSource(), resolved),
+		mcpUrl: resolved.mcpUrl,
+		toolCallTimeoutMs: resolved.toolCallTimeoutMs,
+		protectedTaskIds: resolved.protectedTaskIds,
+		pins: resolved.tools
+	};
+	await ctx.plugin(TicktickService, serviceConfig);
+	service = ctx.get("ticktick");
+	for (const tool of buildTicktickTools(service)) ctx.effect(() => ctx.tools.register(tool), `dsh-ticktick: ${tool.name} tool`);
+	ctx.effect(() => ctx.systemPrompt.section({
+		name: "ticktick:usage",
+		order: 350,
+		text: "TickTick (Dida365) tasks are available through the ticktick_* tools: ticktick_status, ticktick_lists, ticktick_tasks, ticktick_add, ticktick_complete, ticktick_delete, ticktick_due, ticktick_reorder, ticktick_completed, ticktick_search, ticktick_batch_add. The Session header also shows a TickTick panel for browsing lists (undone/completed views, full-text search), adding, completing, deleting, setting due dates, and drag reordering."
+	}), "dsh-ticktick: system prompt section");
+}
+//#endregion
+export { Config, DEFAULT_MCP_URL, DEFAULT_TOOL_CALL_TIMEOUT_MS, McpStreamableClient, SETTINGS_NS, TicktickService, TicktickSettingsSchema, apply, buildTicktickTools, inject, isInboxProject, name, normalizeProjects, normalizeTasks, parseMcpMessage, resolveConfig, resolveToken, resolveTools };