dsh-tiddlywiki 0.4.0 → 0.5.0

package/lib/index.js

@@ -275,6 +275,47 @@ var GitFace = class {
 			message: (r.stderr.trim() || r.stdout.trim()).slice(0, 500)
 		};
 	}
+	/** `git fetch` (no remote configured → failure reported by the caller). */
+	async fetch(dir) {
+		const r = await this.exec(["fetch"], {
+			cwd: dir,
+			timeout: HEAVY_TIMEOUT_MS
+		});
+		return r.ok ? {
+			ok: true,
+			message: r.stdout.trim() || "fetch ok"
+		} : {
+			ok: false,
+			message: (r.stderr.trim() || r.stdout.trim()).slice(0, 500)
+		};
+	}
+	/**
+	* Restore the given files from the freshly fetched remote HEAD (FETCH_HEAD)
+	* into the working tree + index — the "keep remote version" half of
+	* tiddler-granular conflict resolution. Callers must `git fetch` first.
+	*/
+	async checkoutFetchHead(dir, files) {
+		if (files.length === 0) return {
+			ok: true,
+			message: "no files given"
+		};
+		const r = await this.exec([
+			"checkout",
+			"FETCH_HEAD",
+			"--",
+			...files
+		], {
+			cwd: dir,
+			timeout: HEAVY_TIMEOUT_MS
+		});
+		return r.ok ? {
+			ok: true,
+			message: `已从远端检出 ${files.length} 个文件`
+		} : {
+			ok: false,
+			message: (r.stderr.trim() || r.stdout.trim()).slice(0, 500)
+		};
+	}
 	/** Ensure `origin` points at `url` (add or set-url). */
 	async ensureRemote(dir, url) {
 		const cur = await this.exec([
@@ -701,6 +742,11 @@ function json$1(res, payload, status = 200) {
 function pad(n) {
 	return n < 10 ? `0${n}` : String(n);
 }
+/** Flat one-line snippet for the recent-notes picker. */
+function snippetOf$1(text, max = 120) {
+	const flat = text.replace(/\s+/g, " ").trim();
+	return flat.length <= max ? flat : `${flat.slice(0, max)}…`;
+}
 /** Default note title: `YYYY-MM-DD HH:mm` (design doc D6). */
 function timestampTitle(date = /* @__PURE__ */ new Date()) {
 	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
@@ -867,6 +913,85 @@ function registerRoutes(ctx, deps) {
 			}, 500);
 		}
 	};
+	/** Recent non-system tiddlers for the quick-note "最近" picker (newest first). */
+	const handleRecent = async (req, res) => {
+		const client = deps.getClient();
+		if (client === void 0) {
+			json$1(res, {
+				ok: false,
+				error: "wiki service is not running"
+			}, 503);
+			return;
+		}
+		try {
+			const url = new URL(req.url ?? "/", "http://127.0.0.1");
+			const limitRaw = Number(url.searchParams.get("limit") ?? 15);
+			const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(Math.floor(limitRaw), 200)) : 15;
+			json$1(res, {
+				ok: true,
+				limit,
+				items: (await client.recent(limit)).map((t) => ({
+					title: t.title,
+					tags: t.tags ?? [],
+					modified: typeof t.modified === "string" ? t.modified : null,
+					snippet: snippetOf$1(t.text ?? "")
+				}))
+			});
+		} catch (err) {
+			json$1(res, {
+				ok: false,
+				error: err instanceof Error ? err.message : String(err)
+			}, 500);
+		}
+	};
+	/** Full tiddler for the quick-note "最近" picker (load into the editor). */
+	const handleGet = async (req, res) => {
+		const client = deps.getClient();
+		if (client === void 0) {
+			json$1(res, {
+				ok: false,
+				error: "wiki service is not running"
+			}, 503);
+			return;
+		}
+		try {
+			const title = new URL(req.url ?? "/", "http://127.0.0.1").searchParams.get("title") ?? "";
+			if (title.length === 0) {
+				json$1(res, {
+					ok: false,
+					error: "missing title"
+				}, 400);
+				return;
+			}
+			const t = await client.get(title);
+			if (t === void 0) {
+				json$1(res, {
+					ok: false,
+					notFound: true,
+					title
+				}, 404);
+				return;
+			}
+			const fields = {};
+			for (const [k, v] of Object.entries(t)) {
+				if (k === "title" || k === "text" || k === "tags") continue;
+				fields[k] = v;
+			}
+			json$1(res, {
+				ok: true,
+				title: t.title,
+				text: t.text ?? "",
+				tags: t.tags ?? [],
+				type: t.type ?? "text/vnd.tiddlywiki",
+				fields
+			});
+		} catch (err) {
+			json$1(res, {
+				ok: false,
+				error: err instanceof Error ? err.message : String(err)
+			}, 500);
+		}
+	};
 	const handleRestart = async (_req, res) => {
 		try {
 			await deps.server.restart();
@@ -1061,6 +1186,20 @@ function registerRoutes(ctx, deps) {
 				handleTags(req, res);
 			}
 		}),
+		ctx.webServer.register({
+			kind: "exact",
+			path: `${ROUTE_PREFIX}/recent`,
+			handler: (req, res) => {
+				handleRecent(req, res);
+			}
+		}),
+		ctx.webServer.register({
+			kind: "exact",
+			path: `${ROUTE_PREFIX}/get`,
+			handler: (req, res) => {
+				handleGet(req, res);
+			}
+		}),
 		ctx.webServer.register({
 			kind: "exact",
 			path: `${ROUTE_PREFIX}/sync`,
@@ -1542,17 +1681,19 @@ const DOC_NOTE_TEXT = `! dsh-tiddlywiki 插件说明
 
 !! 它能做什么
 
-* **5 个 agent 工具**：\`tiddlywiki_search\`（检索）/ \`tiddlywiki_get\`（读）/ \`tiddlywiki_put\`（写）/ \`tiddlywiki_delete\`（删）/ \`tiddlywiki_git_sync\`（git 同步）。
+* **10 个 agent 工具**：\`tiddlywiki_search\`（检索，支持 tags/since/type/limit 过滤）/ \`tiddlywiki_get\`（读）/ \`tiddlywiki_put\`（写）/ \`tiddlywiki_batch_put\`（批量写）/ \`tiddlywiki_rename\`（重命名+同步引用）/ \`tiddlywiki_delete\`（删）/ \`tiddlywiki_recent\`（最近修改）/ \`tiddlywiki_list_tags\`（标签清单）/ \`tiddlywiki_git_sync\`（git 同步）/ \`tiddlywiki_git_resolve\`（冲突按 tiddler 二选一）。
 * **TW 编辑器面板**：侧边栏「TiddlyWiki」按钮 → 在界面中央打开完整版 TW 编辑器。
-* **快速笔记**：右下角悬浮「📝 快速笔记」写随手记（可多选/自动补全 tag），\`Ctrl+Enter\` 保存；点「✏️ 在 TW 中编辑」会弹出独立小窗用 TW 原生编辑器编辑。
+* **快速笔记**：右下角「知识库」悬浮按钮 → 「📝 快速笔记」写随手记（Markdown 高亮、文件上传、多选/自动补全 tag，草稿自动保存到本地），\`Ctrl+Enter\` 保存；「🕘 最近」可一键载入旧笔记继续编辑；「✏️ 在 TW 中编辑」会弹出独立小窗用 TW 原生编辑器编辑。
+* **一键同步**：「知识库」按钮 → 「🔁 同步」一键 pull → commit → push，按钮上的状态点实时反映 git 状态。
 * **git 同步**：写入自动防抖 commit（默认 60 秒）；手动 \`tiddlywiki_git_sync action=sync\` 做 pull → commit → push。
-* **设置页**：DSH 设置 → 「TiddlyWiki 知识库」管理插件/主题/语言与运行配置（含「快速笔记」显示开关、面板「状态/重载」悬浮按钮开关）。
+* **设置页**：DSH 设置 → 「TiddlyWiki 知识库」管理插件/主题/语言与运行配置（含「知识库」按钮相关显示开关）。
 
 !! 知识库纪律（三条）
 
 1. 开工先 \`tiddlywiki_git_sync action=pull\`（rebase + autostash，真冲突会自动 abort 并报文件）。
-2. 收工 \`tiddlywiki_git_sync action=sync\`。
-3. 插件自动 commit 兜底，手动 sync 用于需要主动推送的场合。
+2. 冲突后：\`tiddlywiki_git_resolve files=[冲突文件] strategy=keep-local|keep-remote\` 按 tiddler 二选一解决，再重新 sync。
+3. 收工 \`tiddlywiki_git_sync action=sync\`。
+4. 插件自动 commit 兜底，手动 sync 用于需要主动推送的场合。
 
 !! 主题与语言
 
@@ -1689,20 +1830,82 @@ var TiddlyWebClient = class {
 	/**
 	* Search non-system tiddlers: one request (default listing with text) plus
 	* local case-insensitive substring matching on title + text, optional exact
-	* tag, capped at `limit`. Robust against the server's external-filter 403.
+	* tags (AND), a `since` modified-time floor, an exact `type`, capped at
+	* `limit`. Robust against the server's external-filter 403.
 	*/
-	async search(query, tag, limit = 30) {
+	async search(query, options = {}) {
 		const items = await this.list(void 0, true);
 		const needle = query.toLowerCase();
-		return items.filter((t) => {
+		const sinceTime = parseSince(options.since);
+		const wantedTags = [...options.tags ?? [], options.tag].filter((t) => typeof t === "string" && t.trim().length > 0);
+		const limit = options.limit ?? 30;
+		const matched = items.filter((t) => {
+			if (t.title.startsWith("$:/")) return false;
 			if (!t.title.toLowerCase().includes(needle) && !(t.text ?? "").toLowerCase().includes(needle)) return false;
-			if (tag !== void 0 && tag.length > 0) {
-				if (!(t.tags ?? []).some((t2) => t2.toLowerCase() === tag.toLowerCase())) return false;
+			if (sinceTime !== void 0) {
+				const modified = typeof t.modified === "string" ? new Date(t.modified).getTime() : NaN;
+				if (Number.isNaN(modified) || modified < sinceTime) return false;
+			}
+			if (options.type !== void 0 && options.type.length > 0 && (t.type ?? "text/vnd.tiddlywiki") !== options.type) return false;
+			if (wantedTags.length > 0) {
+				const tags = (t.tags ?? []).map((tag) => tag.toLowerCase());
+				if (!wantedTags.every((w) => tags.includes(w.toLowerCase()))) return false;
+			}
+			return true;
+		});
+		return {
+			items: matched.slice(0, limit),
+			total: matched.length
+		};
+	}
+	/**
+	* List the most recently modified NON-SYSTEM tiddlers, newest first
+	* (missing/modified-less tiddlers sort to the tail). `since` keeps only
+	* tiddlers modified at/after that instant.
+	*/
+	async recent(limit = 15, since) {
+		const items = await this.list(void 0, true);
+		const sinceTime = parseSince(since);
+		const filtered = items.filter((t) => {
+			if (t.title.startsWith("$:/")) return false;
+			if (sinceTime !== void 0) {
+				const modified = typeof t.modified === "string" ? new Date(t.modified).getTime() : NaN;
+				if (Number.isNaN(modified) || modified < sinceTime) return false;
 			}
 			return true;
-		}).slice(0, limit);
+		});
+		filtered.sort((a, b) => {
+			const am = typeof a.modified === "string" ? new Date(a.modified).getTime() : 0;
+			return (typeof b.modified === "string" ? new Date(b.modified).getTime() : 0) - am;
+		});
+		return filtered.slice(0, Math.max(1, Math.min(limit, 200)));
+	}
+	/**
+	* Distinct non-system tags with their tiddler counts, most-used first then
+	* zh-locale. One skinny listing request (no text payloads).
+	*/
+	async listTags() {
+		const items = await this.list(void 0, false);
+		const map = /* @__PURE__ */ new Map();
+		for (const t of items) {
+			if (t.title.startsWith("$:/")) continue;
+			for (const tag of t.tags ?? []) {
+				if (tag.startsWith("$:/")) continue;
+				map.set(tag, (map.get(tag) ?? 0) + 1);
+			}
+		}
+		return [...map.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0], "zh")).map(([tag, count]) => ({
+			tag,
+			count
+		}));
 	}
 };
+/** Parse a `since` value into an epoch ms, or undefined when absent/invalid. */
+function parseSince(since) {
+	if (typeof since !== "string" || since.trim().length === 0) return void 0;
+	const ms = new Date(since.trim()).getTime();
+	return Number.isNaN(ms) ? void 0 : ms;
+}
 //#endregion
 //#region src/sdk.ts
 /**
@@ -1738,7 +1941,11 @@ function compileValue(spec) {
 		const objectSpec = spec;
 		node.type = "object";
 		node.additionalProperties = objectSpec.additionalProperties;
-		if (objectSpec.properties !== void 0) node.properties = compilePropertyMap(objectSpec.properties).properties;
+		if (objectSpec.properties !== void 0) {
+			const compiled = compilePropertyMap(objectSpec.properties);
+			node.properties = compiled.properties;
+			if (compiled.required !== void 0) node.required = compiled.required;
+		}
 		return node;
 	}
 	if (type === "array") {
@@ -1842,10 +2049,14 @@ function defineTool(options) {
 //#endregion
 //#region src/host/tools.ts
 /**
-* The five `tiddlywiki_*` agent tools (design doc §11, D8) plus the extension
+* The `tiddlywiki_*` agent tools (design doc §11, D8) plus the extension
 * point: `registerTiddlywikiTools(ctx, deps)` registers tools list-style, so a
 * new tool is just one more `defineTool` in the array — index.ts never changes.
 *
+* Toolset (v0.5):
+*   search / get / put / batch_put / rename / delete / recent / list_tags /
+*   git_sync / git_resolve
+*
 * RENDER CONTRACT (design doc §4.3): the registry feeds `output.render(args,
 * value)` into the loop — the model sees ONLY the rendered text, never the raw
 * JSON `value`. Every render must carry the complete facts an agent needs to
@@ -1866,6 +2077,42 @@ function pickFields(t) {
 	}
 	return out;
 }
+/** A put-ready copy of a tiddler (no created/modified, tags as array). */
+function cleanTiddler(t) {
+	const out = {
+		title: t.title,
+		text: t.text ?? "",
+		tags: t.tags ?? []
+	};
+	if (typeof t.type === "string") out.type = t.type;
+	for (const [k, v] of Object.entries(t)) {
+		if (k === "title" || k === "text" || k === "tags" || k === "type" || k === "created" || k === "modified" || k === "fields") continue;
+		out[k] = v;
+	}
+	return out;
+}
+/**
+* Rewrite TiddlyWiki references to a title inside wiki text: `[[Title]]`,
+* `[[display|Title]]`, `{{Title}}` → the new title. Best-effort link/text
+* migration for tiddlywiki_rename; returns the rewritten text + hit count.
+*/
+function rewriteRefs(text, oldTitle, newTitle) {
+	if (oldTitle.length === 0) return {
+		text,
+		count: 0
+	};
+	const escaped = oldTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const re = new RegExp(`(\\[\\[[^\\]|]*\\|)${escaped}(\\]\\])|(\\[\\[)${escaped}(\\]\\])|(\\{\\{)${escaped}(\\}\\})`, "g");
+	let count = 0;
+	return {
+		text: text.replace(re, (...args) => {
+			const p = args;
+			count++;
+			return `${p[1] ?? p[3] ?? p[5] ?? ""}${newTitle}${p[2] ?? p[4] ?? p[6] ?? ""}`;
+		}),
+		count
+	};
+}
 function registerTiddlywikiTools(ctx, deps) {
 	const disposers = [];
 	const register = (tool) => {
@@ -1873,29 +2120,51 @@ function registerTiddlywikiTools(ctx, deps) {
 	};
 	register(defineTool({
 		name: "tiddlywiki_search",
-		description: "检索 TiddlyWiki 持久知识库：按关键词（可选 tag 精确匹配）搜索非系统 tiddler，返回标题、标签与摘要片段。",
+		description: "检索 TiddlyWiki 持久知识库：按关键词（可选 tags 数组 / since 修改时间 / type / limit）搜索非系统 tiddler，返回标题、标签、修改时间与摘要片段。",
 		parameters: {
 			query: {
 				type: "string",
 				description: "搜索关键词（大小写不敏感，子串匹配）",
 				required: true
 			},
+			tags: {
+				type: "array",
+				items: { type: "string" },
+				description: "可选：要求同时包含的标签（AND）"
+			},
 			tag: {
 				type: "string",
-				description: "可选：只返回带该 tag 的 tiddler"
+				description: "可选：单个精确标签（与 tags 同为 AND）"
+			},
+			since: {
+				type: "string",
+				description: "可选：ISO 时间（如 2026-09-01 或 2026-09-01T00:00:00Z），只返回修改时间不早于它的 tiddler"
+			},
+			type: {
+				type: "string",
+				description: "可选：精确 tiddler 类型（默认 text/vnd.tiddlywiki）"
+			},
+			limit: {
+				type: "integer",
+				description: "可选：返回条数上限（默认 30，最大 200）"
 			}
 		},
 		output: {
 			schema: { type: "json" },
 			render: (_args, value) => {
-				const lines = [`TiddlyWiki 搜索「${value.query}」${value.tag !== null ? ` (tag=${value.tag})` : ""}：命中 ${value.count} 条。`];
+				const filters = [];
+				if (value.tags.length > 0) filters.push(`tags=${value.tags.join(",")}`);
+				if (value.since !== null) filters.push(`since=${value.since}`);
+				if (value.type !== null) filters.push(`type=${value.type}`);
+				const lines = [`TiddlyWiki 搜索「${value.query}」${filters.length > 0 ? ` (${filters.join(" · ")})` : ""}：命中 ${value.total} 条。`];
 				if (value.results.length === 0) lines.push("没有匹配的 tiddler。");
 				for (const r of value.results) {
 					const tags = r.tags.length > 0 ? ` [${r.tags.join(", ")}]` : "";
-					lines.push(`- ${r.title}${tags}`);
+					const modified = r.modified !== null ? ` (${r.modified})` : "";
+					lines.push(`- ${r.title}${tags}${modified}`);
 					if (r.snippet.length > 0) lines.push(`  ${r.snippet}`);
 				}
-				if (value.count > value.results.length) lines.push(`（另有 ${value.count - value.results.length} 条未展开，可用 tiddlywiki_get 读取具体标题）`);
+				if (value.total > value.results.length) lines.push(`（另有 ${value.total - value.results.length} 条未展开，可用 tiddlywiki_get 读取具体标题，或提高 limit）`);
 				return [{
 					type: "text",
 					text: lines.join("\n")
@@ -1905,19 +2174,101 @@ function registerTiddlywikiTools(ctx, deps) {
 		execute: async (args) => {
 			const wiki = deps.wiki();
 			if (wiki === void 0) throw new Error("TiddlyWiki 服务未运行（tiddlywiki_status 可查）");
-			const results = await wiki.search(args.query, args.tag);
+			const { items, total } = await wiki.search(args.query, {
+				tags: args.tags,
+				tag: args.tag,
+				since: args.since,
+				type: args.type,
+				limit: args.limit
+			});
 			return {
 				query: args.query,
-				tag: args.tag ?? null,
-				count: results.length,
-				results: results.map((t) => ({
+				tags: args.tags ?? [],
+				since: args.since ?? null,
+				type: args.type ?? null,
+				total,
+				results: items.map((t) => ({
+					title: t.title,
+					tags: t.tags ?? [],
+					modified: typeof t.modified === "string" ? t.modified : null,
+					snippet: snippetOf(t.text ?? "")
+				}))
+			};
+		}
+	}));
+	register(defineTool({
+		name: "tiddlywiki_recent",
+		description: "查看 TiddlyWiki 知识库最近修改的笔记（按修改时间倒序，排除系统 tiddler），返回标题、标签、修改时间与摘要。适合开工时快速了解近期动态。",
+		parameters: {
+			limit: {
+				type: "integer",
+				description: "可选：返回条数（默认 15，最大 200）"
+			},
+			since: {
+				type: "string",
+				description: "可选：只返回修改时间不早于该 ISO 时间的 tiddler"
+			}
+		},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => {
+				const lines = [`TiddlyWiki 最近修改（最近 ${value.results.length} 条${value.since !== null ? `，since=${value.since}` : ""}）：`];
+				if (value.results.length === 0) lines.push("暂无笔记。");
+				for (const r of value.results) {
+					const tags = r.tags.length > 0 ? ` [${r.tags.join(", ")}]` : "";
+					lines.push(`- ${r.title}${tags} (${r.modified ?? "?"})`);
+					if (r.snippet.length > 0) lines.push(`  ${r.snippet}`);
+				}
+				return [{
+					type: "text",
+					text: lines.join("\n")
+				}];
+			}
+		},
+		execute: async (args) => {
+			const wiki = deps.wiki();
+			if (wiki === void 0) throw new Error("TiddlyWiki 服务未运行（tiddlywiki_status 可查）");
+			const items = await wiki.recent(args.limit ?? 15, args.since);
+			return {
+				since: args.since ?? null,
+				results: items.map((t) => ({
 					title: t.title,
 					tags: t.tags ?? [],
+					modified: typeof t.modified === "string" ? t.modified : null,
 					snippet: snippetOf(t.text ?? "")
 				}))
 			};
 		}
 	}));
+	register(defineTool({
+		name: "tiddlywiki_list_tags",
+		description: "列出 TiddlyWiki 知识库现有的非系统标签及各自计数（按使用次数降序），方便决定给笔记打什么 tag。",
+		parameters: {},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => {
+				if (value.tags.length === 0) return [{
+					type: "text",
+					text: "知识库暂无标签。"
+				}];
+				const lines = [`现有标签（${value.tags.length} 个，按使用次数降序）：`];
+				for (const t of value.tags) lines.push(`- ${t.tag} × ${t.count}`);
+				return [{
+					type: "text",
+					text: lines.join("\n")
+				}];
+			}
+		},
+		execute: async () => {
+			const wiki = deps.wiki();
+			if (wiki === void 0) throw new Error("TiddlyWiki 服务未运行（tiddlywiki_status 可查）");
+			const tags = await wiki.listTags();
+			return {
+				count: tags.length,
+				tags
+			};
+		}
+	}));
 	register(defineTool({
 		name: "tiddlywiki_get",
 		description: "读取一个 TiddlyWiki tiddler 的完整内容（标题、全文、标签、自定义字段）。",
@@ -1935,6 +2286,7 @@ function registerTiddlywikiTools(ctx, deps) {
 				}];
 				const lines = [`tiddler「${value.title}」`];
 				if (value.tags.length > 0) lines.push(`标签: ${value.tags.join(", ")}`);
+				if (value.modified !== null) lines.push(`修改: ${value.modified}`);
 				const fields = Object.entries(value.fields);
 				if (fields.length > 0) lines.push(`字段: ${fields.map(([k, v]) => `${k}=${String(v)}`).join(", ")}`);
 				lines.push("--- 全文 ---");
@@ -1954,14 +2306,16 @@ function registerTiddlywikiTools(ctx, deps) {
 				title: args.title,
 				text: "",
 				tags: [],
-				fields: {}
+				fields: {},
+				modified: null
 			};
 			return {
 				notFound: false,
 				title: t.title,
 				text: t.text ?? "",
 				tags: t.tags ?? [],
-				fields: pickFields(t)
+				fields: pickFields(t),
+				modified: typeof t.modified === "string" ? t.modified : null
 			};
 		}
 	}));
@@ -2023,6 +2377,186 @@ function registerTiddlywikiTools(ctx, deps) {
 			};
 		}
 	}));
+	register(defineTool({
+		name: "tiddlywiki_batch_put",
+		description: "批量写入/覆盖多个 TiddlyWiki tiddler（一次工具调用）。overwrite=false 时跳过已存在的标题；返回逐条结果。写入后触发自动 commit。",
+		parameters: {
+			items: {
+				type: "array",
+				items: {
+					type: "object",
+					additionalProperties: true,
+					description: "要写入的 tiddler 数组",
+					properties: {
+						title: {
+							type: "string",
+							description: "标题（精确匹配，覆盖同名）",
+							required: true
+						},
+						text: {
+							type: "string",
+							description: "全文（wiki 文本）",
+							required: true
+						},
+						tags: {
+							type: "array",
+							items: { type: "string" },
+							description: "标签数组（可选）"
+						},
+						fields: {
+							type: "json",
+							description: "附加自定义字段（可选）"
+						}
+					}
+				}
+			},
+			overwrite: {
+				type: "boolean",
+				description: "可选：true=覆盖同名（默认），false=跳过已存在的标题"
+			}
+		},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => {
+				const lines = [`批量写入完成：成功 ${value.written}，跳过 ${value.skipped}，共 ${value.items.length} 条。`];
+				for (const r of value.items) lines.push(`- ${r.title}：${r.written ? "已写入" : "已跳过（存在）"}`);
+				return [{
+					type: "text",
+					text: lines.join("\n")
+				}];
+			}
+		},
+		execute: async (args) => {
+			const wiki = deps.wiki();
+			if (wiki === void 0) throw new Error("TiddlyWiki 服务未运行（tiddlywiki_status 可查）");
+			const list = Array.isArray(args.items) ? args.items : [];
+			if (list.length === 0) return {
+				ok: true,
+				written: 0,
+				skipped: 0,
+				items: []
+			};
+			const overwrite = args.overwrite !== false;
+			const results = [];
+			let written = 0;
+			let skipped = 0;
+			for (const item of list) {
+				if (typeof item.title !== "string" || item.title.length === 0) throw new Error("batch_put: 每条 items 都需要非空 title");
+				if (typeof item.text !== "string") throw new Error(`batch_put: items「${item.title}」缺少 text`);
+				if (!overwrite) {
+					if (await wiki.get(item.title).catch(() => void 0) !== void 0) {
+						skipped++;
+						results.push({
+							title: item.title,
+							written: false,
+							skipped: true
+						});
+						continue;
+					}
+				}
+				const tiddler = {
+					title: item.title,
+					text: item.text
+				};
+				if (Array.isArray(item.tags) && item.tags.length > 0) tiddler.tags = item.tags;
+				if (item.fields !== void 0 && typeof item.fields === "object" && item.fields !== null) Object.assign(tiddler, item.fields);
+				await wiki.put(tiddler);
+				written++;
+				results.push({
+					title: item.title,
+					written: true,
+					skipped: false
+				});
+			}
+			deps.autoCommit();
+			return {
+				ok: true,
+				written,
+				skipped,
+				items: results
+			};
+		}
+	}));
+	register(defineTool({
+		name: "tiddlywiki_rename",
+		description: "重命名一个 TiddlyWiki tiddler：把旧标题的内容复制到新标题、删除旧标题，并可选地更新其他 tiddler 里的 [[旧标题]] / {{旧标题}} 引用（最佳努力）。",
+		parameters: {
+			oldTitle: {
+				type: "string",
+				description: "当前标题",
+				required: true
+			},
+			newTitle: {
+				type: "string",
+				description: "新标题",
+				required: true
+			},
+			updateRefs: {
+				type: "boolean",
+				description: "可选：是否同步更新其他 tiddler 里的引用（默认 true）"
+			}
+		},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => {
+				const lines = [`已重命名「${value.from}」→「${value.to}」`];
+				lines.push(`更新了 ${value.refsUpdated} 处引用（${value.refsTiddlers} 个 tiddler）`);
+				if (value.warning !== void 0) lines.push(`注意: ${value.warning}`);
+				return [{
+					type: "text",
+					text: lines.join("\n")
+				}];
+			}
+		},
+		execute: async (args) => {
+			const wiki = deps.wiki();
+			if (wiki === void 0) throw new Error("TiddlyWiki 服务未运行（tiddlywiki_status 可查）");
+			const { oldTitle, newTitle } = args;
+			if (oldTitle === newTitle) return {
+				ok: true,
+				from: oldTitle,
+				to: newTitle,
+				refsUpdated: 0,
+				refsTiddlers: 0
+			};
+			const existing = await wiki.get(oldTitle);
+			if (existing === void 0) throw new Error(`tiddler「${oldTitle}」不存在`);
+			if (await wiki.get(newTitle) !== void 0) throw new Error(`新标题「${newTitle}」已存在（可先用 tiddlywiki_delete 删除）`);
+			let refsUpdated = 0;
+			let refsTiddlers = 0;
+			let warning;
+			if (args.updateRefs !== false) {
+				const all = await wiki.list(void 0, true);
+				for (const t of all) {
+					if (t.title === oldTitle || t.title === newTitle) continue;
+					if (t.title.startsWith("$:/")) continue;
+					const text = t.text ?? "";
+					if (text.length === 0) continue;
+					const rewritten = rewriteRefs(text, oldTitle, newTitle);
+					if (rewritten.count > 0) {
+						await wiki.put({
+							...cleanTiddler(t),
+							text: rewritten.text
+						});
+						refsUpdated += rewritten.count;
+						refsTiddlers++;
+					}
+				}
+			}
+			await wiki.put(cleanTiddler(existing));
+			await wiki.delete(oldTitle);
+			if (refsTiddlers === 0) warning = "未找到任何其他 tiddler 引用旧标题；如确实需要，可手动补充链接。";
+			deps.autoCommit();
+			return {
+				ok: true,
+				from: oldTitle,
+				to: newTitle,
+				refsUpdated,
+				refsTiddlers,
+				...warning !== void 0 ? { warning } : {}
+			};
+		}
+	}));
 	register(defineTool({
 		name: "tiddlywiki_delete",
 		description: "删除一个 TiddlyWiki tiddler（不存在时是幂等空操作）。删除后触发自动 commit。",
@@ -2132,6 +2666,98 @@ function registerTiddlywikiTools(ctx, deps) {
 			}
 		}
 	}));
+	register(defineTool({
+		name: "tiddlywiki_git_resolve",
+		description: "在 tiddlywiki_git_sync action=pull 冲突（已 abort）后，按 tiddler 二选一解决：keep-local 保留本地版本；keep-remote 用 git fetch 拉取远端并检出远端版本（需已配置 git.remote）；list 仅报告当前状态。解决后建议重新 pull/sync 整合其余改动。",
+		parameters: {
+			strategy: {
+				type: "string",
+				enum: [
+					"keep-local",
+					"keep-remote",
+					"list"
+				],
+				description: "keep-local=保留本地；keep-remote=改用远端版本；list=仅报告当前 git 状态",
+				required: true
+			},
+			files: {
+				type: "array",
+				items: { type: "string" },
+				description: "冲突文件名数组（来自 pull 返回的 conflictFiles；list 时忽略）"
+			}
+		},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => {
+				const lines = [`git resolve ${value.action}: ${value.ok ? "成功" : "失败"}`];
+				lines.push(`  ${value.message}`);
+				if (value.files !== void 0 && value.files.length > 0) lines.push(`涉及文件: ${value.files.join(", ")}`);
+				if (value.commit !== void 0) lines.push(`本地 commit: ${value.commit}`);
+				if (value.status !== void 0) {
+					const s = value.status;
+					const bits = [`分支 ${s.branch}`];
+					if (s.ahead !== void 0) bits.push(`领先 ${s.ahead}`);
+					if (s.behind !== void 0) bits.push(`落后 ${s.behind}`);
+					if (s.dirty) bits.push(`工作区有 ${s.dirtyFiles.length} 个未提交改动`);
+					if (s.lastCommit !== void 0) bits.push(`最近提交 ${s.lastCommit}`);
+					lines.push(`状态: ${bits.join(" · ")}`);
+				}
+				return [{
+					type: "text",
+					text: lines.join("\n")
+				}];
+			}
+		},
+		execute: async (args) => {
+			const dir = deps.wikiPath();
+			if (args.strategy === "list") return {
+				ok: true,
+				action: "list",
+				message: "当前仓库状态（pull 冲突已 abort，工作区即本地版本，不会残留未合并状态）",
+				status: await deps.git.status(dir)
+			};
+			const files = (args.files ?? []).filter((f) => typeof f === "string" && f.length > 0);
+			if (files.length === 0) return {
+				ok: false,
+				action: args.strategy,
+				message: "请提供 conflictFiles（来自 pull 返回）",
+				hint: "可先执行 tiddlywiki_git_sync action=pull 查看冲突文件"
+			};
+			if (args.strategy === "keep-local") {
+				const status = await deps.git.status(dir);
+				return {
+					ok: true,
+					action: "keep-local",
+					message: `已保留本地版本（${files.length} 个文件；abort 后本地即为工作区内容）。建议重新 tiddlywiki_git_sync action=sync 整合远端其余改动。`,
+					files,
+					status
+				};
+			}
+			const fetched = await deps.git.fetch(dir);
+			if (!fetched.ok) return {
+				ok: false,
+				action: "keep-remote",
+				message: `fetch 失败（可能未配置 git.remote）：${fetched.message}`
+			};
+			const checked = await deps.git.checkoutFetchHead(dir, files);
+			if (!checked.ok) return {
+				ok: false,
+				action: "keep-remote",
+				message: `从远端检出失败：${checked.message}`
+			};
+			const committed = await deps.git.commit(dir, `resolve conflict (keep remote) ${(/* @__PURE__ */ new Date()).toISOString()}`);
+			deps.autoCommit();
+			const status = await deps.git.status(dir);
+			return {
+				ok: true,
+				action: "keep-remote",
+				message: `已把 ${files.length} 个冲突文件改为远端版本并提交。建议继续 tiddlywiki_git_sync action=sync 完成整合与推送。`,
+				files,
+				commit: committed.message,
+				status
+			};
+		}
+	}));
 	return disposers;
 }
 function renderSync(value) {
@@ -2140,7 +2766,7 @@ function renderSync(value) {
 	if (value.conflictFiles !== void 0 && value.conflictFiles.length > 0) {
 		lines.push(`冲突文件（rebase 已 abort，勿自动覆盖）:`);
 		for (const f of value.conflictFiles) lines.push(`  - ${f}`);
-		lines.push("处理方式：git checkout --ours <file> 保留本地，或人工编辑后 git add + git rebase --continue；也可以直接让用户处理。");
+		lines.push("处理方式：用 tiddlywiki_git_resolve files=[以上文件] strategy=keep-local|keep-remote 按 tiddler 二选一解决，再重新 sync；也可以直接让用户处理。");
 	}
 	if (value.commit !== void 0) lines.push(`本地 commit: ${value.commit}`);
 	if (value.push !== void 0) lines.push(`远端 push: ${value.push}`);
@@ -2248,14 +2874,17 @@ const PROMPT_TEXT = `## TiddlyWiki 持久知识库
 
 本机有一个 TiddlyWiki 5 持久知识库（wiki 文件夹即 git 仓库）。你可以用工具读写 tiddler：
 
-- \`tiddlywiki_search\`（query, tag?）检索；\`tiddlywiki_get\`（title）读全文；\`tiddlywiki_put\`（title, text, tags?, fields?）写/覆盖；\`tiddlywiki_delete\`（title）删除。
-- \`tiddlywiki_git_sync\`（pull|push|sync）做 git 同步。
+- \`tiddlywiki_search\`（query 必填；可选 tags[]/tag、since 修改时间、type、limit）检索；\`tiddlywiki_get\`（title）读全文；\`tiddlywiki_put\`（title, text, tags?, fields?）写/覆盖；\`tiddlywiki_batch_put\`（items[]）批量写；\`tiddlywiki_rename\`（oldTitle, newTitle, updateRefs?）重命名并尽量同步引用；\`tiddlywiki_delete\`（title）删除。
+- \`tiddlywiki_recent\`（limit?, since?）看最近修改的笔记；\`tiddlywiki_list_tags\` 看现有 tag 及计数。
+- \`tiddlywiki_git_sync\`（pull|push|sync）做 git 同步；\`tiddlywiki_git_resolve\`（files, strategy=keep-local|keep-remote|list）在 pull 冲突后按 tiddler 二选一解决。
 
 知识库同步纪律（三条）：
 1. 开工先 pull：\`tiddlywiki_git_sync action=pull\`（rebase + autostash；真冲突会自动 abort 并报冲突文件）。
 2. 收工 commit + push：\`tiddlywiki_git_sync action=sync\`（pull → commit → push）。
 3. 插件会自动防抖 commit（默认 60s），手动同步用上面的工具。
 
+pull 冲突后：先 \`tiddlywiki_git_resolve files=[冲突文件] strategy=keep-local\`（保留本地）或 \`strategy=keep-remote\`（改用远端版本），再重新 pull/sync 整合其余改动。
+
 把 wiki 当作长期记忆与知识沉淀的地方：会议纪要、决策记录、调研笔记、随手的想法都可存成独立 tiddler（tag 建议用 inbox/meeting/decision 等便于检索）。
 
 用本插件自动创建笔记时，除了业务性 tag 外，请把「当前工作区（项目）的名字」也作为标签之一加上去（例如 \`tiddlywiki_put\` 的 tags 里带上当前 workspace 名），这样笔记能按项目归集、检索。`;
@@ -2427,8 +3056,13 @@ function apply(ctx, rawConfig = {}) {
 		};
 	});
 	ctx.effect(() => () => {
-		disposeAll();
-		server.stop();
+		(async () => {
+			try {
+				await committer?.flush();
+			} catch {}
+			disposeAll();
+			await server.stop();
+		})();
 	}, "dsh-tiddlywiki: host teardown");
 }
 //#endregion