@lobehub/cli 0.0.13 → 0.0.16-beta.1

package/dist/index.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import { EventEmitter } from "node:events";
-import { execFile, spawn } from "node:child_process";
-import * as path$1 from "node:path";
-import path from "node:path";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import path, { basename, extname } from "node:path";
 import fs, { createReadStream, existsSync, readFileSync, writeFileSync } from "node:fs";
-import os, { tmpdir } from "node:os";
+import os, { platform, tmpdir } from "node:os";
 import crypto$1, { createHash, randomUUID } from "node:crypto";
 import { createInterface } from "node:readline";
 import { text } from "node:stream/consumers";
-import fs$1, { access, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import fs$1, { access, mkdir, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
 
 //#region \0rolldown/runtime.js
 var __create$2 = Object.create;
@@ -1034,7 +1033,7 @@ var require_suggestSimilar = /* @__PURE__ */ __commonJSMin(((exports) => {
 var require_command = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const EventEmitter$7 = __require("node:events").EventEmitter;
 	const childProcess = __require("node:child_process");
-	const path$12 = __require("node:path");
+	const path$11 = __require("node:path");
 	const fs$12 = __require("node:fs");
 	const process$1 = __require("node:process");
 	const { Argument, humanReadableArgName } = require_argument();
@@ -1941,9 +1940,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
 				".cjs"
 			];
 			function findFile(baseDir, baseName) {
-				const localBin = path$12.resolve(baseDir, baseName);
+				const localBin = path$11.resolve(baseDir, baseName);
 				if (fs$12.existsSync(localBin)) return localBin;
-				if (sourceExt.includes(path$12.extname(baseName))) return void 0;
+				if (sourceExt.includes(path$11.extname(baseName))) return void 0;
 				const foundExt = sourceExt.find((ext) => fs$12.existsSync(`${localBin}${ext}`));
 				if (foundExt) return `${localBin}${foundExt}`;
 			}
@@ -1958,17 +1957,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
 				} catch {
 					resolvedScriptPath = this._scriptPath;
 				}
-				executableDir = path$12.resolve(path$12.dirname(resolvedScriptPath), executableDir);
+				executableDir = path$11.resolve(path$11.dirname(resolvedScriptPath), executableDir);
 			}
 			if (executableDir) {
 				let localFile = findFile(executableDir, executableFile);
 				if (!localFile && !subcommand._executableFile && this._scriptPath) {
-					const legacyName = path$12.basename(this._scriptPath, path$12.extname(this._scriptPath));
+					const legacyName = path$11.basename(this._scriptPath, path$11.extname(this._scriptPath));
 					if (legacyName !== this._name) localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
 				}
 				executableFile = localFile || executableFile;
 			}
-			launchWithNode = sourceExt.includes(path$12.extname(executableFile));
+			launchWithNode = sourceExt.includes(path$11.extname(executableFile));
 			let proc;
 			if (process$1.platform !== "win32") if (launchWithNode) {
 				args.unshift(executableFile);
@@ -2672,7 +2671,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 		* @return {Command}
 		*/
 		nameFromFilename(filename) {
-			this._name = path$12.basename(filename, path$12.extname(filename));
+			this._name = path$11.basename(filename, path$11.extname(filename));
 			return this;
 		}
 		/**
@@ -6949,7 +6948,10 @@ function registerAgentCommand(program) {
 				return;
 			}
 		}
-		const input = { prompt: options.prompt };
+		const input = {
+			prompt: options.prompt,
+			trigger: "cli"
+		};
 		if (options.agentId) input.agentId = options.agentId;
 		if (deviceId) input.deviceId = deviceId;
 		if (options.slug) input.slug = options.slug;
@@ -7346,8 +7348,7 @@ const DEFAULT_AGENT_SEARCH_FC_MODEL = {
 	provider: DEFAULT_PROVIDER
 };
 const DEFAULT_AGENT_CHAT_CONFIG = {
-	autoCreateTopicThreshold: 2,
-	enableAutoCreateTopic: true,
+	enableAgentMode: true,
 	enableCompressHistory: true,
 	enableContextCompression: true,
 	enableHistoryCount: false,
@@ -7414,7 +7415,6 @@ const KeyEnum = {
 };
 const HotkeyEnum = {
 	AddUserMessage: "addUserMessage",
-	ClearCurrentMessages: "clearCurrentMessages",
 	CommandPalette: "commandPalette",
 	DeleteAndRegenerateMessage: "deleteAndRegenerateMessage",
 	DeleteLastMessage: "deleteLastMessage",
@@ -7543,16 +7543,6 @@ const HOTKEYS_REGISTRATION = [
 		nonEditable: true,
 		scopes: [HotkeyScopeEnum.Chat]
 	},
-	{
-		group: HotkeyGroupEnum.Conversation,
-		id: HotkeyEnum.ClearCurrentMessages,
-		keys: combineKeys([
-			KeyEnum.Alt,
-			KeyEnum.Shift,
-			KeyEnum.Backspace
-		]),
-		scopes: [HotkeyScopeEnum.Chat]
-	},
 	{
 		group: HotkeyGroupEnum.Essential,
 		id: HotkeyEnum.SaveDocument,
@@ -7589,6 +7579,29 @@ const DEFAULT_INPUT_COMPLETION_SYSTEM_AGENT_ITEM = {
 //#region ../../packages/const/src/discover.ts
 const DEFAULT_CREATED_AT = (/* @__PURE__ */ new Date()).toISOString();
 
+//#endregion
+//#region ../../packages/const/src/interests.ts
+const INTEREST_AREA_KEYS = [
+	"writing",
+	"coding",
+	"design",
+	"education",
+	"business",
+	"marketing",
+	"product",
+	"sales",
+	"operations",
+	"hr",
+	"finance-legal",
+	"creator",
+	"investing",
+	"parenting",
+	"health",
+	"hobbies",
+	"personal"
+];
+const interestAreaKeySet = new Set(INTEREST_AREA_KEYS);
+
 //#endregion
 //#region ../../../node_modules/.pnpm/react@19.2.4/node_modules/react/cjs/react-jsx-runtime.production.js
 /**
@@ -10011,16 +10024,6 @@ const KLAVIS_SERVER_TYPES = [
 		label: "Google Calendar",
 		serverName: McpServerName.GoogleCalendar
 	},
-	{
-		author: "Klavis",
-		authorUrl: "https://klavis.io",
-		description: "Notion is a collaborative productivity and note-taking application",
-		icon: "https://hub-apac-1.lobeobjects.space/assets/logos/notion.svg",
-		identifier: "notion",
-		readme: "Connect to Notion to access and manage your workspace. Create pages, search content, update databases, and organize your knowledge base—all through natural conversation with your AI assistant.",
-		label: "Notion",
-		serverName: McpServerName.Notion
-	},
 	{
 		author: "Klavis",
 		authorUrl: "https://klavis.io",
@@ -10213,6 +10216,15 @@ const KLAVIS_SERVER_TYPES = [
 	}
 ];
 
+//#endregion
+//#region ../../package.json
+var version$3 = "2.2.0";
+
+//#endregion
+//#region ../../packages/const/src/version.ts
+const CURRENT_VERSION = version$3;
+const isDesktop = typeof __ELECTRON__ !== "undefined" && !!__ELECTRON__;
+
 //#endregion
 //#region ../../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/predicate/isLength.mjs
 function isLength(value) {
@@ -10621,6 +10633,669 @@ const DEFAULT_INBOX_SESSION = merge(DEFAULT_AGENT_LOBE_SESSION, {
 	meta: { avatar: DEFAULT_INBOX_AVATAR }
 });
 
+//#endregion
+//#region ../../packages/const/src/taskTemplate.ts
+const taskTemplates = [
+	{
+		id: "daily-topic-pick",
+		category: "content-creation",
+		cronPattern: "0 9 * * *",
+		interests: ["writing"]
+	},
+	{
+		id: "hot-topic-radar",
+		category: "content-creation",
+		cronPattern: "0 10 * * *",
+		interests: ["writing"]
+	},
+	{
+		id: "headline-inspiration",
+		category: "content-creation",
+		cronPattern: "0 10 * * *",
+		interests: ["writing"]
+	},
+	{
+		id: "viral-content-breakdown",
+		category: "content-creation",
+		cronPattern: "0 10 * * *",
+		interests: ["writing"]
+	},
+	{
+		id: "twitter-weekly-recap",
+		category: "content-creation",
+		cronPattern: "0 10 * * 1",
+		interests: ["writing", "creator"],
+		requiresSkills: [{
+			provider: "twitter",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "youtube-weekly-recap",
+		category: "content-creation",
+		cronPattern: "0 9 * * 1",
+		interests: ["writing", "creator"],
+		requiresSkills: [{
+			provider: "youtube",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "competitor-creator-tracking",
+		category: "content-creation",
+		cronPattern: "0 9 * * *",
+		interests: ["writing", "creator"]
+	},
+	{
+		id: "content-calendar-weekly",
+		category: "content-creation",
+		cronPattern: "0 20 * * 0",
+		interests: ["writing", "creator"],
+		optionalSkills: [{
+			provider: "notion",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "oss-intel-daily",
+		category: "engineering",
+		cronPattern: "0 9 * * *",
+		icon: "github",
+		interests: ["coding"]
+	},
+	{
+		id: "repo-health-weekly",
+		category: "engineering",
+		cronPattern: "0 9 * * 1",
+		interests: ["coding"],
+		requiresSkills: [{
+			provider: "github",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "dependency-security-weekly",
+		category: "engineering",
+		cronPattern: "0 10 * * 1",
+		interests: ["coding"],
+		requiresSkills: [{
+			provider: "github",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "vercel-health-weekly",
+		category: "engineering",
+		cronPattern: "0 10 * * 1",
+		interests: ["coding"],
+		requiresSkills: [{
+			provider: "vercel",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "linear-sprint-daily",
+		category: "engineering",
+		cronPattern: "30 8 * * *",
+		interests: ["coding", "product"],
+		requiresSkills: [{
+			provider: "linear",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "tech-trend-weekly",
+		category: "engineering",
+		cronPattern: "0 8 * * 1",
+		interests: ["coding"]
+	},
+	{
+		id: "keyword-tech-feed",
+		category: "engineering",
+		cronPattern: "0 10 * * *",
+		interests: ["coding"]
+	},
+	{
+		id: "daily-design-inspiration",
+		category: "design",
+		cronPattern: "0 9 * * *",
+		interests: ["design"]
+	},
+	{
+		id: "design-trend-weekly",
+		category: "design",
+		cronPattern: "0 9 * * 1",
+		interests: ["design"]
+	},
+	{
+		id: "figma-files-cleanup",
+		category: "design",
+		cronPattern: "0 17 * * 5",
+		interests: ["design"],
+		requiresSkills: [{
+			provider: "figma",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "aigc-prompt-inspiration",
+		category: "design",
+		cronPattern: "0 10 * * *",
+		interests: ["design"]
+	},
+	{
+		id: "brand-watch-weekly",
+		category: "design",
+		cronPattern: "0 10 * * 1",
+		interests: ["design"]
+	},
+	{
+		id: "font-color-weekly",
+		category: "design",
+		cronPattern: "0 10 * * 3",
+		interests: ["design"]
+	},
+	{
+		id: "arxiv-curated-daily",
+		category: "learning-research",
+		cronPattern: "0 9 * * *",
+		interests: ["education"]
+	},
+	{
+		id: "must-read-papers-weekly",
+		category: "learning-research",
+		cronPattern: "0 20 * * 0",
+		interests: ["education"]
+	},
+	{
+		id: "language-morning-bite",
+		category: "learning-research",
+		cronPattern: "30 7 * * *",
+		interests: ["education"]
+	},
+	{
+		id: "industry-research-weekly",
+		category: "learning-research",
+		cronPattern: "0 9 * * 1",
+		interests: ["education", "business"]
+	},
+	{
+		id: "industry-morning-brief",
+		category: "business",
+		cronPattern: "0 8 * * *",
+		interests: ["business"]
+	},
+	{
+		id: "competitor-radar-daily",
+		category: "business",
+		cronPattern: "0 9 * * *",
+		interests: ["business"]
+	},
+	{
+		id: "funding-intel-daily",
+		category: "business",
+		cronPattern: "0 10 * * *",
+		interests: ["business"]
+	},
+	{
+		id: "macro-economy-weekly",
+		category: "business",
+		cronPattern: "0 8 * * 1",
+		interests: ["business", "investing"]
+	},
+	{
+		id: "weekly-meeting-brief",
+		category: "business",
+		cronPattern: "30 8 * * 1",
+		interests: ["business"]
+	},
+	{
+		id: "marketing-hot-radar",
+		category: "marketing",
+		cronPattern: "0 10 * * *",
+		interests: ["marketing"]
+	},
+	{
+		id: "ad-creative-inspiration",
+		category: "marketing",
+		cronPattern: "0 10 * * *",
+		interests: ["marketing"]
+	},
+	{
+		id: "brand-mention-daily",
+		category: "marketing",
+		cronPattern: "0 18 * * *",
+		interests: ["marketing"],
+		requiresSkills: [{
+			provider: "twitter",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "seo-weekly-report",
+		category: "marketing",
+		cronPattern: "0 9 * * 1",
+		interests: ["marketing"]
+	},
+	{
+		id: "newsletter-perf-weekly",
+		category: "marketing",
+		cronPattern: "0 10 * * 1",
+		interests: ["marketing"],
+		requiresSkills: [{
+			provider: "gmail",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "kol-collab-calendar",
+		category: "marketing",
+		cronPattern: "0 9 * * 1",
+		interests: ["marketing"],
+		requiresSkills: [{
+			provider: "airtable",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "hubspot-funnel-daily",
+		category: "marketing",
+		cronPattern: "0 9 * * *",
+		interests: ["marketing", "sales"],
+		requiresSkills: [{
+			provider: "hubspot",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "user-feedback-daily",
+		category: "product",
+		cronPattern: "0 9 * * *",
+		interests: ["product"]
+	},
+	{
+		id: "competitor-update-daily",
+		category: "product",
+		cronPattern: "0 10 * * *",
+		interests: ["product"]
+	},
+	{
+		id: "standup-brief",
+		category: "product",
+		cronPattern: "30 8 * * *",
+		interests: ["product"],
+		requiresSkills: [{
+			provider: "linear",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "iteration-recap-weekly",
+		category: "product",
+		cronPattern: "0 17 * * 5",
+		interests: ["product"],
+		requiresSkills: [{
+			provider: "linear",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "core-metric-daily",
+		category: "product",
+		cronPattern: "0 9 * * *",
+		interests: ["product"]
+	},
+	{
+		id: "user-interview-schedule",
+		category: "product",
+		cronPattern: "0 9 * * 1",
+		interests: ["product"],
+		requiresSkills: [{
+			provider: "google-calendar",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "prd-review-reminder",
+		category: "product",
+		cronPattern: "0 15 * * 5",
+		interests: ["product"],
+		requiresSkills: [{
+			provider: "notion",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "daily-followup-list",
+		category: "sales-customer",
+		cronPattern: "0 9 * * *",
+		interests: ["sales"],
+		requiresSkills: [{
+			provider: "hubspot",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "renewal-risk-weekly",
+		category: "sales-customer",
+		cronPattern: "0 9 * * 1",
+		interests: ["sales"],
+		requiresSkills: [{
+			provider: "hubspot",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "deal-pipeline-weekly",
+		category: "sales-customer",
+		cronPattern: "0 16 * * 5",
+		interests: ["sales"],
+		requiresSkills: [{
+			provider: "hubspot",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "key-account-radar",
+		category: "sales-customer",
+		cronPattern: "0 9 * * *",
+		interests: ["sales"]
+	},
+	{
+		id: "zendesk-ticket-daily",
+		category: "sales-customer",
+		cronPattern: "0 9 * * *",
+		interests: ["sales"],
+		requiresSkills: [{
+			provider: "zendesk",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "morning-brief",
+		category: "operations",
+		cronPattern: "0 8 * * *",
+		interests: ["operations"],
+		requiresSkills: [{
+			provider: "google-calendar",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "meeting-brief",
+		category: "operations",
+		cronPattern: "30 8 * * *",
+		interests: ["operations"],
+		requiresSkills: [{
+			provider: "google-calendar",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "calendar-conflict-check",
+		category: "operations",
+		cronPattern: "30 7 * * *",
+		interests: ["operations"],
+		requiresSkills: [{
+			provider: "google-calendar",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "friday-wrap-list",
+		category: "operations",
+		cronPattern: "0 16 * * 5",
+		interests: ["operations"],
+		requiresSkills: [{
+			provider: "linear",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "recruit-funnel-daily",
+		category: "hr",
+		cronPattern: "0 9 * * *",
+		interests: ["hr"],
+		requiresSkills: [{
+			provider: "airtable",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "onboarding-buddy-weekly",
+		category: "hr",
+		cronPattern: "0 9 * * 1",
+		interests: ["hr"],
+		requiresSkills: [{
+			provider: "notion",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "team-status-weekly",
+		category: "hr",
+		cronPattern: "0 9 * * 1",
+		interests: ["hr"],
+		requiresSkills: [{
+			provider: "google-calendar",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "precious-metals-daily",
+		category: "finance-legal",
+		cronPattern: "0 16 * * *",
+		interests: ["finance-legal", "investing"]
+	},
+	{
+		id: "pre-market-brief",
+		category: "finance-legal",
+		cronPattern: "0 9 * * *",
+		interests: ["finance-legal", "investing"]
+	},
+	{
+		id: "cashflow-weekly",
+		category: "finance-legal",
+		cronPattern: "0 9 * * 1",
+		interests: ["finance-legal"],
+		requiresSkills: [{
+			provider: "airtable",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "contract-expiry-weekly",
+		category: "finance-legal",
+		cronPattern: "0 9 * * 1",
+		interests: ["finance-legal"],
+		requiresSkills: [{
+			provider: "notion",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "regulation-watch-weekly",
+		category: "finance-legal",
+		cronPattern: "0 10 * * 1",
+		interests: ["finance-legal"]
+	},
+	{
+		id: "invoice-collection-daily",
+		category: "finance-legal",
+		cronPattern: "0 10 * * *",
+		interests: ["finance-legal"],
+		requiresSkills: [{
+			provider: "gmail",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "cross-platform-engagement-daily",
+		category: "creator",
+		cronPattern: "0 9 * * *",
+		interests: ["creator"],
+		requiresSkills: [{
+			provider: "twitter",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "brand-collab-weekly",
+		category: "creator",
+		cronPattern: "0 10 * * 1",
+		interests: ["creator"]
+	},
+	{
+		id: "follower-growth-weekly",
+		category: "creator",
+		cronPattern: "0 10 * * 1",
+		interests: ["creator"],
+		requiresSkills: [{
+			provider: "twitter",
+			source: "lobehub"
+		}]
+	},
+	{
+		id: "youtube-channel-weekly",
+		category: "creator",
+		cronPattern: "0 9 * * 1",
+		interests: ["creator"],
+		requiresSkills: [{
+			provider: "youtube",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "monetization-opportunity-weekly",
+		category: "creator",
+		cronPattern: "0 10 * * 3",
+		interests: ["creator"]
+	},
+	{
+		id: "portfolio-daily",
+		category: "investing",
+		cronPattern: "0 16 * * *",
+		interests: ["investing"]
+	},
+	{
+		id: "crypto-market-daily",
+		category: "investing",
+		cronPattern: "0 9 * * *",
+		interests: ["investing"]
+	},
+	{
+		id: "child-growth-weekly",
+		category: "parenting",
+		cronPattern: "0 9 * * 1",
+		interests: ["parenting"]
+	},
+	{
+		id: "child-study-weekly",
+		category: "parenting",
+		cronPattern: "0 20 * * 0",
+		interests: ["parenting", "education"]
+	},
+	{
+		id: "family-finance-weekly",
+		category: "parenting",
+		cronPattern: "0 20 * * 0",
+		interests: ["parenting", "finance-legal"],
+		requiresSkills: [{
+			provider: "google-sheets",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "family-task-schedule",
+		category: "parenting",
+		cronPattern: "0 8 * * 1",
+		interests: ["parenting"],
+		optionalSkills: [{
+			provider: "google-calendar",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "diet-log-companion",
+		category: "health",
+		cronPattern: "0 21 * * *",
+		interests: ["health"]
+	},
+	{
+		id: "podcast-new-episodes",
+		category: "hobbies",
+		cronPattern: "0 9 * * 1",
+		interests: ["hobbies"]
+	},
+	{
+		id: "newsletter-aggregator",
+		category: "hobbies",
+		cronPattern: "0 20 * * 0",
+		interests: ["hobbies"],
+		requiresSkills: [{
+			provider: "gmail",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "series-update-weekly",
+		category: "hobbies",
+		cronPattern: "0 9 * * 1",
+		interests: ["hobbies"]
+	},
+	{
+		id: "travel-inspiration-weekly",
+		category: "hobbies",
+		cronPattern: "0 10 * * 3",
+		interests: ["hobbies"]
+	},
+	{
+		id: "watchlist-friday",
+		category: "hobbies",
+		cronPattern: "0 18 * * 5",
+		interests: ["hobbies"]
+	},
+	{
+		id: "exhibition-event-weekly",
+		category: "hobbies",
+		cronPattern: "0 10 * * 1",
+		interests: ["hobbies"]
+	},
+	{
+		id: "daily-learning-bite",
+		category: "personal-life",
+		cronPattern: "30 7 * * *",
+		interests: ["education", "personal"]
+	},
+	{
+		id: "sunday-reflection",
+		category: "personal-life",
+		cronPattern: "0 21 * * 0",
+		interests: ["personal"]
+	},
+	{
+		id: "morning-ritual",
+		category: "personal-life",
+		cronPattern: "0 7 * * *",
+		interests: ["personal"],
+		optionalSkills: [{
+			provider: "google-calendar",
+			source: "klavis"
+		}]
+	},
+	{
+		id: "bedtime-gratitude",
+		category: "personal-life",
+		cronPattern: "0 22 * * *",
+		interests: ["personal"],
+		optionalSkills: [{
+			provider: "notion",
+			source: "lobehub"
+		}]
+	}
+];
+const KNOWN_TASK_TEMPLATE_IDS = new Set(taskTemplates.map((t) => t.id));
+
 //#endregion
 //#region ../../packages/const/src/url.ts
 const isDev = process.env.NODE_ENV === "development";
@@ -10671,21 +11346,74 @@ const MEMORY_SEARCH_TOP_K_LIMITS = {
 	medium: { ...DEFAULT_SEARCH_USER_MEMORY_TOP_K }
 };
 
-//#endregion
-//#region ../../package.json
-var version$3 = "2.1.56";
-
-//#endregion
-//#region ../../packages/const/src/version.ts
-const CURRENT_VERSION = version$3;
-const isDesktop = typeof __ELECTRON__ !== "undefined" && !!__ELECTRON__;
-
 //#endregion
 //#region src/commands/botMessage.ts
+const MIME_EXT_MAP = {
+	".bmp": "image/bmp",
+	".gif": "image/gif",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".m4a": "audio/mp4",
+	".mp3": "audio/mpeg",
+	".mp4": "video/mp4",
+	".ogg": "audio/ogg",
+	".pdf": "application/pdf",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".txt": "text/plain",
+	".wav": "audio/wav",
+	".webm": "video/webm",
+	".webp": "image/webp"
+};
+const inferMime = (path) => MIME_EXT_MAP[extname(path).toLowerCase()];
+const inferAttachmentType = (mimeType) => {
+	if (!mimeType) return "file";
+	if (mimeType.startsWith("image/")) return "image";
+	if (mimeType.startsWith("video/")) return "video";
+	if (mimeType.startsWith("audio/")) return "audio";
+	return "file";
+};
+/**
+* Parse a single `--attachment <value>` argument. Accepted forms:
+*   - `https://…` / `http://…`           → fetchUrl, type inferred from extension
+*   - any other string                    → treated as a local file path;
+*                                           bytes are read + base64-encoded
+*/
+const parseAttachmentArg = async (raw) => {
+	if (/^https?:\/\//.test(raw)) {
+		const pathname = new URL(raw).pathname;
+		const mimeType = inferMime(pathname);
+		return {
+			fetchUrl: raw,
+			mimeType,
+			name: basename(pathname) || void 0,
+			type: inferAttachmentType(mimeType)
+		};
+	}
+	const bytes = await readFile(raw);
+	const mimeType = inferMime(raw);
+	return {
+		data: bytes.toString("base64"),
+		mimeType,
+		name: basename(raw),
+		type: inferAttachmentType(mimeType)
+	};
+};
 function registerBotMessageCommands(bot) {
 	const message = bot.command("message").description("Send and manage messages on connected platforms");
-	message.command("send <botId>").description("Send a message to a channel").requiredOption("--target <channelId>", "Target channel / conversation ID").requiredOption("--message <text>", "Message content").option("--reply-to <messageId>", "Reply to a specific message").option("--json", "Output JSON").action(async (botId, options) => {
+	message.command("send <botId>").description("Send a message to a channel").requiredOption("--target <channelId>", "Target channel / conversation ID").requiredOption("--message <text>", "Message content").option("--attachment <pathOrUrl>", "Attach a file by local path or remote URL (repeatable). Local paths are base64-encoded; http(s) URLs are passed as fetchUrl.", collectOptions, []).option("--reply-to <messageId>", "Reply to a specific message").option("--json", "Output JSON").action(async (botId, options) => {
+		let attachments;
+		if (options.attachment.length > 0) {
+			attachments = [];
+			for (const raw of options.attachment) try {
+				attachments.push(await parseAttachmentArg(raw));
+			} catch (error) {
+				log$7.error(`Failed to load attachment "${raw}": ${error.message}`);
+				process.exit(1);
+			}
+		}
 		const result = await (await getTrpcClient()).botMessage.sendMessage.mutate({
+			attachments,
 			botId,
 			channelId: options.target,
 			content: options.message,
@@ -10696,7 +11424,8 @@ function registerBotMessageCommands(bot) {
 			return;
 		}
 		const r = result;
-		console.log(`${import_picocolors.default.green("✓")} Message sent${r.messageId ? ` (${import_picocolors.default.dim(r.messageId)})` : ""}`);
+		const suffix = attachments?.length ? ` with ${attachments.length} attachment(s)` : "";
+		console.log(`${import_picocolors.default.green("✓")} Message sent${r.messageId ? ` (${import_picocolors.default.dim(r.messageId)})` : ""}${suffix}`);
 	});
 	message.command("read <botId>").description("Read messages from a channel").requiredOption("--target <channelId>", "Target channel / conversation ID").option("--limit <n>", "Max messages to fetch", String(50)).option("--before <messageId>", "Read messages before this ID").option("--after <messageId>", "Read messages after this ID").option("--start-time <timestamp>", "Start time as Unix seconds (Feishu/Lark)").option("--end-time <timestamp>", "End time as Unix seconds (Feishu/Lark)").option("--cursor <token>", "Pagination cursor from a previous response (Feishu/Lark)").option("--json", "Output JSON").action(async (botId, options) => {
 		const result = await (await getTrpcClient()).botMessage.readMessages.query({
@@ -11144,6 +11873,134 @@ function registerAllowlistCommand(bot, opts) {
 		console.log(`${import_picocolors.default.green("✓")} Cleared ${opts.fieldKey} on bot ${import_picocolors.default.bold(botId)}`);
 	});
 }
+/**
+* Normalise `settings.watchKeywords` into the canonical
+* `{keyword, instruction?}[]` shape. Mirrors `extractWatchKeywordEntries`
+* in `src/server/services/bot/platforms/const.ts` so the CLI accepts the
+* same legacy on-disk shapes (`string`, `string[]`, `{keyword, …}[]`)
+* the runtime is forgiving about — including the rare comma/whitespace
+* separated string from a hand-pasted upgrade.
+*/
+function normalizeWatchKeywords(raw) {
+	const push = (out, keyword, instruction) => {
+		if (typeof keyword !== "string") return;
+		const normalised = keyword.trim().toLowerCase();
+		if (!normalised) return;
+		const trimmedInstruction = typeof instruction === "string" && instruction.trim() ? instruction.trim() : void 0;
+		const existing = out.get(normalised);
+		if (!existing) {
+			out.set(normalised, {
+				instruction: trimmedInstruction,
+				keyword: normalised
+			});
+			return;
+		}
+		if (!existing.instruction && trimmedInstruction) existing.instruction = trimmedInstruction;
+	};
+	const collected = /* @__PURE__ */ new Map();
+	if (typeof raw === "string") for (const piece of raw.split(/[\s,]+/)) push(collected, piece);
+	else if (Array.isArray(raw)) for (const entry of raw) {
+		if (typeof entry === "string") {
+			push(collected, entry);
+			continue;
+		}
+		if (entry && typeof entry === "object" && "keyword" in entry) {
+			const obj = entry;
+			push(collected, obj.keyword, obj.instruction);
+		}
+	}
+	return [...collected.values()];
+}
+/**
+* Build a `list / add / remove / clear` subcommand group around
+* `settings.watchKeywords`. Shape differs from the user/channel allowlists
+* (`{keyword, instruction?}` vs `{id, name?}`), so we duplicate the
+* scaffolding instead of squeezing both shapes through one factory — the
+* help text, column headers, and `--instruction` flag are all keyword-
+* specific and would just bloat the unified version.
+*/
+function registerWatchKeywordsCommand(bot) {
+	const group = bot.command("watch-keywords").description("Manage watch keywords (non-mention channel triggers; the optional instruction is prepended to the user message before being sent to the AI)");
+	const readEntries = (bot) => normalizeWatchKeywords(bot.settings?.watchKeywords);
+	const buildPayload = (bot, nextEntries) => ({
+		id: bot.id,
+		settings: {
+			...bot.settings,
+			watchKeywords: nextEntries
+		}
+	});
+	group.command("list <botId>").description("List watch-keyword entries").option("--json", "Output JSON").action(async (botId, options) => {
+		const entries = readEntries(await findBot(await getTrpcClient(), botId));
+		if (options.json) {
+			outputJson(entries);
+			return;
+		}
+		if (entries.length === 0) {
+			console.log(`${import_picocolors.default.dim("No watch-keyword entries.")}`);
+			return;
+		}
+		printTable(entries.map((e) => [e.keyword, e.instruction ?? import_picocolors.default.dim("-")]), ["KEYWORD", "INSTRUCTION"]);
+	});
+	group.command("add <botId> <keyword>").description("Add a watch keyword (with optional instruction prefix)").option("--instruction <text>", "Prompt prepended to the user message when this keyword fires (omit for \"just wake the bot\")").action(async (botId, keyword, options) => {
+		const trimmedKeyword = keyword.trim().toLowerCase();
+		if (!trimmedKeyword) {
+			log$7.error("Keyword cannot be empty.");
+			process.exit(1);
+			return;
+		}
+		const trimmedInstruction = options.instruction?.trim();
+		const client = await getTrpcClient();
+		const b = await findBot(client, botId);
+		const entries = readEntries(b);
+		const existing = entries.find((e) => e.keyword === trimmedKeyword);
+		if (existing) {
+			if (trimmedInstruction && existing.instruction !== trimmedInstruction) {
+				existing.instruction = trimmedInstruction;
+				await client.agentBotProvider.update.mutate(buildPayload(b, entries));
+				console.log(`${import_picocolors.default.green("✓")} Updated instruction for ${import_picocolors.default.bold(trimmedKeyword)} (${entries.length} entr${entries.length === 1 ? "y" : "ies"})`);
+				return;
+			}
+			log$7.info(`${trimmedKeyword} is already on watchKeywords — nothing to do.`);
+			return;
+		}
+		const next = [...entries, trimmedInstruction ? {
+			instruction: trimmedInstruction,
+			keyword: trimmedKeyword
+		} : { keyword: trimmedKeyword }];
+		await client.agentBotProvider.update.mutate(buildPayload(b, next));
+		console.log(`${import_picocolors.default.green("✓")} Added ${import_picocolors.default.bold(trimmedKeyword)}${trimmedInstruction ? " (with instruction)" : ""} to watchKeywords (now ${next.length} entr${next.length === 1 ? "y" : "ies"})`);
+	});
+	group.command("remove <botId> <keyword>").description("Remove a watch keyword").action(async (botId, keyword) => {
+		const trimmedKeyword = keyword.trim().toLowerCase();
+		const client = await getTrpcClient();
+		const b = await findBot(client, botId);
+		const entries = readEntries(b);
+		const next = entries.filter((e) => e.keyword !== trimmedKeyword);
+		if (next.length === entries.length) {
+			log$7.info(`${trimmedKeyword} is not on watchKeywords — nothing to do.`);
+			return;
+		}
+		await client.agentBotProvider.update.mutate(buildPayload(b, next));
+		console.log(`${import_picocolors.default.green("✓")} Removed ${import_picocolors.default.bold(trimmedKeyword)} from watchKeywords (${next.length} entr${next.length === 1 ? "y" : "ies"} left)`);
+	});
+	group.command("clear <botId>").description("Clear all watch keywords").option("--yes", "Skip confirmation prompt").action(async (botId, options) => {
+		const client = await getTrpcClient();
+		const b = await findBot(client, botId);
+		const entries = readEntries(b);
+		if (entries.length === 0) {
+			log$7.info("watchKeywords is already empty — nothing to do.");
+			return;
+		}
+		if (!options.yes) {
+			if (!await confirm(`Clear all ${entries.length} watch-keyword entr${entries.length === 1 ? "y" : "ies"} from this bot?`)) {
+				console.log("Cancelled.");
+				return;
+			}
+		}
+		await client.agentBotProvider.update.mutate(buildPayload(b, []));
+		console.log(`${import_picocolors.default.green("✓")} Cleared watchKeywords on bot ${import_picocolors.default.bold(botId)}`);
+	});
+}
 function registerBotCommand(program) {
 	const bot = program.command("bot").description("Manage bot integrations");
 	registerBotMessageCommands(bot);
@@ -11333,6 +12190,7 @@ function registerBotCommand(program) {
 		idLabel: "channel / group / thread ID",
 		name: "group-allowlist"
 	});
+	registerWatchKeywordsCommand(bot);
 	bot.command("remove <botId>").description("Remove a bot integration").option("--yes", "Skip confirmation prompt").action(async (botId, options) => {
 		if (!options.yes) {
 			if (!await confirm("Are you sure you want to remove this bot integration?")) {
@@ -16388,7 +17246,7 @@ var require_path = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
 	const os$3 = __require("os");
-	const path$11 = __require("path");
+	const path$10 = __require("path");
 	const IS_WINDOWS_PLATFORM = os$3.platform() === "win32";
 	const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
 	/**
@@ -16417,7 +17275,7 @@ var require_path = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 	exports.unixify = unixify;
 	function makeAbsolute(cwd, filepath) {
-		return path$11.resolve(cwd, filepath);
+		return path$10.resolve(cwd, filepath);
 	}
 	exports.makeAbsolute = makeAbsolute;
 	function removeLeadingDotSegment(entry) {
@@ -17683,7 +18541,7 @@ var require_braces = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/constants.js
 var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const path$10 = __require("path");
+	const path$9 = __require("path");
 	const WIN_SLASH = "\\\\/";
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 	const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
@@ -17812,7 +18670,7 @@ var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		CHAR_UNDERSCORE: 95,
 		CHAR_VERTICAL_LINE: 124,
 		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-		SEP: path$10.sep,
+		SEP: path$9.sep,
 		/**
 		* Create EXTGLOB_CHARS
 		*/
@@ -17857,7 +18715,7 @@ var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/utils.js
 var require_utils$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
-	const path$9 = __require("path");
+	const path$8 = __require("path");
 	const win32 = process.platform === "win32";
 	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants$2();
 	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
@@ -17877,7 +18735,7 @@ var require_utils$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	};
 	exports.isWindows = (options) => {
 		if (options && typeof options.windows === "boolean") return options.windows;
-		return win32 === true || path$9.sep === "\\";
+		return win32 === true || path$8.sep === "\\";
 	};
 	exports.escapeLast = (input, char, lastIdx) => {
 		const idx = input.lastIndexOf(char, lastIdx);
@@ -19250,7 +20108,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region node_modules/.pnpm/picomatch@2.3.2/node_modules/picomatch/lib/picomatch.js
 var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const path$8 = __require("path");
+	const path$7 = __require("path");
 	const scan = require_scan();
 	const parse = require_parse();
 	const utils = require_utils$3();
@@ -19389,7 +20247,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @api public
 	*/
 	picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(path$8.basename(input));
+		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(path$7.basename(input));
 	};
 	/**
 	* Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -19947,7 +20805,7 @@ var require_micromatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.isAbsolute = exports.partitionAbsoluteAndRelative = exports.removeDuplicateSlashes = exports.matchAny = exports.convertPatternsToRe = exports.makeRe = exports.getPatternParts = exports.expandBraceExpansion = exports.expandPatternsWithBraceExpansion = exports.isAffectDepthOfReadingPattern = exports.endsWithSlashGlobStar = exports.hasGlobStar = exports.getBaseDirectory = exports.isPatternRelatedToParentDirectory = exports.getPatternsOutsideCurrentDirectory = exports.getPatternsInsideCurrentDirectory = exports.getPositivePatterns = exports.getNegativePatterns = exports.isPositivePattern = exports.isNegativePattern = exports.convertToNegativePattern = exports.convertToPositivePattern = exports.isDynamicPattern = exports.isStaticPattern = void 0;
-	const path$7 = __require("path");
+	const path$6 = __require("path");
 	const globParent = require_glob_parent();
 	const micromatch = require_micromatch();
 	const GLOBSTAR = "**";
@@ -20055,7 +20913,7 @@ var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 	exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
 	function isAffectDepthOfReadingPattern(pattern) {
-		const basename = path$7.basename(pattern);
+		const basename = path$6.basename(pattern);
 		return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
 	}
 	exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
@@ -20129,7 +20987,7 @@ var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 	exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
 	function isAbsolute(pattern) {
-		return path$7.isAbsolute(pattern);
+		return path$6.isAbsolute(pattern);
 	}
 	exports.isAbsolute = isAbsolute;
 }));
@@ -20788,7 +21646,7 @@ var require_fs = /* @__PURE__ */ __commonJSMin(((exports) => {
 //#region node_modules/.pnpm/@nodelib+fs.scandir@2.1.5/node_modules/@nodelib/fs.scandir/out/settings.js
 var require_settings$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
-	const path$6 = __require("path");
+	const path$5 = __require("path");
 	const fsStat = require_out$3();
 	const fs = require_fs();
 	var Settings = class {
@@ -20796,7 +21654,7 @@ var require_settings$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 			this._options = _options;
 			this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
 			this.fs = fs.createFileSystemAdapter(this._options.fs);
-			this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$6.sep);
+			this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$5.sep);
 			this.stats = this._getValue(this._options.stats, false);
 			this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
 			this.fsStatSettings = new fsStat.Settings({
@@ -21401,7 +22259,7 @@ var require_sync$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
 //#region node_modules/.pnpm/@nodelib+fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/settings.js
 var require_settings$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
-	const path$5 = __require("path");
+	const path$4 = __require("path");
 	const fsScandir = require_out$2();
 	var Settings = class {
 		constructor(_options = {}) {
@@ -21411,7 +22269,7 @@ var require_settings$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 			this.deepFilter = this._getValue(this._options.deepFilter, null);
 			this.entryFilter = this._getValue(this._options.entryFilter, null);
 			this.errorFilter = this._getValue(this._options.errorFilter, null);
-			this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$5.sep);
+			this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$4.sep);
 			this.fsScandirSettings = new fsScandir.Settings({
 				followSymbolicLinks: this._options.followSymbolicLinks,
 				fs: this._options.fs,
@@ -21465,7 +22323,7 @@ var require_out$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 //#region node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/readers/reader.js
 var require_reader$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
-	const path$4 = __require("path");
+	const path$3 = __require("path");
 	const fsStat = require_out$3();
 	const utils = require_utils$2();
 	var Reader = class {
@@ -21478,7 +22336,7 @@ var require_reader$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 			});
 		}
 		_getFullEntryPath(filepath) {
-			return path$4.resolve(this._settings.cwd, filepath);
+			return path$3.resolve(this._settings.cwd, filepath);
 		}
 		_makeEntry(stats, pattern) {
 			const entry = {
@@ -21822,7 +22680,7 @@ var require_entry = /* @__PURE__ */ __commonJSMin(((exports) => {
 //#region node_modules/.pnpm/fast-glob@3.3.3/node_modules/fast-glob/out/providers/provider.js
 var require_provider = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
-	const path$3 = __require("path");
+	const path$2 = __require("path");
 	const deep_1 = require_deep();
 	const entry_1 = require_entry$1();
 	const error_1 = require_error();
@@ -21836,7 +22694,7 @@ var require_provider = /* @__PURE__ */ __commonJSMin(((exports) => {
 			this.entryTransformer = new entry_2.default(this._settings);
 		}
 		_getRootDirectory(task) {
-			return path$3.resolve(this._settings.cwd, task.base);
+			return path$2.resolve(this._settings.cwd, task.base);
 		}
 		_getReaderOptions(task) {
 			const basePath = task.base === "." ? "" : task.base;
@@ -22148,16 +23006,36 @@ var require_out = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = FastGlob;
 }));
 
+//#endregion
+//#region ../../packages/local-file-shell/src/file/hasHiddenSegment.ts
+/**
+* Detect whether a glob pattern (or path) contains a dot-prefixed segment such
+* as `.github`, `.husky`, or `foo/.config`. Used to auto-enable hidden-file
+* matching when the caller's intent is clearly to traverse a hidden directory
+* — otherwise `fast-glob` (`dot: false`) and `ripgrep` (no `--hidden`) silently
+* return zero results.
+*
+* Skips `.` and `..` (relative path indicators), which are not hidden segments.
+*/
+const HIDDEN_SEGMENT_RE = /(?:^|\/)\.[^./]/;
+const hasHiddenSegment = (pattern) => !!pattern && HIDDEN_SEGMENT_RE.test(pattern);
+
 //#endregion
 //#region ../../packages/local-file-shell/src/file/glob.ts
 var import_out = /* @__PURE__ */ __toESM$2(require_out());
 async function globLocalFiles({ pattern, cwd }) {
 	try {
-		return { files: await (0, import_out.default)(pattern, {
+		const wantsHidden = hasHiddenSegment(pattern);
+		const files = await (0, import_out.default)(pattern, {
 			cwd: expandTilde(cwd) || process.cwd(),
-			dot: false,
+			dot: wantsHidden,
 			ignore: ["**/node_modules/**", "**/.git/**"]
-		}) };
+		});
+		if (wantsHidden) return {
+			files,
+			hint: `Auto-enabled hidden-file matching because pattern contains a dot-prefixed segment.`
+		};
+		return { files };
 	} catch (error) {
 		return {
 			error: error.message,
@@ -22169,8 +23047,11 @@ async function globLocalFiles({ pattern, cwd }) {
 //#endregion
 //#region ../../packages/local-file-shell/src/file/grep.ts
 async function grepContent({ pattern, cwd, filePattern }) {
+	const wantsHidden = hasHiddenSegment(filePattern);
+	const hint = wantsHidden ? `Auto-enabled hidden-file matching because filePattern contains a dot-prefixed segment.` : void 0;
 	return new Promise((resolve) => {
 		const args = ["--json", "-n"];
+		if (wantsHidden) args.push("--hidden", "--glob", "!**/.git/**");
 		if (filePattern) args.push("--glob", filePattern);
 		args.push(pattern);
 		const child = spawn("rg", args, { cwd: expandTilde(cwd) || process.cwd() });
@@ -22182,6 +23063,7 @@ async function grepContent({ pattern, cwd, filePattern }) {
 		child.on("close", (code) => {
 			if (code !== 0 && code !== 1) {
 				resolve({
+					hint,
 					matches: [],
 					success: false
 				});
@@ -22189,6 +23071,7 @@ async function grepContent({ pattern, cwd, filePattern }) {
 			}
 			try {
 				resolve({
+					hint,
 					matches: stdout.split("\n").filter(Boolean).map((line) => {
 						try {
 							return JSON.parse(line);
@@ -22200,6 +23083,7 @@ async function grepContent({ pattern, cwd, filePattern }) {
 				});
 			} catch {
 				resolve({
+					hint,
 					matches: [],
 					success: true
 				});
@@ -22207,6 +23091,7 @@ async function grepContent({ pattern, cwd, filePattern }) {
 		});
 		child.on("error", () => {
 			resolve({
+				hint,
 				matches: [],
 				success: false
 			});
@@ -22971,6 +23856,120 @@ var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	else module.exports = require_node$1();
 }));
 
+//#endregion
+//#region ../../packages/file-loaders/src/utils/detectUtf16.ts
+const HEURISTIC_SAMPLE_BYTES = 512;
+const HEURISTIC_THRESHOLD = .3;
+/**
+* Detect UTF-16 without BOM by sampling and counting ASCII-shaped code-unit
+* pairs. ASCII chars in UTF-16 produce a 0x00 byte at the high half: at
+* odd index for LE, at even index for BE.
+*
+* Used both by `TextLoader` (to pick the right decoder) and by the binary
+* sniffer (so a UTF-16 text file without BOM isn't mistaken for binary
+* because of its alternating null bytes).
+*/
+const detectUtf16NoBom = (buffer) => {
+	const sample = buffer.subarray(0, Math.min(HEURISTIC_SAMPLE_BYTES, buffer.length));
+	if (sample.length < 4 || sample.length % 2 !== 0) return null;
+	let leAsciiPairs = 0;
+	let beAsciiPairs = 0;
+	const totalPairs = sample.length / 2;
+	for (let i = 0; i < sample.length; i += 2) {
+		const lo = sample[i];
+		const hi = sample[i + 1];
+		if (hi === 0 && lo !== 0) leAsciiPairs++;
+		else if (lo === 0 && hi !== 0) beAsciiPairs++;
+	}
+	if (leAsciiPairs > beAsciiPairs && leAsciiPairs / totalPairs >= HEURISTIC_THRESHOLD) return "utf-16le";
+	if (beAsciiPairs > leAsciiPairs && beAsciiPairs / totalPairs >= HEURISTIC_THRESHOLD) return "utf-16be";
+	return null;
+};
+
+//#endregion
+//#region ../../packages/file-loaders/src/loaders/text/index.ts
+var import_src$5 = /* @__PURE__ */ __toESM$2(require_src());
+const log$6 = (0, import_src$5.default)("file-loaders:text");
+/**
+* Read a text file with automatic encoding detection.
+* Detects UTF-8, UTF-16LE, and UTF-16BE via BOM, with a heuristic fallback
+* for UTF-16 without BOM (common in some Windows exports). Falls back to UTF-8.
+*/
+const readTextFile = async (filePath) => {
+	const buffer = await readFile(filePath);
+	if (buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254) {
+		log$6("Detected UTF-16LE BOM");
+		return new TextDecoder("utf-16le").decode(buffer.subarray(2));
+	}
+	if (buffer.length >= 2 && buffer[0] === 254 && buffer[1] === 255) {
+		log$6("Detected UTF-16BE BOM");
+		return new TextDecoder("utf-16be").decode(buffer.subarray(2));
+	}
+	if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
+		log$6("Detected UTF-8 BOM");
+		return buffer.subarray(3).toString("utf8");
+	}
+	const variant = detectUtf16NoBom(buffer);
+	if (variant) {
+		log$6("Detected %s without BOM (heuristic)", variant);
+		return new TextDecoder(variant).decode(buffer);
+	}
+	return buffer.toString("utf8");
+};
+/**
+* Loader for loading plain text files.
+*/
+var TextLoader = class {
+	async loadPages(filePath) {
+		log$6("Loading text file:", filePath);
+		try {
+			const fileContent = await readTextFile(filePath);
+			log$6("Text file loaded successfully, size:", fileContent.length, "bytes");
+			const lineCount = fileContent.split("\n").length;
+			const charCount = fileContent.length;
+			log$6("Text file stats:", {
+				charCount,
+				lineCount
+			});
+			const page = {
+				charCount,
+				lineCount,
+				metadata: {
+					lineNumberEnd: lineCount,
+					lineNumberStart: 1
+				},
+				pageContent: fileContent
+			};
+			log$6("Text page created successfully");
+			return [page];
+		} catch (e) {
+			const error = e;
+			log$6("Error encountered while loading text file");
+			console.error(`Error loading text file ${filePath}: ${error.message}`);
+			const errorPage = {
+				charCount: 0,
+				lineCount: 0,
+				metadata: { error: `Failed to load text file: ${error.message}` },
+				pageContent: ""
+			};
+			log$6("Created error page for failed text file loading");
+			return [errorPage];
+		}
+	}
+	/**
+	* For plain text, simply concatenate the content of all pages.
+	* (Although TextLoader typically has only one page, this maintains interface consistency)
+	* @param pages Array of pages
+	* @returns Aggregated content
+	*/
+	async aggregateContent(pages) {
+		log$6("Aggregating content from", pages.length, "text pages");
+		const result = pages.map((page) => page.pageContent).join("\n");
+		log$6("Content aggregated successfully, length:", result.length);
+		return result;
+	}
+};
+
 //#endregion
 //#region node_modules/.pnpm/word-extractor@1.0.4/node_modules/word-extractor/lib/ole-header.js
 var require_ole_header = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -27169,7 +28168,7 @@ var require_open_office_extractor = /* @__PURE__ */ __commonJSMin(((exports, mod
 	* Note that [WordOleExtractor]{@link module:word-ole-extractor~WordOleExtractor} is 
 	* used for older, OLE-style, compound document files. 
 	*/
-	const path$2 = __require("path");
+	const path$1 = __require("path");
 	const SAXES = require_saxes();
 	const yauzl = require_yauzl$1();
 	const BufferReader = require_buffer_reader();
@@ -27204,7 +28203,7 @@ var require_open_office_extractor = /* @__PURE__ */ __commonJSMin(((exports, mod
 		}
 		shouldProcess(filename) {
 			if (this._actions[filename]) return true;
-			const extension = path$2.posix.extname(filename).replace(/^\./, "");
+			const extension = path$1.posix.extname(filename).replace(/^\./, "");
 			if (!extension) return false;
 			const defaultType = this._defaults[extension];
 			if (defaultType && this._streamTypes[defaultType]) return true;
@@ -27457,14 +28456,14 @@ var require_word = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../packages/file-loaders/src/loaders/doc/index.ts
 var doc_exports = /* @__PURE__ */ __exportAll({ DocLoader: () => DocLoader });
-var import_src$6, import_word, log$6, DocLoader;
+var import_src$4, import_word, log$5, DocLoader;
 var init_doc = __esmMin((() => {
-	import_src$6 = /* @__PURE__ */ __toESM$2(require_src());
+	import_src$4 = /* @__PURE__ */ __toESM$2(require_src());
 	import_word = /* @__PURE__ */ __toESM$2(require_word());
-	log$6 = (0, import_src$6.default)("file-loaders:doc");
+	log$5 = (0, import_src$4.default)("file-loaders:doc");
 	DocLoader = class {
 		async loadPages(filePath) {
-			log$6("Loading DOC file:", filePath);
+			log$5("Loading DOC file:", filePath);
 			try {
 				const extracted = await new import_word.default().extract(filePath);
 				const pageContent = extracted && typeof extracted.getBody === "function" ? extracted.getBody() : extracted?.text ?? "";
@@ -27475,11 +28474,11 @@ var init_doc = __esmMin((() => {
 					metadata: { pageNumber: 1 },
 					pageContent
 				};
-				log$6("DOC loading completed");
+				log$5("DOC loading completed");
 				return [page];
 			} catch (e) {
 				const error = e;
-				log$6("Error encountered while loading DOC file");
+				log$5("Error encountered while loading DOC file");
 				console.error(`Error loading DOC file ${filePath}: ${error.message}`);
 				return [{
 					charCount: 0,
@@ -27490,7 +28489,7 @@ var init_doc = __esmMin((() => {
 			}
 		}
 		async aggregateContent(pages) {
-			log$6("Aggregating content from", pages.length, "DOC pages");
+			log$5("Aggregating content from", pages.length, "DOC pages");
 			return pages.map((p) => p.pageContent).join("\n\n");
 		}
 	};
@@ -61735,23 +62734,23 @@ var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 //#endregion
 //#region ../../packages/file-loaders/src/loaders/docx/index.ts
 var docx_exports = /* @__PURE__ */ __exportAll({ DocxLoader: () => DocxLoader });
-var import_src$5, import_lib$1, log$5, DocxLoader;
+var import_src$3, import_lib$1, log$4, DocxLoader;
 var init_docx = __esmMin((() => {
-	import_src$5 = /* @__PURE__ */ __toESM$2(require_src());
+	import_src$3 = /* @__PURE__ */ __toESM$2(require_src());
 	import_lib$1 = /* @__PURE__ */ __toESM$2(require_lib$1());
-	log$5 = (0, import_src$5.default)("file-loaders:docx");
+	log$4 = (0, import_src$3.default)("file-loaders:docx");
 	DocxLoader = class {
 		async loadPages(filePath) {
-			log$5("Loading DOCX file:", filePath);
+			log$4("Loading DOCX file:", filePath);
 			try {
 				const buffer = await fs$1.readFile(filePath);
-				log$5("File buffer read, size:", buffer.length);
+				log$4("File buffer read, size:", buffer.length);
 				const result = await import_lib$1.extractRawText({ buffer });
 				const pageContent = result.value;
-				log$5("Text extracted, length:", pageContent.length);
+				log$4("Text extracted, length:", pageContent.length);
 				const lineCount = pageContent.split("\n").length;
 				const charCount = pageContent.length;
-				log$5("DOCX document processed, lines:", lineCount, "chars:", charCount);
+				log$4("DOCX document processed, lines:", lineCount, "chars:", charCount);
 				const page = {
 					charCount,
 					lineCount,
@@ -61761,15 +62760,15 @@ var init_docx = __esmMin((() => {
 				if (result.messages.length > 0) {
 					const warnings = result.messages.filter((msg) => msg.type === "warning");
 					if (warnings.length > 0) {
-						log$5("Extraction warnings:", warnings.length);
-						warnings.forEach((warning) => log$5("Warning:", warning.message));
+						log$4("Extraction warnings:", warnings.length);
+						warnings.forEach((warning) => log$4("Warning:", warning.message));
 					}
 				}
-				log$5("DOCX loading completed");
+				log$4("DOCX loading completed");
 				return [page];
 			} catch (e) {
 				const error = e;
-				log$5("Error encountered while loading DOCX file");
+				log$4("Error encountered while loading DOCX file");
 				console.error(`Error loading DOCX file ${filePath}: ${error.message}`);
 				const errorPage = {
 					charCount: 0,
@@ -61777,7 +62776,7 @@ var init_docx = __esmMin((() => {
 					metadata: { error: `Failed to load DOCX file: ${error.message}` },
 					pageContent: ""
 				};
-				log$5("Created error page for failed DOCX loading");
+				log$4("Created error page for failed DOCX loading");
 				return [errorPage];
 			}
 		}
@@ -61788,9 +62787,9 @@ var init_docx = __esmMin((() => {
 		* @returns Aggregated content as a string.
 		*/
 		async aggregateContent(pages) {
-			log$5("Aggregating content from", pages.length, "DOCX pages");
+			log$4("Aggregating content from", pages.length, "DOCX pages");
 			const result = pages.map((page) => page.pageContent).join("\n\n");
-			log$5("DOCX content aggregated successfully, length:", result.length);
+			log$4("DOCX content aggregated successfully, length:", result.length);
 			return result;
 		}
 	};
@@ -85153,68 +86152,68 @@ var excel_exports = /* @__PURE__ */ __exportAll({ ExcelLoader: () => ExcelLoader
 * Handles empty sheets and escapes pipe characters.
 */
 function sheetToMarkdownTable(jsonData) {
-	log$4("Converting sheet data to Markdown table, rows:", jsonData?.length || 0);
+	log$3("Converting sheet data to Markdown table, rows:", jsonData?.length || 0);
 	if (!jsonData || jsonData.length === 0) {
-		log$4("Sheet is empty, returning placeholder message");
+		log$3("Sheet is empty, returning placeholder message");
 		return "*Sheet is empty or contains no data.*";
 	}
 	const headers = Object.keys(jsonData[0] || {});
-	log$4("Sheet headers:", headers);
+	log$3("Sheet headers:", headers);
 	if (headers.length === 0) {
-		log$4("Sheet has no headers, returning placeholder message");
+		log$3("Sheet has no headers, returning placeholder message");
 		return "*Sheet has headers but no data.*";
 	}
 	const headerRow = `| ${headers.join(" | ")} |`;
 	const separatorRow = `| ${headers.map(() => "---").join(" | ")} |`;
-	log$4("Building data rows for Markdown table");
+	log$3("Building data rows for Markdown table");
 	const result = `${headerRow}\n${separatorRow}\n${jsonData.map((row) => {
 		return `| ${headers.map((header) => {
 			const value = row[header];
 			return (value === null || value === void 0 ? "" : String(value).replaceAll("|", "\\|")).trim();
 		}).join(" | ")} |`;
 	}).join("\n")}`;
-	log$4("Markdown table created, length:", result.length);
+	log$3("Markdown table created, length:", result.length);
 	return result;
 }
-var import_src$4, log$4, ExcelLoader;
+var import_src$2, log$3, ExcelLoader;
 var init_excel = __esmMin((() => {
-	import_src$4 = /* @__PURE__ */ __toESM$2(require_src());
+	import_src$2 = /* @__PURE__ */ __toESM$2(require_src());
 	init_xlsx();
 	init_prompt$1();
-	log$4 = (0, import_src$4.default)("file-loaders:excel");
+	log$3 = (0, import_src$2.default)("file-loaders:excel");
 	ExcelLoader = class {
 		async loadPages(filePath) {
-			log$4("Loading Excel file:", filePath);
+			log$3("Loading Excel file:", filePath);
 			const pages = [];
 			try {
-				log$4("Reading Excel file as buffer");
+				log$3("Reading Excel file as buffer");
 				const dataBuffer = await readFile(filePath);
-				log$4("Excel file read successfully, size:", dataBuffer.length, "bytes");
-				log$4("Parsing Excel workbook");
+				log$3("Excel file read successfully, size:", dataBuffer.length, "bytes");
+				log$3("Parsing Excel workbook");
 				const workbook = readSync(dataBuffer, { type: "buffer" });
-				log$4("Excel workbook parsed successfully, sheets:", workbook.SheetNames.length);
+				log$3("Excel workbook parsed successfully, sheets:", workbook.SheetNames.length);
 				for (const sheetName of workbook.SheetNames) {
-					log$4(`Processing sheet: ${sheetName}`);
+					log$3(`Processing sheet: ${sheetName}`);
 					const worksheet = workbook.Sheets[sheetName];
 					const jsonData = utils.sheet_to_json(worksheet, {
 						defval: "",
 						raw: false
 					});
-					log$4(`Sheet ${sheetName} converted to JSON, rows:`, jsonData.length);
+					log$3(`Sheet ${sheetName} converted to JSON, rows:`, jsonData.length);
 					const tableMarkdown = sheetToMarkdownTable(jsonData);
 					const lineCount = tableMarkdown.split("\n").length;
 					const charCount = tableMarkdown.length;
-					log$4(`Sheet ${sheetName} converted to Markdown, lines: ${lineCount}, chars: ${charCount}`);
+					log$3(`Sheet ${sheetName} converted to Markdown, lines: ${lineCount}, chars: ${charCount}`);
 					pages.push({
 						charCount,
 						lineCount,
 						metadata: { sheetName },
 						pageContent: tableMarkdown.trim()
 					});
-					log$4(`Added sheet ${sheetName} as page`);
+					log$3(`Added sheet ${sheetName} as page`);
 				}
 				if (pages.length === 0) {
-					log$4("Excel file contains no sheets, creating empty page with error");
+					log$3("Excel file contains no sheets, creating empty page with error");
 					pages.push({
 						charCount: 0,
 						lineCount: 0,
@@ -85222,11 +86221,11 @@ var init_excel = __esmMin((() => {
 						pageContent: ""
 					});
 				}
-				log$4("Excel loading completed, total pages:", pages.length);
+				log$3("Excel loading completed, total pages:", pages.length);
 				return pages;
 			} catch (e) {
 				const error = e;
-				log$4("Error encountered while loading Excel file");
+				log$3("Error encountered while loading Excel file");
 				console.error(`Error loading Excel file ${filePath}: ${error.message}`);
 				const errorPage = {
 					charCount: 0,
@@ -85234,7 +86233,7 @@ var init_excel = __esmMin((() => {
 					metadata: { error: `Failed to load Excel file: ${error.message}` },
 					pageContent: ""
 				};
-				log$4("Created error page for failed Excel loading");
+				log$3("Created error page for failed Excel loading");
 				return [errorPage];
 			}
 		}
@@ -85245,9 +86244,9 @@ var init_excel = __esmMin((() => {
 		* @returns Aggregated content as a string.
 		*/
 		async aggregateContent(pages) {
-			log$4("Aggregating content from", pages.length, "Excel pages");
+			log$3("Aggregating content from", pages.length, "Excel pages");
 			const result = promptTemplate$1(pages);
-			log$4("Excel content aggregated successfully, length:", result.length);
+			log$3("Excel content aggregated successfully, length:", result.length);
 			return result;
 		}
 	};
@@ -193505,40 +194504,40 @@ ${page.pageContent}
 //#endregion
 //#region ../../packages/file-loaders/src/loaders/pdf/index.ts
 var pdf_exports = /* @__PURE__ */ __exportAll({ PdfLoader: () => PdfLoader });
-var import_src$3, log$3, PdfLoader;
+var import_src$1, log$2, PdfLoader;
 var init_pdf = __esmMin((() => {
-	import_src$3 = /* @__PURE__ */ __toESM$2(require_src());
+	import_src$1 = /* @__PURE__ */ __toESM$2(require_src());
 	init_pdf$1();
 	init_pdf_worker();
 	init_prompt();
-	log$3 = (0, import_src$3.default)("file-loaders:pdf");
+	log$2 = (0, import_src$1.default)("file-loaders:pdf");
 	PdfLoader = class {
 		pdfInstance = null;
 		pdfjsWorker = pdf_worker_exports;
 		async getPDFFile(filePath) {
-			log$3("Reading PDF file:", filePath);
+			log$2("Reading PDF file:", filePath);
 			const dataBuffer = await readFile(filePath);
-			log$3("PDF file read successfully, size:", dataBuffer.length, "bytes");
+			log$2("PDF file read successfully, size:", dataBuffer.length, "bytes");
 			const loadingTask = getDocument({
 				data: new Uint8Array(dataBuffer.buffer, dataBuffer.byteOffset, dataBuffer.length),
 				useSystemFonts: true
 			});
-			log$3("PDF document loading task created");
+			log$2("PDF document loading task created");
 			const pdf = await loadingTask.promise;
-			log$3("PDF document loaded successfully, pages:", pdf.numPages);
+			log$2("PDF document loaded successfully, pages:", pdf.numPages);
 			return pdf;
 		}
 		async loadPages(filePath) {
-			log$3("Starting to load PDF pages from:", filePath);
+			log$2("Starting to load PDF pages from:", filePath);
 			try {
 				const pdf = await this.getPDFFile(filePath);
 				const pages = [];
-				log$3(`Processing ${pdf.numPages} PDF pages`);
+				log$2(`Processing ${pdf.numPages} PDF pages`);
 				for (let i = 1; i <= pdf.numPages; i += 1) {
-					log$3(`Loading page ${i}/${pdf.numPages}`);
+					log$2(`Loading page ${i}/${pdf.numPages}`);
 					const page = await pdf.getPage(i);
 					const content = await page.getTextContent();
-					log$3(`Page ${i} text content retrieved, items:`, content.items.length);
+					log$2(`Page ${i} text content retrieved, items:`, content.items.length);
 					let lastY;
 					const textItems = [];
 					for (const item of content.items) if ("str" in item) {
@@ -193549,23 +194548,23 @@ var init_pdf = __esmMin((() => {
 					const cleanedPageContent = textItems.join("").replaceAll("\0", "");
 					const lineCount = cleanedPageContent.split("\n").length;
 					const charCount = cleanedPageContent.length;
-					log$3(`Page ${i} processed, lines: ${lineCount}, chars: ${charCount}`);
+					log$2(`Page ${i} processed, lines: ${lineCount}, chars: ${charCount}`);
 					pages.push({
 						charCount,
 						lineCount,
 						metadata: { pageNumber: i },
 						pageContent: cleanedPageContent
 					});
-					log$3(`Cleaning up page ${i} resources`);
+					log$2(`Cleaning up page ${i} resources`);
 					page.cleanup();
 				}
-				log$3("Cleaning up PDF document resources");
+				log$2("Cleaning up PDF document resources");
 				await pdf.destroy();
-				log$3(`PDF loading completed for ${filePath}, total pages:`, pages.length);
+				log$2(`PDF loading completed for ${filePath}, total pages:`, pages.length);
 				return pages;
 			} catch (e) {
 				const error = e;
-				log$3("Error encountered while loading PDF file");
+				log$2("Error encountered while loading PDF file");
 				console.error(`Error loading PDF file ${filePath} using pdfjs-dist: ${error.message}`, error.stack);
 				const errorPage = {
 					charCount: 0,
@@ -193576,7 +194575,7 @@ var init_pdf = __esmMin((() => {
 					},
 					pageContent: ""
 				};
-				log$3("Created error page for failed PDF loading");
+				log$2("Created error page for failed PDF loading");
 				return [errorPage];
 			}
 		}
@@ -193587,25 +194586,25 @@ var init_pdf = __esmMin((() => {
 		* @returns Aggregated content as a string.
 		*/
 		async aggregateContent(pages) {
-			log$3("Aggregating content from", pages.length, "PDF pages");
+			log$2("Aggregating content from", pages.length, "PDF pages");
 			const validPages = pages.filter((page) => !page.metadata.error);
-			log$3(`Found ${validPages.length} valid pages for aggregation (${pages.length - validPages.length} pages with errors filtered out)`);
+			log$2(`Found ${validPages.length} valid pages for aggregation (${pages.length - validPages.length} pages with errors filtered out)`);
 			const result = promptTemplate(validPages);
-			log$3("PDF content aggregated successfully, length:", result.length);
+			log$2("PDF content aggregated successfully, length:", result.length);
 			return result;
 		}
 		async attachDocumentMetadata(filePath) {
-			log$3("Attaching document metadata for PDF:", filePath);
+			log$2("Attaching document metadata for PDF:", filePath);
 			const pdf = await this.getPDFFile(filePath);
-			log$3("Getting PDF metadata");
+			log$2("Getting PDF metadata");
 			const pdfMetadata = await pdf.getMetadata().catch((err) => {
-				log$3("Error retrieving PDF metadata");
+				log$2("Error retrieving PDF metadata");
 				console.error(`Error getting PDF metadata: ${err.message}`);
 				return null;
 			}) ?? null;
 			const pdfInfo = pdfMetadata?.info ?? {};
 			const metadata = pdfMetadata?.metadata ?? null;
-			log$3("PDF metadata retrieved:", {
+			log$2("PDF metadata retrieved:", {
 				hasInfo: !!Object.keys(pdfInfo).length,
 				hasMetadata: !!metadata
 			});
@@ -204656,11 +205655,11 @@ var init_parser_utils = __esmMin((() => {
 //#endregion
 //#region ../../packages/file-loaders/src/loaders/pptx/index.ts
 var pptx_exports = /* @__PURE__ */ __exportAll({ PptxLoader: () => PptxLoader });
-var import_src$2, log$2, PptxLoader;
+var import_src, log$1, PptxLoader;
 var init_pptx = __esmMin((() => {
-	import_src$2 = /* @__PURE__ */ __toESM$2(require_src());
+	import_src = /* @__PURE__ */ __toESM$2(require_src());
 	init_parser_utils();
-	log$2 = (0, import_src$2.default)("file-loaders:pptx");
+	log$1 = (0, import_src.default)("file-loaders:pptx");
 	PptxLoader = class {
 		/**
 		* Loads pages from the specified PPTX file path.
@@ -204671,33 +205670,33 @@ var init_pptx = __esmMin((() => {
 		*          `DocumentPage` object with error information in its metadata.
 		*/
 		async loadPages(filePath) {
-			log$2("Loading PPTX file:", filePath);
+			log$1("Loading PPTX file:", filePath);
 			const sourceFileName = path.basename(filePath);
-			log$2("Source file name:", sourceFileName);
+			log$1("Source file name:", sourceFileName);
 			try {
 				const slidesRegex = /ppt\/slides\/slide\d+\.xml/g;
 				const slideNumberRegex = /slide(\d+)\.xml/;
-				log$2("Extracting slide XML files from PPTX");
+				log$1("Extracting slide XML files from PPTX");
 				const slideFiles = await extractFiles(filePath, (fileName) => slidesRegex.test(fileName));
-				log$2("Extracted slide files:", slideFiles.length);
+				log$1("Extracted slide files:", slideFiles.length);
 				if (slideFiles.length === 0) {
-					log$2("No slide XML files found in the PPTX file");
+					log$1("No slide XML files found in the PPTX file");
 					console.warn(`No slide XML files found in ${sourceFileName}. May be corrupted or empty.`);
 					return [this.createErrorPage("No slides found. The PPTX file might be empty, corrupted, or does not contain standard slide XMLs.", sourceFileName)];
 				}
-				log$2("Sorting slide files by slide number");
+				log$1("Sorting slide files by slide number");
 				slideFiles.sort((a, b) => {
 					const matchA = a.path.match(slideNumberRegex);
 					const matchB = b.path.match(slideNumberRegex);
 					return (matchA ? parseInt(matchA[1], 10) : Infinity) - (matchB ? parseInt(matchB[1], 10) : Infinity);
 				});
-				log$2("Slide files sorted");
-				log$2("Creating document pages from slide files");
+				log$1("Slide files sorted");
+				log$1("Creating document pages from slide files");
 				const pages = slideFiles.map((slideFile, index) => {
 					try {
-						log$2(`Processing slide ${index + 1}/${slideFiles.length}, path: ${slideFile.path}`);
+						log$1(`Processing slide ${index + 1}/${slideFiles.length}, path: ${slideFile.path}`);
 						const paragraphNodes = parseString(slideFile.content).getElementsByTagName("a:p");
-						log$2(`Found ${paragraphNodes.length} paragraph nodes in slide ${index + 1}`);
+						log$1(`Found ${paragraphNodes.length} paragraph nodes in slide ${index + 1}`);
 						const slideText = Array.from(paragraphNodes).map((pNode) => {
 							const textNodes = pNode.getElementsByTagName("a:t");
 							return Array.from(textNodes).map((tNode) => tNode.childNodes[0] ? tNode.childNodes[0].nodeValue : "").join("");
@@ -204705,7 +205704,7 @@ var init_pptx = __esmMin((() => {
 						const lines = slideText.split("\n");
 						const slideNumberMatch = slideFile.path.match(slideNumberRegex);
 						const slideNumber = slideNumberMatch ? parseInt(slideNumberMatch[1], 10) : index + 1;
-						log$2(`Slide ${index + 1} text extracted, lines: ${lines.length}, characters: ${slideText.length}`);
+						log$1(`Slide ${index + 1} text extracted, lines: ${lines.length}, characters: ${slideText.length}`);
 						const metadata = {
 							pageCount: slideFiles.length,
 							slideNumber,
@@ -204718,26 +205717,26 @@ var init_pptx = __esmMin((() => {
 							pageContent: slideText.trim()
 						};
 					} catch (parseError) {
-						log$2(`Error parsing slide ${slideFile.path}`);
+						log$1(`Error parsing slide ${slideFile.path}`);
 						console.error(`Failed to parse XML for slide ${slideFile.path} in ${sourceFileName}: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
 						return this.createErrorPage(`Error parsing slide ${slideFile.path}: ${parseError instanceof Error ? parseError.message : String(parseError)}`, sourceFileName, slideFile.path);
 					}
 				}).filter((page) => page !== null);
-				log$2(`Created ${pages.length} document pages from slides`);
+				log$1(`Created ${pages.length} document pages from slides`);
 				if (pages.length === 0) {
-					log$2("Parsing resulted in zero valid pages");
+					log$1("Parsing resulted in zero valid pages");
 					console.warn(`Parsing resulted in zero valid pages for ${sourceFileName}`);
 					return [this.createErrorPage("Parsing resulted in zero valid pages.", sourceFileName)];
 				}
 				if (pages.every((page) => page.metadata?.error)) {
-					log$2("All slides failed to parse");
+					log$1("All slides failed to parse");
 					console.warn(`All slides failed to parse for ${sourceFileName}`);
 					return [this.createErrorPage("All slides failed to parse correctly.", sourceFileName)];
 				}
-				log$2("PPTX loading completed successfully");
+				log$1("PPTX loading completed successfully");
 				return pages;
 			} catch (error) {
-				log$2("Error loading or processing PPTX file");
+				log$1("Error loading or processing PPTX file");
 				const errorMessage = `Failed to load or process PPTX file: ${error instanceof Error ? error.message : String(error)}`;
 				console.error(errorMessage, { filePath });
 				return [this.createErrorPage(errorMessage, sourceFileName)];
@@ -204753,11 +205752,11 @@ var init_pptx = __esmMin((() => {
 		* @returns A Promise resolving to the aggregated content string.
 		*/
 		async aggregateContent(pages) {
-			log$2("Aggregating content from", pages.length, "PPTX pages");
+			log$1("Aggregating content from", pages.length, "PPTX pages");
 			const validPages = pages.filter((page) => !page.metadata?.error);
-			log$2(`Found ${validPages.length} valid pages for aggregation (${pages.length - validPages.length} error pages filtered out)`);
+			log$1(`Found ${validPages.length} valid pages for aggregation (${pages.length - validPages.length} error pages filtered out)`);
 			if (validPages.length === 0) {
-				log$2("No valid pages found, returning content of first page (may be error page)");
+				log$1("No valid pages found, returning content of first page (may be error page)");
 				return pages[0]?.pageContent || "";
 			}
 			const result = validPages.map((page) => {
@@ -204766,7 +205765,7 @@ var init_pptx = __esmMin((() => {
 ${page.pageContent}
 </slide_page>`;
 			}).join("\n\n");
-			log$2("PPTX content aggregated successfully, length:", result.length);
+			log$1("PPTX content aggregated successfully, length:", result.length);
 			return result;
 		}
 		/**
@@ -204778,7 +205777,7 @@ ${page.pageContent}
 		* @returns A `DocumentPage` object representing the error state.
 		*/
 		createErrorPage(errorInfo, sourceFileName, sourceFilePath) {
-			log$2("Creating error page:", errorInfo);
+			log$1("Creating error page:", errorInfo);
 			return {
 				charCount: 0,
 				lineCount: 0,
@@ -204794,104 +205793,6 @@ ${page.pageContent}
 	};
 }));
 
-//#endregion
-//#region ../../packages/file-loaders/src/loaders/text/index.ts
-var text_exports = /* @__PURE__ */ __exportAll({ TextLoader: () => TextLoader });
-var import_src$1, log$1, HEURISTIC_SAMPLE_BYTES, HEURISTIC_THRESHOLD, detectUtf16NoBom, readTextFile, TextLoader;
-var init_text = __esmMin((() => {
-	import_src$1 = /* @__PURE__ */ __toESM$2(require_src());
-	log$1 = (0, import_src$1.default)("file-loaders:text");
-	HEURISTIC_SAMPLE_BYTES = 512;
-	HEURISTIC_THRESHOLD = .3;
-	detectUtf16NoBom = (buffer) => {
-		const sample = buffer.subarray(0, Math.min(HEURISTIC_SAMPLE_BYTES, buffer.length));
-		if (sample.length < 4 || sample.length % 2 !== 0) return null;
-		let leAsciiPairs = 0;
-		let beAsciiPairs = 0;
-		const totalPairs = sample.length / 2;
-		for (let i = 0; i < sample.length; i += 2) {
-			const lo = sample[i];
-			const hi = sample[i + 1];
-			if (hi === 0 && lo !== 0) leAsciiPairs++;
-			else if (lo === 0 && hi !== 0) beAsciiPairs++;
-		}
-		if (leAsciiPairs > beAsciiPairs && leAsciiPairs / totalPairs >= HEURISTIC_THRESHOLD) return "utf-16le";
-		if (beAsciiPairs > leAsciiPairs && beAsciiPairs / totalPairs >= HEURISTIC_THRESHOLD) return "utf-16be";
-		return null;
-	};
-	readTextFile = async (filePath) => {
-		const buffer = await readFile(filePath);
-		if (buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254) {
-			log$1("Detected UTF-16LE BOM");
-			return new TextDecoder("utf-16le").decode(buffer.subarray(2));
-		}
-		if (buffer.length >= 2 && buffer[0] === 254 && buffer[1] === 255) {
-			log$1("Detected UTF-16BE BOM");
-			return new TextDecoder("utf-16be").decode(buffer.subarray(2));
-		}
-		if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
-			log$1("Detected UTF-8 BOM");
-			return buffer.subarray(3).toString("utf8");
-		}
-		const variant = detectUtf16NoBom(buffer);
-		if (variant) {
-			log$1("Detected %s without BOM (heuristic)", variant);
-			return new TextDecoder(variant).decode(buffer);
-		}
-		return buffer.toString("utf8");
-	};
-	TextLoader = class {
-		async loadPages(filePath) {
-			log$1("Loading text file:", filePath);
-			try {
-				const fileContent = await readTextFile(filePath);
-				log$1("Text file loaded successfully, size:", fileContent.length, "bytes");
-				const lineCount = fileContent.split("\n").length;
-				const charCount = fileContent.length;
-				log$1("Text file stats:", {
-					charCount,
-					lineCount
-				});
-				const page = {
-					charCount,
-					lineCount,
-					metadata: {
-						lineNumberEnd: lineCount,
-						lineNumberStart: 1
-					},
-					pageContent: fileContent
-				};
-				log$1("Text page created successfully");
-				return [page];
-			} catch (e) {
-				const error = e;
-				log$1("Error encountered while loading text file");
-				console.error(`Error loading text file ${filePath}: ${error.message}`);
-				const errorPage = {
-					charCount: 0,
-					lineCount: 0,
-					metadata: { error: `Failed to load text file: ${error.message}` },
-					pageContent: ""
-				};
-				log$1("Created error page for failed text file loading");
-				return [errorPage];
-			}
-		}
-		/**
-		* For plain text, simply concatenate the content of all pages.
-		* (Although TextLoader typically has only one page, this maintains interface consistency)
-		* @param pages Array of pages
-		* @returns Aggregated content
-		*/
-		async aggregateContent(pages) {
-			log$1("Aggregating content from", pages.length, "text pages");
-			const result = pages.map((page) => page.pageContent).join("\n");
-			log$1("Content aggregated successfully, length:", result.length);
-			return result;
-		}
-	};
-}));
-
 //#endregion
 //#region ../../packages/file-loaders/src/loaders/index.ts
 const lazyFileLoaders = {
@@ -204923,23 +205824,18 @@ const lazyFileLoaders = {
 	pptx: async () => {
 		const { PptxLoader } = await Promise.resolve().then(() => (init_pptx(), pptx_exports));
 		return PptxLoader;
-	},
-	txt: async () => {
-		const { TextLoader } = await Promise.resolve().then(() => (init_text(), text_exports));
-		return TextLoader;
 	}
 };
 /**
 * Get a file loader class for the specified file type.
 * Uses dynamic imports to avoid loading heavy dependencies (like pdfjs-dist) until needed.
-* Falls back to TextLoader if no specific loader is found.
+* TextLoader is returned synchronously (statically imported) for `txt` and as the
+* fallback for unknown types.
 */
 const getFileLoader = async (fileType) => {
+	if (fileType === "txt") return TextLoader;
 	const loaderFactory = lazyFileLoaders[fileType];
-	if (!loaderFactory) {
-		const { TextLoader } = await Promise.resolve().then(() => (init_text(), text_exports));
-		return TextLoader;
-	}
+	if (!loaderFactory) return TextLoader;
 	return loaderFactory();
 };
 
@@ -204951,6 +205847,8 @@ const TEXT_READABLE_FILE_TYPES = [
 	"markdown",
 	"mdx",
 	"json",
+	"jsonc",
+	"json5",
 	"xml",
 	"yaml",
 	"yml",
@@ -204959,6 +205857,8 @@ const TEXT_READABLE_FILE_TYPES = [
 	"cfg",
 	"conf",
 	"csv",
+	"env",
+	"properties",
 	"html",
 	"htm",
 	"css",
@@ -204969,6 +205869,9 @@ const TEXT_READABLE_FILE_TYPES = [
 	"ts",
 	"tsx",
 	"mjs",
+	"cjs",
+	"mts",
+	"cts",
 	"vue",
 	"svelte",
 	"svg",
@@ -204989,6 +205892,11 @@ const TEXT_READABLE_FILE_TYPES = [
 	"bash",
 	"bat",
 	"ps1",
+	"lua",
+	"dart",
+	"scala",
+	"groovy",
+	"gradle",
 	"log",
 	"sql",
 	"patch",
@@ -204996,6 +205904,18 @@ const TEXT_READABLE_FILE_TYPES = [
 	"db"
 ];
 /**
+* Extensions that have dedicated parsers in `loadFile`. These are not text but
+* are explicitly supported file types that we know how to extract text from.
+*/
+const SPECIAL_PARSED_FILE_TYPES = [
+	"pdf",
+	"doc",
+	"docx",
+	"xls",
+	"xlsx",
+	"pptx"
+];
+/**
 * Determine if a file can be read as text based on its extension.
 * @param fileType File extension (without the leading dot)
 * @returns Whether the file is likely text-readable
@@ -205003,11 +205923,29 @@ const TEXT_READABLE_FILE_TYPES = [
 function isTextReadableFile(fileType) {
 	return TEXT_READABLE_FILE_TYPES.includes(fileType.toLowerCase());
 }
+/**
+* Whether the agent's `readFile` should be willing to attempt reading this
+* extension at all. True for known text formats and for the special parsed
+* binary formats (pdf/doc/etc.) that have dedicated loaders. Anything else —
+* `.bin`, `.zip`, `.b64`, `.exe`, … — should be hard-rejected before the file
+* is opened, to avoid feeding a binary blob to the LLM.
+*/
+function isReadableFileType(fileType) {
+	const ext = fileType.toLowerCase();
+	return TEXT_READABLE_FILE_TYPES.includes(ext) || SPECIAL_PARSED_FILE_TYPES.includes(ext);
+}
 
 //#endregion
 //#region ../../packages/file-loaders/src/loadFile.ts
-var import_src = /* @__PURE__ */ __toESM$2(require_src());
-const log = (0, import_src.default)("file-loaders:loadFile");
+const log = (0, import_src$5.default)("file-loaders:loadFile");
+var UnsupportedFileTypeError = class extends Error {
+	fileType;
+	constructor(fileType, filename) {
+		super(`Unsupported file type '${fileType || "unknown"}' for file '${filename}'.`);
+		this.name = "UnsupportedFileTypeError";
+		this.fileType = fileType;
+	}
+};
 /**
 * Determines the file type based on the filename extension.
 * @param filePath The path to the file.
@@ -205015,7 +205953,7 @@ const log = (0, import_src.default)("file-loaders:loadFile");
 */
 const getFileType = (filePath) => {
 	log("Determining file type for:", filePath);
-	const extension = path$1.extname(filePath).toLowerCase().replace(".", "");
+	const extension = path.extname(filePath).toLowerCase().replace(".", "");
 	if (!extension) {
 		log("No extension found, treating as txt");
 		return "txt";
@@ -205070,8 +206008,8 @@ const loadFile = async (filePath, fileMetadata) => {
 		fsError = `Failed to access file stats: ${error.message}`;
 	}
 	log("Determining base file info");
-	const fileExtension = path$1.extname(filePath).slice(1).toLowerCase();
-	const baseFilename = path$1.basename(filePath);
+	const fileExtension = path.extname(filePath).slice(1).toLowerCase();
+	const baseFilename = path.basename(filePath);
 	const source = fileMetadata?.source ?? filePath;
 	const filename = fileMetadata?.filename ?? baseFilename;
 	const fileType = fileMetadata?.fileType ?? fileExtension;
@@ -205086,10 +206024,13 @@ const loadFile = async (filePath, fileMetadata) => {
 	});
 	const parserType = getFileType(filePath);
 	log("Parser type determined as:", parserType);
+	if (!parserType && !fsError) {
+		console.warn(`No specific loader found for file type '${fileType}'. Rejecting unsupported file type.`);
+		throw new UnsupportedFileTypeError(fileType, filename);
+	}
 	const LoaderClass = await getFileLoader(parserType ?? "txt");
 	log("Selected loader class:", LoaderClass.name);
-	if (!parserType) console.warn(`No specific loader found for file type '${fileType}'. Using default loader (TextLoader) as fallback.`);
-	let pages = [];
+	let pages;
 	let aggregatedContent = "";
 	let loaderError;
 	let aggregationError;
@@ -205187,6 +206128,69 @@ const loadFile = async (filePath, fileMetadata) => {
 	return fileDocument;
 };
 
+//#endregion
+//#region ../../packages/file-loaders/src/utils/isBinaryContent.ts
+const SNIFF_BYTES = 8192;
+const NON_PRINTABLE_THRESHOLD = .3;
+const hasUtf8Bom = (buf) => buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191;
+const hasUtf16Bom = (buf) => buf.length >= 2 && (buf[0] === 255 && buf[1] === 254 || buf[0] === 254 && buf[1] === 255);
+/**
+* Heuristically determine if a buffer looks like binary data.
+*
+* - UTF-8 / UTF-16 BOM → text
+* - UTF-16 detected without BOM (Windows-style exports) → text, decoded for
+*   the printable-ratio check
+* - Any null byte (and not UTF-16) → binary
+* - More than 30% of decoded chars are control or U+FFFD replacement → binary
+*
+* Note: this only catches truly binary content. Text-encoded blobs (e.g., a
+* single 27KB line of base64) will pass this check — the extension whitelist
+* and the post-load char cap are what stop those.
+*/
+const sniffBinaryBuffer = (buffer) => {
+	if (buffer.length === 0) return { isBinary: false };
+	if (hasUtf8Bom(buffer) || hasUtf16Bom(buffer)) return { isBinary: false };
+	const utf16Variant = detectUtf16NoBom(buffer);
+	if (utf16Variant) return checkPrintableRatio(new TextDecoder(utf16Variant, { fatal: false }).decode(buffer), buffer.length);
+	if (buffer.includes(0)) return {
+		isBinary: true,
+		reason: "contains null byte"
+	};
+	return checkPrintableRatio(new TextDecoder("utf-8", { fatal: false }).decode(buffer), buffer.length);
+};
+const REPLACEMENT_CHAR = "�";
+const checkPrintableRatio = (text, sampledBytes) => {
+	if (text.length === 0) return { isBinary: false };
+	let suspect = 0;
+	for (const ch of text) {
+		if (ch === REPLACEMENT_CHAR) {
+			suspect++;
+			continue;
+		}
+		const code = ch.codePointAt(0);
+		if (code < 32 && code !== 9 && code !== 10 && code !== 13) suspect++;
+	}
+	const ratio = suspect / text.length;
+	if (ratio > NON_PRINTABLE_THRESHOLD) return {
+		isBinary: true,
+		reason: `${(ratio * 100).toFixed(1)}% non-printable chars in first ${sampledBytes} bytes`
+	};
+	return { isBinary: false };
+};
+/**
+* Read up to the leading 8KB of a file and run the binary heuristic on it.
+*/
+const sniffBinaryFile = async (filePath) => {
+	const fd = await open(filePath, "r");
+	try {
+		const buffer = Buffer.alloc(SNIFF_BYTES);
+		const { bytesRead } = await fd.read(buffer, 0, SNIFF_BYTES, 0);
+		return sniffBinaryBuffer(buffer.subarray(0, bytesRead));
+	} finally {
+		await fd.close();
+	}
+};
+
 //#endregion
 //#region ../../packages/local-file-shell/src/file/list.ts
 async function listLocalFiles({ path: rawPath, sortBy = "modifiedTime", sortOrder = "desc", limit = 100 }, options) {
@@ -205247,9 +206251,52 @@ async function listLocalFiles({ path: rawPath, sortBy = "modifiedTime", sortOrde
 
 //#endregion
 //#region ../../packages/local-file-shell/src/file/read.ts
+/** Hard cap on file size we will read into memory at all (10MB). */
+const MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
+/** Cap on the total chars returned to the agent. */
+const MAX_OUTPUT_CHARS = 5e5;
+/** Cap on chars per line. Keeps a single 27KB base64 line from blowing up the response. */
+const MAX_LINE_CHARS = 8e3;
+const inferFileType = (filePath) => path.extname(filePath).toLowerCase().replace(".", "") || "unknown";
+const buildErrorResult = (filePath, message) => ({
+	charCount: 0,
+	content: message,
+	createdTime: /* @__PURE__ */ new Date(),
+	fileType: inferFileType(filePath),
+	filename: path.basename(filePath),
+	lineCount: 0,
+	loc: [0, 0],
+	modifiedTime: /* @__PURE__ */ new Date(),
+	totalCharCount: 0,
+	totalLineCount: 0
+});
+const truncateLine = (line) => {
+	if (line.length <= MAX_LINE_CHARS) return {
+		line,
+		truncated: false
+	};
+	return {
+		line: `${line.slice(0, MAX_LINE_CHARS)}… [line truncated: was ${line.length} chars, kept first ${MAX_LINE_CHARS}]`,
+		truncated: true
+	};
+};
 async function readLocalFile({ path: rawPath, loc, fullContent }) {
 	const filePath = expandTilde(rawPath) ?? rawPath;
 	const effectiveLoc = fullContent ? void 0 : loc ?? [0, 200];
+	let stats;
+	try {
+		stats = await stat(filePath);
+	} catch (error) {
+		return buildErrorResult(filePath, `Error accessing or processing file: ${error.message}`);
+	}
+	if (stats.isDirectory()) return buildErrorResult(filePath, "This is a directory and cannot be read as plain text.");
+	if (stats.size > MAX_FILE_SIZE_BYTES) return buildErrorResult(filePath, `Error: File is too large to read (${stats.size} bytes, limit ${MAX_FILE_SIZE_BYTES}). Use grep / shell tools to inspect specific parts.`);
+	const extension = path.extname(filePath).toLowerCase().replace(".", "");
+	if (extension && !isReadableFileType(extension)) return buildErrorResult(filePath, `Error: Unsupported binary file type: .${extension}. Use a different tool (e.g., 'runCommand' with file/hexdump/strings) to inspect binary files.`);
+	if (!SPECIAL_PARSED_FILE_TYPES.includes(extension)) try {
+		const sniff = await sniffBinaryFile(filePath);
+		if (sniff.isBinary) return buildErrorResult(filePath, `Error: File appears to be binary (${sniff.reason}). Refusing to read as text.`);
+	} catch {}
 	try {
 		const fileDocument = await loadFile(filePath);
 		if (fileDocument.metadata?.error) return {
@@ -205267,59 +206314,45 @@ async function readLocalFile({ path: rawPath, loc, fullContent }) {
 		const lines = fileDocument.content.split("\n");
 		const totalLineCount = lines.length;
 		const totalCharCount = fileDocument.content.length;
-		let content;
-		let charCount;
-		let lineCount;
+		let workingLines;
 		let actualLoc;
 		if (effectiveLoc === void 0) {
-			content = fileDocument.content;
-			charCount = totalCharCount;
-			lineCount = totalLineCount;
+			workingLines = lines;
 			actualLoc = [0, totalLineCount];
 		} else {
 			const [startLine, endLine] = effectiveLoc;
-			const selectedLines = lines.slice(startLine, endLine);
-			content = selectedLines.join("\n");
-			charCount = content.length;
-			lineCount = selectedLines.length;
+			workingLines = lines.slice(startLine, endLine);
 			actualLoc = effectiveLoc;
 		}
-		const fileType = fileDocument.fileType || "unknown";
+		let linesTruncated = 0;
+		let content = workingLines.map((line) => {
+			const r = truncateLine(line);
+			if (r.truncated) linesTruncated++;
+			return r.line;
+		}).join("\n");
+		let truncated = false;
+		if (content.length > MAX_OUTPUT_CHARS) {
+			const originalLength = content.length;
+			content = `${content.slice(0, MAX_OUTPUT_CHARS)}\n[content truncated: response was ${originalLength} chars, kept first ${MAX_OUTPUT_CHARS}. Use a smaller line range or grep to narrow down.]`;
+			truncated = true;
+		}
 		const result = {
-			charCount,
+			charCount: content.length,
 			content,
 			createdTime: fileDocument.createdTime,
-			fileType,
+			fileType: fileDocument.fileType || "unknown",
 			filename: fileDocument.filename,
-			lineCount,
+			lineCount: workingLines.length,
 			loc: actualLoc,
 			modifiedTime: fileDocument.modifiedTime,
 			totalCharCount,
 			totalLineCount
 		};
-		try {
-			if ((await stat(filePath)).isDirectory()) {
-				result.content = "This is a directory and cannot be read as plain text.";
-				result.charCount = 0;
-				result.lineCount = 0;
-				result.totalCharCount = 0;
-				result.totalLineCount = 0;
-			}
-		} catch {}
+		if (truncated) result.truncated = true;
+		if (linesTruncated > 0) result.linesTruncated = linesTruncated;
 		return result;
 	} catch (error) {
-		return {
-			charCount: 0,
-			content: `Error accessing or processing file: ${error.message}`,
-			createdTime: /* @__PURE__ */ new Date(),
-			fileType: path.extname(filePath).toLowerCase().replace(".", "") || "unknown",
-			filename: path.basename(filePath),
-			lineCount: 0,
-			loc: [0, 0],
-			modifiedTime: /* @__PURE__ */ new Date(),
-			totalCharCount: 0,
-			totalLineCount: 0
-		};
+		return buildErrorResult(filePath, `Error accessing or processing file: ${error.message}`);
 	}
 }
 
@@ -205328,9 +206361,10 @@ async function readLocalFile({ path: rawPath, loc, fullContent }) {
 async function searchLocalFiles({ keywords, directory, contentContains, limit = 30 }) {
 	try {
 		const cwd = expandTilde(directory) || process.cwd();
+		const wantsHidden = keywords.startsWith(".");
 		let results = (await (0, import_out.default)(`**/*${keywords}*`, {
 			cwd,
-			dot: false,
+			dot: wantsHidden,
 			ignore: ["**/node_modules/**", "**/.git/**"]
 		})).map((f) => ({
 			name: path.basename(f),
@@ -205471,7 +206505,7 @@ async function runCommand$1({ command, cwd, description, env: extraEnv, run_in_b
 		cwd,
 		timeout
 	});
-	const effectiveTimeout = Math.min(Math.max(timeout, 1e3), 6e5);
+	const effectiveTimeout = Math.min(Math.max(timeout, 1e3), 8e5);
 	const shellConfig = getShellConfig(command);
 	const childEnv = extraEnv ? {
 		...process.env,
@@ -205571,6 +206605,207 @@ async function runCommand$1({ command, cwd, description, env: extraEnv, run_in_b
 	}
 }
 
+//#endregion
+//#region src/daemon/taskRegistry.ts
+function getRegistryPath() {
+	return path.join(os.homedir(), ".lobehub", "task-registry.json");
+}
+function readRegistry() {
+	try {
+		return JSON.parse(fs.readFileSync(getRegistryPath(), "utf8"));
+	} catch {
+		return {};
+	}
+}
+function writeRegistry(entries) {
+	const dir = path.dirname(getRegistryPath());
+	fs.mkdirSync(dir, {
+		mode: 448,
+		recursive: true
+	});
+	fs.writeFileSync(getRegistryPath(), JSON.stringify(entries, null, 2), { mode: 384 });
+}
+function saveTask(entry) {
+	const registry = readRegistry();
+	registry[entry.taskId] = entry;
+	writeRegistry(registry);
+}
+function getTask(taskId) {
+	return readRegistry()[taskId];
+}
+function removeTask(taskId) {
+	const registry = readRegistry();
+	delete registry[taskId];
+	writeRegistry(registry);
+}
+
+//#endregion
+//#region src/tools/heteroTask.ts
+const DEFAULT_HERMES_PORT = 3456;
+/** Resolve the absolute path to the `lh` binary to avoid PATH issues in child processes. */
+function resolveLhPath() {
+	try {
+		return execFileSync("which", ["lh"], { encoding: "utf8" }).trim();
+	} catch {
+		return "lh";
+	}
+}
+function getHermesPort() {
+	const env = process.env.HERMES_GATEWAY_PORT;
+	if (env) {
+		const parsed = Number.parseInt(env, 10);
+		if (!Number.isNaN(parsed)) return parsed;
+	}
+	return DEFAULT_HERMES_PORT;
+}
+async function isHermesGatewayRunning(port) {
+	try {
+		return (await fetch(`http://localhost:${port}/health`)).ok;
+	} catch {
+		return false;
+	}
+}
+async function startHermesGateway(port) {
+	spawn("hermes", ["gateway", "start"], {
+		detached: true,
+		env: { ...process.env },
+		stdio: "ignore"
+	}).unref();
+	const deadline = Date.now() + 1e4;
+	while (Date.now() < deadline) {
+		await new Promise((r) => setTimeout(r, 500));
+		if (await isHermesGatewayRunning(port)) return;
+	}
+	throw new Error(`Hermes gateway did not start within 10s on port ${port}`);
+}
+async function sendAutoNotify(topicId, taskId, text, agentId) {
+	try {
+		await (await getTrpcClient()).agentNotify.notify.mutate({
+			agentId,
+			content: JSON.stringify({
+				stage: "error",
+				taskId,
+				text
+			}),
+			topicId
+		});
+	} catch (err) {
+		log$7.error("Failed to send auto-notify:", err instanceof Error ? err.message : String(err));
+	}
+}
+async function runHeteroTask(params) {
+	const { agentId, agentType, cwd, operationId, prompt, taskId, topicId } = params;
+	const workDir = cwd || process.cwd();
+	if (agentType === "openclaw") {
+		const enrichedPrompt = `${prompt}\n\nWhen your task is complete, run this shell command to report back:\n${resolveLhPath()} notify --topic ${topicId} --content '${JSON.stringify({
+			stage: "done",
+			taskId,
+			text: "Task completed"
+		})}'`;
+		const openclawAgent = process.env.OPENCLAW_AGENT_ID ?? "main";
+		const child = spawn("openclaw", [
+			"agent",
+			"--agent",
+			openclawAgent,
+			"--message",
+			enrichedPrompt,
+			"--local"
+		], {
+			cwd: workDir,
+			detached: true,
+			env: { ...process.env },
+			stdio: "ignore"
+		});
+		const pid = child.pid;
+		if (pid === void 0) throw new Error("Failed to get PID for openclaw process");
+		child.unref();
+		saveTask({
+			agentId,
+			agentType,
+			operationId,
+			pid,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			taskId,
+			topicId
+		});
+		log$7.info(`OpenClaw task started: taskId=${taskId} pid=${pid} agent=${openclawAgent}`);
+		child.on("close", (code, signal) => {
+			removeTask(taskId);
+			if (code !== 0 || signal !== null) sendAutoNotify(topicId, taskId, signal ? `Task cancelled (signal: ${signal})` : `Task failed (exit code: ${code})`, agentId);
+		});
+		return JSON.stringify({
+			pid,
+			taskId
+		});
+	}
+	if (agentType === "hermes") {
+		const port = getHermesPort();
+		if (!await isHermesGatewayRunning(port)) {
+			log$7.info(`Hermes gateway not running on port ${port}, starting...`);
+			await startHermesGateway(port);
+		}
+		const res = await fetch(`http://localhost:${port}/message`, {
+			body: JSON.stringify({
+				content: prompt,
+				operationId
+			}),
+			headers: { "Content-Type": "application/json" },
+			method: "POST"
+		});
+		if (!res.ok) throw new Error(`Hermes gateway returned ${res.status}: ${await res.text()}`);
+		saveTask({
+			agentId,
+			agentType,
+			operationId,
+			pid: 0,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			taskId,
+			topicId
+		});
+		log$7.info(`Hermes task dispatched: taskId=${taskId} operationId=${operationId}`);
+		return JSON.stringify({
+			operationId,
+			taskId
+		});
+	}
+	throw new Error(`Unsupported agentType: ${agentType}`);
+}
+async function cancelHeteroTask(params) {
+	const { signal = "SIGINT", taskId } = params;
+	const entry = getTask(taskId);
+	if (!entry) return JSON.stringify({
+		message: `No task found with taskId: ${taskId}`,
+		success: false
+	});
+	if (entry.agentType === "hermes") {
+		const port = getHermesPort();
+		try {
+			await fetch(`http://localhost:${port}/stop`, {
+				body: JSON.stringify({ operationId: entry.operationId }),
+				headers: { "Content-Type": "application/json" },
+				method: "POST"
+			});
+		} catch (err) {
+			log$7.warn(`Failed to send /stop to Hermes gateway: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		removeTask(taskId);
+		await sendAutoNotify(entry.topicId, taskId, "Task cancelled", entry.agentId);
+		return JSON.stringify({ taskId });
+	}
+	try {
+		process.kill(entry.pid, signal);
+	} catch (err) {
+		log$7.warn(`Failed to send ${signal} to pid ${entry.pid}: ${err instanceof Error ? err.message : String(err)}`);
+		removeTask(taskId);
+		await sendAutoNotify(entry.topicId, taskId, "Task already completed or cancelled", entry.agentId);
+	}
+	return JSON.stringify({
+		pid: entry.pid,
+		signal,
+		taskId
+	});
+}
+
 //#endregion
 //#region src/tools/shell.ts
 const processManager = new ShellProcessManager();
@@ -205593,6 +206828,7 @@ async function killCommand(params) {
 //#endregion
 //#region src/tools/index.ts
 const methodMap = {
+	cancelHeteroTask,
 	editFile: editLocalFile,
 	getCommandOutput,
 	globFiles: globLocalFiles,
@@ -205601,6 +206837,7 @@ const methodMap = {
 	listFiles: listLocalFiles,
 	readFile: readLocalFile,
 	runCommand,
+	runHeteroTask,
 	searchFiles: searchLocalFiles,
 	writeFile: writeLocalFile,
 	editLocalFile,
@@ -205939,141 +207176,6 @@ function collectSystemInfo() {
 	};
 }
 
-//#endregion
-//#region src/commands/cron.ts
-function registerCronCommand(program) {
-	const cron = program.command("cron").description("Manage agent cron jobs");
-	cron.command("list").description("List cron jobs").option("--agent-id <id>", "Filter by agent ID").option("--enabled", "Only show enabled jobs").option("--disabled", "Only show disabled jobs").option("-L, --limit <n>", "Page size", "20").option("--offset <n>", "Offset", "0").option("--json [fields]", "Output JSON, optionally specify fields (comma-separated)").action(async (options) => {
-		const client = await getTrpcClient();
-		const input = {};
-		if (options.agentId) input.agentId = options.agentId;
-		if (options.enabled) input.enabled = true;
-		if (options.disabled) input.enabled = false;
-		if (options.limit) input.limit = Number.parseInt(options.limit, 10);
-		if (options.offset) input.offset = Number.parseInt(options.offset, 10);
-		const items = (await client.agentCronJob.list.query(input)).data ?? [];
-		if (options.json !== void 0) {
-			outputJson(items, typeof options.json === "string" ? options.json : void 0);
-			return;
-		}
-		if (items.length === 0) {
-			console.log("No cron jobs found.");
-			return;
-		}
-		printTable(items.map((j) => [
-			j.id || "",
-			truncate(j.name || "", 30),
-			j.schedule || "",
-			j.enabled ? import_picocolors.default.green("enabled") : import_picocolors.default.dim("disabled"),
-			`${j.executionCount ?? 0}/${j.maxExecutions ?? "∞"}`,
-			j.updatedAt ? timeAgo(j.updatedAt) : ""
-		]), [
-			"ID",
-			"NAME",
-			"SCHEDULE",
-			"STATUS",
-			"EXECUTIONS",
-			"UPDATED"
-		]);
-	});
-	cron.command("view <id>").description("View cron job details").option("--json [fields]", "Output JSON").action(async (id, options) => {
-		const job = (await (await getTrpcClient()).agentCronJob.findById.query({ id })).data;
-		if (options.json !== void 0) {
-			outputJson(job, typeof options.json === "string" ? options.json : void 0);
-			return;
-		}
-		if (!job) {
-			log$7.error("Cron job not found.");
-			process.exit(1);
-		}
-		console.log(`${import_picocolors.default.bold("ID:")}          ${job.id}`);
-		console.log(`${import_picocolors.default.bold("Name:")}        ${job.name || ""}`);
-		console.log(`${import_picocolors.default.bold("Agent ID:")}    ${job.agentId || ""}`);
-		console.log(`${import_picocolors.default.bold("Schedule:")}    ${job.schedule || ""}`);
-		console.log(`${import_picocolors.default.bold("Status:")}      ${job.enabled ? import_picocolors.default.green("enabled") : import_picocolors.default.dim("disabled")}`);
-		console.log(`${import_picocolors.default.bold("Executions:")}  ${job.executionCount ?? 0}/${job.maxExecutions ?? "∞"}`);
-		if (job.prompt) console.log(`${import_picocolors.default.bold("Prompt:")}      ${truncate(job.prompt, 80)}`);
-		if (job.createdAt) console.log(`${import_picocolors.default.bold("Created:")}     ${timeAgo(job.createdAt)}`);
-		if (job.updatedAt) console.log(`${import_picocolors.default.bold("Updated:")}     ${timeAgo(job.updatedAt)}`);
-	});
-	cron.command("create").description("Create a cron job").requiredOption("--agent-id <id>", "Agent ID").requiredOption("-s, --schedule <cron>", "Cron schedule expression").option("-n, --name <name>", "Job name").option("-p, --prompt <prompt>", "Prompt text").option("--max-executions <n>", "Maximum number of executions").option("--json", "Output JSON").action(async (options) => {
-		const client = await getTrpcClient();
-		const input = {
-			agentId: options.agentId,
-			cronPattern: options.schedule
-		};
-		if (options.name) input.name = options.name;
-		if (options.prompt) input.content = options.prompt;
-		if (options.maxExecutions) input.maxExecutions = Number.parseInt(options.maxExecutions, 10);
-		const result = await client.agentCronJob.create.mutate(input);
-		if (options.json) {
-			console.log(JSON.stringify(result, null, 2));
-			return;
-		}
-		const data = result.data;
-		console.log(`${import_picocolors.default.green("✓")} Created cron job ${import_picocolors.default.bold(data?.id || "")}`);
-	});
-	cron.command("edit <id>").description("Update a cron job").option("-n, --name <name>", "Job name").option("-s, --schedule <cron>", "Cron schedule expression").option("-p, --prompt <prompt>", "Prompt text").option("--max-executions <n>", "Maximum number of executions").option("--enable", "Enable the job").option("--disable", "Disable the job").action(async (id, options) => {
-		const data = {};
-		if (options.name) data.name = options.name;
-		if (options.schedule) data.cronPattern = options.schedule;
-		if (options.prompt) data.content = options.prompt;
-		if (options.maxExecutions) data.maxExecutions = Number.parseInt(options.maxExecutions, 10);
-		if (options.enable) data.enabled = true;
-		if (options.disable) data.enabled = false;
-		if (Object.keys(data).length === 0) {
-			log$7.error("No changes specified. Use --name, --schedule, --prompt, --enable, or --disable.");
-			process.exit(1);
-		}
-		await (await getTrpcClient()).agentCronJob.update.mutate({
-			data,
-			id
-		});
-		console.log(`${import_picocolors.default.green("✓")} Updated cron job ${import_picocolors.default.bold(id)}`);
-	});
-	cron.command("delete <id>").description("Delete a cron job").option("--yes", "Skip confirmation prompt").action(async (id, options) => {
-		if (!options.yes) {
-			if (!await confirm("Are you sure you want to delete this cron job?")) {
-				console.log("Cancelled.");
-				return;
-			}
-		}
-		await (await getTrpcClient()).agentCronJob.delete.mutate({ id });
-		console.log(`${import_picocolors.default.green("✓")} Deleted cron job ${import_picocolors.default.bold(id)}`);
-	});
-	cron.command("toggle <ids...>").description("Batch enable or disable cron jobs").option("--enable", "Enable the jobs").option("--disable", "Disable the jobs").action(async (ids, options) => {
-		if (!options.enable && !options.disable) {
-			log$7.error("Specify --enable or --disable.");
-			process.exit(1);
-		}
-		const enabled = !!options.enable;
-		const count = (await (await getTrpcClient()).agentCronJob.batchUpdateStatus.mutate({
-			enabled,
-			ids
-		})).data?.updatedCount ?? ids.length;
-		console.log(`${import_picocolors.default.green("✓")} ${enabled ? "Enabled" : "Disabled"} ${count} cron job(s)`);
-	});
-	cron.command("reset <id>").description("Reset execution count for a cron job").option("--max <n>", "Set new max executions").action(async (id, options) => {
-		const client = await getTrpcClient();
-		const input = { id };
-		if (options.max) input.newMaxExecutions = Number.parseInt(options.max, 10);
-		await client.agentCronJob.resetExecutions.mutate(input);
-		console.log(`${import_picocolors.default.green("✓")} Reset execution count for ${import_picocolors.default.bold(id)}`);
-	});
-	cron.command("stats").description("Get cron job execution statistics").option("--json", "Output JSON").action(async (options) => {
-		const stats = (await (await getTrpcClient()).agentCronJob.getStats.query()).data;
-		if (options.json) {
-			console.log(JSON.stringify(stats, null, 2));
-			return;
-		}
-		if (!stats) {
-			console.log("No statistics available.");
-			return;
-		}
-		for (const [key, value] of Object.entries(stats)) console.log(`${import_picocolors.default.bold(key + ":")} ${value}`);
-	});
-}
-
 //#endregion
 //#region src/commands/device.ts
 function registerDeviceCommand(program) {
@@ -207203,6 +208305,58 @@ function colorStatus(status) {
 * regardless of whether they share a constant.
 */
 const CC_TODO_WRITE_TOOL_NAME = "TodoWrite";
+/**
+* CC 2.1.143+ replaced the declarative {@link CC_TODO_WRITE_TOOL_NAME} with
+* an imperative trio: one task per `TaskCreate` (server-assigned numeric id),
+* field-merge mutations via `TaskUpdate`, and `TaskList` as the only
+* full-state read. The adapter accumulates these into a per-session map and
+* synthesizes the shared `pluginState.todos` shape on each task-tool
+* tool_result so the existing TodoProgress UI keeps working.
+*
+* The old TodoWrite path stays alongside — resumed sessions started on an
+* older CC may still emit it, and CC's recent SDK reminder text doesn't
+* forbid the model from using TodoWrite if it really wants to.
+*/
+const CC_TASK_CREATE_TOOL_NAME = "TaskCreate";
+const CC_TASK_UPDATE_TOOL_NAME = "TaskUpdate";
+const CC_TASK_LIST_TOOL_NAME = "TaskList";
+/**
+* tool_result confirmation emitted by CC for a successful `TaskCreate`.
+* Observed shape on CC 2.1.143: `Task #1 created successfully: <subject>`.
+* The numeric id is the only place we can read the CC-assigned handle —
+* `TaskCreate.input` itself does not echo it.
+*/
+const TASK_CREATE_RESULT_PATTERN = /^Task #(\d+) created successfully/;
+/**
+* tool_result confirmation emitted by CC for a successful `TaskUpdate`.
+* Suffix varies (`status`, blank if no field changed, etc.); we only need
+* the id to confirm the mutation landed — the field deltas are already
+* carried by the cached `TaskUpdate.input`.
+*/
+const TASK_UPDATE_RESULT_PATTERN = /^Updated task #\d+/;
+/**
+* One line of `TaskList`'s plain-text output: `#1 [in_progress] read hosts`.
+* Used as the resume reconciliation path — when this adapter joins a CC
+* session mid-stream and missed earlier Create / Update events, parsing
+* TaskList rebuilds id / subject / status. `activeForm` and `description`
+* cannot be recovered (CC omits them) so resumed in_progress tasks fall
+* back to the subject text, same as TodoWrite's content-fallback.
+*/
+const TASK_LIST_LINE_PATTERN = /^#(\d+) \[(pending|in_progress|completed)\] (.+)$/;
+/**
+* Tool name CC sees for the LobeHub-hosted MCP `ask_user_question` server.
+* Source of truth lives in `../askUser/constants.ts`; replicated here as a
+* literal so the adapter compiles in browser bundles without dragging in
+* any of the askUser package's runtime (node:http, MCP SDK, etc.) by
+* accident. Keep in sync.
+*/
+const ASK_USER_MCP_TOOL_NAME = "mcp__lobe_cc__ask_user_question";
+/**
+* apiName the adapter rewrites the MCP tool to so the renderer routes on
+* a stable key, not the wire-prefixed MCP name. Source of truth same as
+* above.
+*/
+const ASK_USER_API_NAME = "askUserQuestion";
 const CLAUDE_CODE_CLI_INSTALL_DOCS_URL = "https://docs.anthropic.com/en/docs/claude-code/setup";
 const CLI_AUTH_REQUIRED_PATTERNS = [
 	/failed to authenticate/i,
@@ -207260,24 +208414,40 @@ const getRateLimitTerminalError = (result, rateLimitInfo, apiErrorStatus) => {
 		stderr: rawMessage
 	};
 };
+const toSynthesizedStatus = (status) => status === "in_progress" ? "processing" : status === "pending" ? "todo" : "completed";
+const synthesizeTodoWritePluginState = (args) => {
+	return { todos: {
+		items: (args.todos || []).map((todo) => {
+			const text = todo.status === "in_progress" ? todo.activeForm || todo.content : todo.content;
+			return {
+				status: toSynthesizedStatus(todo.status),
+				text
+			};
+		}),
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	} };
+};
 /**
-* CC's TodoWrite is a declarative state-write tool: its `tool_use.input` IS
-* the target todos list, and the `tool_result` content is just a confirmation
-* string. Translating the input into the shared `StepContextTodos` shape lets
-* the Gateway/ACP-aligned `pluginState.todos` contract light up the
-* TodoProgress card without any CC-specific knowledge leaking into selectors
-* or executors.
+* Snapshot the running `claudeCodeTasks` accumulator into the shared
+* `pluginState.todos` shape. Sorted by numeric id so the rendered order
+* matches CC's own TaskList output (insertion order = id order in practice,
+* but TaskUpdate can rearrange status without rearranging ids). Carries the
+* `id` per item so the TaskUpdate inspector can resolve `args.taskId` →
+* subject text without falling back to a `#N` label.
 *
-* Word mapping: CC `pending|in_progress|completed` → shared `todo|processing|completed`.
-* Text field: use `activeForm` while in progress (present-continuous is what
-* the header surfaces), fall back to `content` for every other state.
+* Text resolution mirrors {@link synthesizeTodoWritePluginState}: use
+* `activeForm` while in progress so the spinner reads "Running tests"
+* rather than "Run tests"; fall back to `subject` whenever activeForm is
+* missing (TaskList-reconciled entries, or a TaskCreate that omitted it).
 */
-const synthesizeTodoWritePluginState = (args) => {
+const synthesizeTaskPluginState = (tasks) => {
 	return { todos: {
-		items: (args.todos || []).map((todo) => {
+		items: [...tasks.entries()].sort(([a], [b]) => Number(a) - Number(b)).map(([id, entry]) => {
+			const text = entry.status === "in_progress" ? entry.activeForm || entry.subject : entry.subject;
 			return {
-				status: todo.status === "in_progress" ? "processing" : todo.status === "pending" ? "todo" : "completed",
-				text: todo.status === "in_progress" ? todo.activeForm || todo.content : todo.content
+				id,
+				status: toSynthesizedStatus(entry.status),
+				text
 			};
 		}),
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -207338,10 +208508,10 @@ var ClaudeCodeAdapter = class {
 	* authoritative usage on `message_delta`.
 	*/
 	currentStreamEventModel;
-	/** message.ids whose text has already been streamed as deltas — skip the full-block emission */
-	messagesWithStreamedText = /* @__PURE__ */ new Set();
-	/** message.ids whose thinking has already been streamed as deltas — skip the full-block emission */
-	messagesWithStreamedThinking = /* @__PURE__ */ new Set();
+	/** Cumulative text streamed via partial-message deltas, keyed by message.id. */
+	streamedTextByMessageId = /* @__PURE__ */ new Map();
+	/** Cumulative thinking streamed via partial-message deltas, keyed by message.id. */
+	streamedThinkingByMessageId = /* @__PURE__ */ new Map();
 	/**
 	* Cumulative tool_use blocks per message.id. CC streams each tool_use in
 	* its OWN assistant event, and the handler's in-memory assistant.tools
@@ -207359,6 +208529,34 @@ var ClaudeCodeAdapter = class {
 	*/
 	todoWriteInputs = /* @__PURE__ */ new Map();
 	/**
+	* Cached `TaskCreate.input` keyed by `tool_use.id`. Drained in `handleUser`
+	* once the matching tool_result lands: at that point we parse the
+	* CC-assigned numeric id from `Task #N created successfully` and push the
+	* cached fields into {@link claudeCodeTasks}. Cleared even on error to
+	* keep long sessions bounded — failed creates never reach the accumulator.
+	*/
+	taskCreateInputs = /* @__PURE__ */ new Map();
+	/**
+	* Cached `TaskUpdate.input` keyed by `tool_use.id`. Drained on
+	* tool_result; on success the cached fields merge into the targeted entry
+	* in {@link claudeCodeTasks}. `status: 'deleted'` removes the entry.
+	*/
+	taskUpdateInputs = /* @__PURE__ */ new Map();
+	/**
+	* Tool_use ids of `TaskList` calls awaiting their tool_result. Used to
+	* dispatch the reconciliation parser without re-checking the tool name on
+	* every user event. `TaskList.input` is empty so no payload to cache.
+	*/
+	pendingTaskListCalls = /* @__PURE__ */ new Set();
+	/**
+	* Adapter's running mirror of CC's task list, keyed by the CC-assigned
+	* numeric task id. Survives across `result` events because CC keeps the
+	* task list alive between turns within one session; cleared only when
+	* the adapter is destroyed. This is what `synthesizeTaskPluginState`
+	* snapshots on each task-tool tool_result.
+	*/
+	claudeCodeTasks = /* @__PURE__ */ new Map();
+	/**
 	* Cached inputs for main-agent tool_uses keyed by their tool_use.id.
 	* Populated for every main-agent tool_use (not just `Task`) because
 	* CC uses multiple tool names for subagent delegation — real traces
@@ -207379,6 +208577,63 @@ var ClaudeCodeAdapter = class {
 	* recreate the Thread on every chunk.
 	*/
 	announcedSpawns = /* @__PURE__ */ new Set();
+	/**
+	* Tool name keyed by main-agent `tool_use.id`. Used to label the
+	* resulting {@link ExternalSignalContext} when a Monitor-style task
+	* fires a callback turn.
+	*
+	* Populated for every main-agent tool_use; subagent inner tools are
+	* excluded because their tool_results route through `subagent.parentToolCallId`,
+	* not the main-agent signal detector.
+	*/
+	mainToolNamesById = /* @__PURE__ */ new Map();
+	/**
+	* Active CC tasks (long-running tools registered via `system task_started`).
+	* Keyed by `task_id`, carries the originating `tool_use_id`, the resolved
+	* tool name, and a counter incremented for each signal callback turn
+	* the adapter attributes to this task.
+	*
+	* A task lives from `task_started` until `task_notification` /
+	* `task_completed`. While alive, any `message_start` that opens a turn
+	* WITHOUT a preceding `user` event is a signal callback and gets tagged.
+	*/
+	activeTasks = /* @__PURE__ */ new Map();
+	/**
+	* True after a `user` event has been seen but the next turn hasn't yet
+	* opened (`message_start` not yet fired). Carries the "this next turn
+	* is a natural follow-up to a tool_result, not a signal callback"
+	* intent across the gap between the tool_result event and the
+	* resulting assistant turn.
+	*
+	* Reset to `false` once a `message_start` consumes it. After that, any
+	* further `message_start` that opens while {@link activeTasks} is
+	* non-empty is treated as a signal callback (CC re-invoked the LLM
+	* because a long-running tool pushed an update).
+	*/
+	hasUnhandledUserInput = false;
+	/**
+	* {@link ExternalSignalContext} to attach to the NEXT `stream_start(newStep)`.
+	*
+	* Armed by `message_start` when {@link hasUnhandledUserInput} is false
+	* AND {@link activeTasks} is non-empty — i.e. CC opened a new turn
+	* without fresh user input while a long-running tool is alive. Cleared
+	* on the next `tool_use` (LLM is back on the main chain).
+	*/
+	pendingExternalSignal;
+	/**
+	* Source-tool lineage of the most recently completed long-running task,
+	* waiting to be stamped on the post-task summary turn with
+	* `type: 'task-completion'`.
+	*
+	* Armed when `system task_notification` ends an active task; consumed
+	* by the NEXT `message_start` that takes the natural-turn branch
+	* (no other active task triggering a callback). Cleared on `result`
+	* so it never leaks across LLM runs.
+	*
+	* Lets the renderer keep the summary inside the same AssistantGroup as
+	* the preceding callbacks instead of letting it spawn a separate group.
+	*/
+	pendingTaskCompletion;
 	adapt(raw) {
 		if (!raw || typeof raw !== "object") return [];
 		switch (raw.type) {
@@ -207400,6 +208655,25 @@ var ClaudeCodeAdapter = class {
 		return events;
 	}
 	handleSystem(raw) {
+		if (raw.subtype === "task_started" && raw.task_id && raw.tool_use_id) {
+			const toolUseId = raw.tool_use_id;
+			this.activeTasks.set(raw.task_id, {
+				callbackCount: 0,
+				sourceToolName: this.mainToolNamesById.get(toolUseId) ?? "unknown",
+				toolUseId
+			});
+			return [];
+		}
+		if (raw.subtype === "task_notification" && raw.task_id) {
+			const ending = this.activeTasks.get(raw.task_id);
+			if (ending) this.pendingTaskCompletion = {
+				sourceToolCallId: ending.toolUseId,
+				sourceToolName: ending.sourceToolName
+			};
+			this.activeTasks.delete(raw.task_id);
+			return [];
+		}
+		if (raw.subtype === "task_updated") return [];
 		if (raw.subtype !== "init") return [];
 		this.sessionId = raw.session_id;
 		this.started = true;
@@ -207428,9 +208702,10 @@ var ClaudeCodeAdapter = class {
 			case "thinking":
 				if (block.thinking) reasoningParts.push(block.thinking);
 				break;
-			case "tool_use":
+			case "tool_use": {
+				const apiName = block.name === ASK_USER_MCP_TOOL_NAME ? ASK_USER_API_NAME : block.name;
 				newToolCalls.push({
-					apiName: block.name,
+					apiName,
 					arguments: JSON.stringify(block.input || {}),
 					id: block.id,
 					identifier: "claude-code",
@@ -207438,19 +208713,29 @@ var ClaudeCodeAdapter = class {
 				});
 				this.pendingToolCalls.add(block.id);
 				if (block.input) this.mainToolInputsById.set(block.id, block.input);
+				if (block.name) this.mainToolNamesById.set(block.id, block.name);
 				if (block.name === CC_TODO_WRITE_TOOL_NAME && block.input) this.todoWriteInputs.set(block.id, block.input);
+				if (block.name === CC_TASK_CREATE_TOOL_NAME && block.input) this.taskCreateInputs.set(block.id, block.input);
+				if (block.name === CC_TASK_UPDATE_TOOL_NAME && block.input) this.taskUpdateInputs.set(block.id, block.input);
+				if (block.name === CC_TASK_LIST_TOOL_NAME) this.pendingTaskListCalls.add(block.id);
 				break;
+			}
 		}
-		const textAlreadyStreamed = !!messageId && this.messagesWithStreamedText.has(messageId);
-		const thinkingAlreadyStreamed = !!messageId && this.messagesWithStreamedThinking.has(messageId);
-		if (textParts.length > 0 && !textAlreadyStreamed) events.push(this.makeChunkEvent({
+		if (newToolCalls.length > 0) this.pendingExternalSignal = void 0;
+		const textCompletion = this.getTrailingCompletion(messageId, textParts.join(""), this.streamedTextByMessageId);
+		const thinkingCompletion = this.getTrailingCompletion(messageId, reasoningParts.join(""), this.streamedThinkingByMessageId);
+		if (textCompletion) events.push(this.makeChunkEvent({
 			chunkType: "text",
-			content: textParts.join("")
+			content: textCompletion
 		}));
-		if (reasoningParts.length > 0 && !thinkingAlreadyStreamed) events.push(this.makeChunkEvent({
+		if (thinkingCompletion) events.push(this.makeChunkEvent({
 			chunkType: "reasoning",
-			reasoning: reasoningParts.join("")
+			reasoning: thinkingCompletion
 		}));
+		if (messageId) this.clearStreamedBuffers(messageId, {
+			thinking: reasoningParts.length > 0,
+			text: textParts.length > 0
+		});
 		events.push(...this.emitToolChunk(newToolCalls, messageId));
 		return events;
 	}
@@ -207500,9 +208785,10 @@ var ClaudeCodeAdapter = class {
 			case "thinking":
 				if (block.thinking) reasoningParts.push(block.thinking);
 				break;
-			case "tool_use":
+			case "tool_use": {
+				const apiName = block.name === ASK_USER_MCP_TOOL_NAME ? ASK_USER_API_NAME : block.name;
 				newToolCalls.push({
-					apiName: block.name,
+					apiName,
 					arguments: JSON.stringify(block.input || {}),
 					id: block.id,
 					identifier: "claude-code",
@@ -207511,6 +208797,7 @@ var ClaudeCodeAdapter = class {
 				this.pendingToolCalls.add(block.id);
 				if (block.name === CC_TODO_WRITE_TOOL_NAME && block.input) this.todoWriteInputs.set(block.id, block.input);
 				break;
+			}
 		}
 		const events = [];
 		if (textParts.length > 0) events.push(this.makeChunkEvent({
@@ -207597,6 +208884,7 @@ var ClaudeCodeAdapter = class {
 			if (block.type !== "tool_result") continue;
 			const toolCallId = block.tool_use_id;
 			if (!toolCallId) continue;
+			if (!subagentCtx) this.hasUnhandledUserInput = true;
 			const resultContent = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map((c) => {
 				if (c?.type === "tool_reference" && c.tool_name) return c.tool_name;
 				if (c?.type === "image") return `[Image: ${c.source?.media_type || "image"}]`;
@@ -207604,7 +208892,9 @@ var ClaudeCodeAdapter = class {
 			}).filter(Boolean).join("\n") : JSON.stringify(block.content || "");
 			const cachedTodoArgs = this.todoWriteInputs.get(toolCallId);
 			if (cachedTodoArgs) this.todoWriteInputs.delete(toolCallId);
-			const pluginState = cachedTodoArgs && !block.is_error ? synthesizeTodoWritePluginState(cachedTodoArgs) : void 0;
+			const todoWritePluginState = cachedTodoArgs && !block.is_error ? synthesizeTodoWritePluginState(cachedTodoArgs) : void 0;
+			const taskPluginState = subagentCtx === void 0 ? this.applyTaskToolResult(toolCallId, !!block.is_error, resultContent) : void 0;
+			const pluginState = todoWritePluginState ?? taskPluginState;
 			events.push(this.makeEvent("tool_result", {
 				content: resultContent,
 				isError: !!block.is_error,
@@ -207623,6 +208913,68 @@ var ClaudeCodeAdapter = class {
 		}
 		return events;
 	}
+	/**
+	* Apply a Task* tool_result to the running {@link claudeCodeTasks}
+	* accumulator and return a fresh synthesized `pluginState.todos` snapshot.
+	* Returns `undefined` if the tool_result was for a non-Task tool, was an
+	* error, or carried no state change (the snapshot is identical to the
+	* pre-call one — but we still emit it so the UI re-syncs).
+	*
+	* Drain the input caches even on error to keep long sessions bounded;
+	* the accumulator itself only mutates on success so a failed TaskUpdate
+	* doesn't leak partial state into the rendered todo list.
+	*/
+	applyTaskToolResult(toolCallId, isError, resultContent) {
+		const cachedCreate = this.taskCreateInputs.get(toolCallId);
+		if (cachedCreate) this.taskCreateInputs.delete(toolCallId);
+		const cachedUpdate = this.taskUpdateInputs.get(toolCallId);
+		if (cachedUpdate) this.taskUpdateInputs.delete(toolCallId);
+		const wasTaskList = this.pendingTaskListCalls.has(toolCallId);
+		if (wasTaskList) this.pendingTaskListCalls.delete(toolCallId);
+		if (!cachedCreate && !cachedUpdate && !wasTaskList) return void 0;
+		if (isError) return void 0;
+		if (cachedCreate) {
+			const match = TASK_CREATE_RESULT_PATTERN.exec(resultContent);
+			if (match) {
+				const taskId = match[1];
+				this.claudeCodeTasks.set(taskId, {
+					activeForm: cachedCreate.activeForm,
+					description: cachedCreate.description,
+					status: "pending",
+					subject: cachedCreate.subject
+				});
+			}
+		} else if (cachedUpdate) {
+			if (!TASK_UPDATE_RESULT_PATTERN.test(resultContent)) return void 0;
+			if (cachedUpdate.status === "deleted") this.claudeCodeTasks.delete(cachedUpdate.taskId);
+			else {
+				const next = this.claudeCodeTasks.get(cachedUpdate.taskId) ?? {
+					status: "pending",
+					subject: cachedUpdate.subject ?? `Task #${cachedUpdate.taskId}`
+				};
+				if (cachedUpdate.status) next.status = cachedUpdate.status;
+				if (cachedUpdate.subject !== void 0) next.subject = cachedUpdate.subject;
+				if (cachedUpdate.description !== void 0) next.description = cachedUpdate.description;
+				if (cachedUpdate.activeForm !== void 0) next.activeForm = cachedUpdate.activeForm;
+				this.claudeCodeTasks.set(cachedUpdate.taskId, next);
+			}
+		} else if (wasTaskList) for (const rawLine of resultContent.split("\n")) {
+			const line = rawLine.trim();
+			if (!line) continue;
+			const m = TASK_LIST_LINE_PATTERN.exec(line);
+			if (!m) continue;
+			const [, taskId, status, subject] = m;
+			const existing = this.claudeCodeTasks.get(taskId);
+			if (existing) {
+				existing.status = status;
+				existing.subject = subject;
+			} else this.claudeCodeTasks.set(taskId, {
+				status,
+				subject
+			});
+		}
+		return synthesizeTaskPluginState(this.claudeCodeTasks);
+	}
 	handleResult(raw) {
 		const events = [];
 		const usage = toUsageData$1(raw.usage);
@@ -207638,6 +208990,9 @@ var ClaudeCodeAdapter = class {
 			message: resultMessage
 		}) : this.makeEvent("agent_runtime_end", {});
 		this.pendingRateLimitInfo = void 0;
+		this.streamedTextByMessageId.clear();
+		this.streamedThinkingByMessageId.clear();
+		this.pendingTaskCompletion = void 0;
 		return [
 			...events,
 			this.makeEvent("stream_end", {}),
@@ -207669,14 +209024,14 @@ var ClaudeCodeAdapter = class {
 				if (!delta) return [];
 				const msgId = this.currentStreamEventMessageId;
 				if (delta.type === "text_delta" && delta.text) {
-					if (msgId) this.messagesWithStreamedText.add(msgId);
+					if (msgId) this.streamedTextByMessageId.set(msgId, `${this.streamedTextByMessageId.get(msgId) ?? ""}${delta.text}`);
 					return [this.makeChunkEvent({
 						chunkType: "text",
 						content: delta.text
 					})];
 				}
 				if (delta.type === "thinking_delta" && delta.thinking) {
-					if (msgId) this.messagesWithStreamedThinking.add(msgId);
+					if (msgId) this.streamedThinkingByMessageId.set(msgId, `${this.streamedThinkingByMessageId.get(msgId) ?? ""}${delta.thinking}`);
 					return [this.makeChunkEvent({
 						chunkType: "reasoning",
 						reasoning: delta.thinking
@@ -207727,12 +209082,44 @@ var ClaudeCodeAdapter = class {
 		}
 		this.currentMessageId = messageId;
 		this.stepIndex++;
+		if (!this.hasUnhandledUserInput && this.activeTasks.size > 0) {
+			const lastTaskKey = [...this.activeTasks.keys()].at(-1);
+			const task = this.activeTasks.get(lastTaskKey);
+			task.callbackCount += 1;
+			this.pendingExternalSignal = {
+				sequence: task.callbackCount,
+				sourceToolCallId: task.toolUseId,
+				sourceToolName: task.sourceToolName,
+				type: "tool-stdout"
+			};
+		} else if (this.pendingTaskCompletion) {
+			this.pendingExternalSignal = {
+				sourceToolCallId: this.pendingTaskCompletion.sourceToolCallId,
+				sourceToolName: this.pendingTaskCompletion.sourceToolName,
+				type: "task-completion"
+			};
+			this.pendingTaskCompletion = void 0;
+		} else this.pendingExternalSignal = void 0;
+		this.hasUnhandledUserInput = false;
 		return [this.makeEvent("stream_end", {}), this.makeEvent("stream_start", {
+			externalSignal: this.pendingExternalSignal,
 			model,
 			newStep: true,
 			provider: "claude-code"
 		})];
 	}
+	getTrailingCompletion(messageId, fullContent, streamedByMessageId) {
+		if (!fullContent) return;
+		if (!messageId) return fullContent;
+		const streamed = streamedByMessageId.get(messageId);
+		if (!streamed) return fullContent;
+		if (fullContent === streamed) return;
+		if (fullContent.startsWith(streamed)) return fullContent.slice(streamed.length) || void 0;
+	}
+	clearStreamedBuffers(messageId, modes) {
+		if (modes.text) this.streamedTextByMessageId.delete(messageId);
+		if (modes.thinking) this.streamedThinkingByMessageId.delete(messageId);
+	}
 	makeEvent(type, data) {
 		return {
 			data,
@@ -208373,6 +209760,142 @@ var AgentStreamPipeline = class {
 	}
 };
 
+//#endregion
+//#region ../../packages/heterogeneous-agents/src/spawn/cliSpawn.ts
+const WINDOWS_EXE_EXT_PATTERN = /\.exe$/i;
+const WINDOWS_NODE_EXE_PATTERN = /(?:^|[\\/])node(?:\.exe)?$/i;
+const isWindows = () => platform() === "win32";
+const isPathLikeCommand = (command) => path.win32.isAbsolute(command) || path.posix.isAbsolute(command) || /[\\/]/.test(command);
+const fileExists = async (filePath) => {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const execFileString = async (command, args) => new Promise((resolve, reject) => {
+	execFile(command, args, {
+		timeout: 3e3,
+		windowsHide: true
+	}, (error, stdout) => {
+		if (error) {
+			reject(error);
+			return;
+		}
+		resolve(stdout.toString());
+	});
+});
+const pickWindowsExecutable = (candidates) => candidates.find((candidate) => WINDOWS_EXE_EXT_PATTERN.test(candidate));
+const pickWindowsNodeExecutable = (candidates) => candidates.find((candidate) => WINDOWS_EXE_EXT_PATTERN.test(candidate) && WINDOWS_NODE_EXE_PATTERN.test(candidate));
+const joinShimRelativePath = (shimPath, relativePath) => path.win32.join(path.win32.dirname(shimPath), ...relativePath.replaceAll("\\", "/").split("/").filter(Boolean));
+const resolveShimPathToken = (shimPath, token) => {
+	const trimmedToken = token.trim().replaceAll(/^['"]|['"]$/g, "");
+	const lowerToken = trimmedToken.toLowerCase();
+	if (lowerToken.startsWith("$basedir")) return joinShimRelativePath(shimPath, trimmedToken.slice(8).replace(/^[\\/]/, ""));
+	if (lowerToken.startsWith("%dp0%")) return joinShimRelativePath(shimPath, trimmedToken.slice(5).replace(/^[\\/]/, ""));
+	if (path.win32.isAbsolute(trimmedToken)) return trimmedToken;
+	if (/[\\/]/.test(trimmedToken)) return joinShimRelativePath(shimPath, trimmedToken);
+};
+const getExistingShimPathToken = async (shimPath, token) => {
+	const resolvedPath = resolveShimPathToken(shimPath, token);
+	if (!resolvedPath) return;
+	return await fileExists(resolvedPath) ? resolvedPath : void 0;
+};
+const resolveWindowsNodeCommand = async (shimPath) => {
+	const localNodePath = path.win32.join(path.win32.dirname(shimPath), "node.exe");
+	if (await fileExists(localNodePath)) return localNodePath;
+	try {
+		return pickWindowsNodeExecutable((await execFileString("where", ["node"])).split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+	} catch {
+		return;
+	}
+};
+const getNodeCommand = async (shimPath, token) => {
+	const trimmedToken = token.trim().replaceAll(/^['"]|['"]$/g, "");
+	if (/^node(?:\.exe)?$/i.test(trimmedToken) || /^%_prog%$/i.test(trimmedToken)) return resolveWindowsNodeCommand(shimPath);
+	const resolvedPath = await getExistingShimPathToken(shimPath, trimmedToken);
+	if (!resolvedPath) return;
+	return WINDOWS_NODE_EXE_PATTERN.test(resolvedPath) ? resolvedPath : void 0;
+};
+const getNodeScriptTarget = async (shimPath, nodeToken, scriptToken) => {
+	const command = await getNodeCommand(shimPath, nodeToken);
+	if (!command) return;
+	const scriptPath = await getExistingShimPathToken(shimPath, scriptToken);
+	if (!scriptPath) return;
+	return {
+		argsPrefix: [scriptPath],
+		command
+	};
+};
+const inferWindowsNodeScriptFromShim = async (shimPath, source) => {
+	for (const pattern of [
+		/exec\s+"(\$basedir[^"]*node(?:\.exe)?)"\s+"([^"]+)"/i,
+		/exec\s+(node(?:\.exe)?)\s+"([^"]+)"/i,
+		/"(%dp0%[^"]*node(?:\.exe)?)"\s+"([^"]+)"/i,
+		/"(%_prog%)"\s+"([^"]+)"/i,
+		[/(?:^|\r?\n)\s*(node(?:\.exe)?)\s+"([^"]+)"/i, "node"]
+	]) {
+		const regex = Array.isArray(pattern) ? pattern[0] : pattern;
+		const match = source.match(regex);
+		if (!match) continue;
+		const nodeToken = Array.isArray(pattern) ? pattern[1] : match[1];
+		const scriptToken = Array.isArray(pattern) ? match[2] : match[2];
+		if (!nodeToken || !scriptToken) continue;
+		const target = await getNodeScriptTarget(shimPath, nodeToken, scriptToken);
+		if (target) return target;
+	}
+};
+const inferWindowsExecutableFromShim = async (shimPath, source) => {
+	const matches = [...source.matchAll(/\$basedir[\\/]([^"\s]+?\.exe)/gi), ...source.matchAll(/%dp0%\\([^"\r\n]+?\.exe)/gi)];
+	for (const match of matches) {
+		const relativePath = match[1]?.replaceAll("\\", "/");
+		if (!relativePath || WINDOWS_NODE_EXE_PATTERN.test(relativePath)) continue;
+		const command = joinShimRelativePath(shimPath, relativePath);
+		if (await fileExists(command)) return { command };
+	}
+};
+const inferWindowsNpmShimTarget = async (shimPath) => {
+	if (WINDOWS_EXE_EXT_PATTERN.test(shimPath)) return { command: shimPath };
+	if (!await fileExists(shimPath)) return;
+	try {
+		const source = await readFile(shimPath, "utf8");
+		return await inferWindowsNodeScriptFromShim(shimPath, source) ?? await inferWindowsExecutableFromShim(shimPath, source);
+	} catch {
+		return;
+	}
+};
+const resolveWindowsBareCommand = async (command) => {
+	try {
+		const candidates = (await execFileString("where", [command])).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+		const executable = pickWindowsExecutable(candidates);
+		if (executable) return { command: executable };
+		for (const candidate of candidates) {
+			const target = await inferWindowsNpmShimTarget(candidate);
+			if (target) return target;
+		}
+		return;
+	} catch {
+		return;
+	}
+};
+const resolveCliSpawnPlan = async (command, args) => {
+	const trimmedCommand = command.trim();
+	if (!isWindows() || !trimmedCommand) return {
+		args,
+		command
+	};
+	const target = isPathLikeCommand(trimmedCommand) ? await inferWindowsNpmShimTarget(trimmedCommand) : await resolveWindowsBareCommand(trimmedCommand);
+	if (!target) return {
+		args,
+		command
+	};
+	return {
+		args: [...target.argsPrefix ?? [], ...args],
+		command: target.command
+	};
+};
+
 //#endregion
 //#region ../../packages/heterogeneous-agents/src/spawn/input/normalizeImage.ts
 const PNG_SIG = Buffer.from([
@@ -208615,6 +210138,19 @@ const buildAgentInput = async (agentType, prompt, options = {}) => {
 
 //#endregion
 //#region ../../packages/heterogeneous-agents/src/spawn/spawnAgent.ts
+/**
+* Invariant Claude Code CLI flags shared by every spawn site (desktop driver,
+* `lh hetero exec`). Permission mode and `--include-partial-messages` vary by
+* caller — the desktop UI wants live deltas + user-mode bypassPermissions, the
+* sandbox CLI may run as root and skip partials — so they're composed on top
+* of this base.
+*
+* `AskUserQuestion` is disabled because CC's CLI self-injects an
+* `is_error: "Answer questions?"` tool_result in `-p` mode before the host
+* can surface the questions, so the model falls back to plain-text prompting
+* anyway. Remove this once a local MCP-backed replacement is wired to
+* LobeHub's intervention UI.
+*/
 const CLAUDE_CODE_BASE_ARGS = [
 	"-p",
 	"--input-format",
@@ -208622,7 +210158,8 @@ const CLAUDE_CODE_BASE_ARGS = [
 	"--output-format",
 	"stream-json",
 	"--verbose",
-	"--include-partial-messages"
+	"--disallowedTools",
+	"AskUserQuestion"
 ];
 const isRunningAsRoot = () => process.getuid?.() === 0;
 const CLAUDE_CODE_PERMISSION_ARGS = () => isRunningAsRoot() ? [
@@ -208636,14 +210173,15 @@ const CODEX_REQUIRED_ARGS = [
 	"--skip-git-repo-check",
 	"--full-auto"
 ];
-const buildClaudeCodeArgs = (resumeSessionId, inputArgs, extraArgs) => [
+const buildClaudeCodeArgs = ({ extraArgs, includePartialMessages, inputArgs, resumeSessionId }) => [
 	...CLAUDE_CODE_BASE_ARGS,
+	...includePartialMessages ? ["--include-partial-messages"] : [],
 	...CLAUDE_CODE_PERMISSION_ARGS(),
 	...resumeSessionId ? ["--resume", resumeSessionId] : [],
 	...inputArgs,
 	...extraArgs
 ];
-const buildCodexArgs = (resumeSessionId, inputArgs, extraArgs) => resumeSessionId ? [
+const buildCodexArgs = ({ extraArgs, inputArgs, resumeSessionId }) => resumeSessionId ? [
 	"exec",
 	"resume",
 	...CODEX_REQUIRED_ARGS,
@@ -208657,11 +210195,11 @@ const buildCodexArgs = (resumeSessionId, inputArgs, extraArgs) => resumeSessionI
 	...inputArgs,
 	...extraArgs
 ];
-const buildSpawnArgs = (agentType, resumeSessionId, inputArgs, extraArgs) => {
-	switch (agentType) {
-		case "claude-code": return buildClaudeCodeArgs(resumeSessionId, inputArgs, extraArgs);
-		case "codex": return buildCodexArgs(resumeSessionId, inputArgs, extraArgs);
-		default: throw new Error(`spawnAgent: unsupported agent type "${agentType}"`);
+const buildSpawnArgs = (params) => {
+	switch (params.agentType) {
+		case "claude-code": return buildClaudeCodeArgs(params);
+		case "codex": return buildCodexArgs(params);
+		default: throw new Error(`spawnAgent: unsupported agent type "${params.agentType}"`);
 	}
 };
 const defaultCommand = (agentType) => agentType === "codex" ? "codex" : "claude";
@@ -208698,8 +210236,17 @@ const killProcessTree = (proc, signal) => {
 const spawnAgent = async (options) => {
 	const command = options.command || defaultCommand(options.agentType);
 	const inputPlan = await buildAgentInput(options.agentType, options.prompt, options.inputOptions);
-	const proc = spawn(command, buildSpawnArgs(options.agentType, options.resumeSessionId, inputPlan.args, options.extraArgs ?? []), {
-		cwd: options.cwd || process.cwd(),
+	const args = buildSpawnArgs({
+		agentType: options.agentType,
+		extraArgs: options.extraArgs ?? [],
+		includePartialMessages: options.includePartialMessages ?? false,
+		inputArgs: inputPlan.args,
+		resumeSessionId: options.resumeSessionId
+	});
+	const cwd = options.cwd || process.cwd();
+	const cliSpawnPlan = await resolveCliSpawnPlan(command, args);
+	const proc = spawn(cliSpawnPlan.command, cliSpawnPlan.args, {
+		cwd,
 		detached: process.platform !== "win32",
 		env: {
 			...process.env,
@@ -208711,6 +210258,13 @@ const spawnAgent = async (options) => {
 			"pipe"
 		]
 	});
+	const exit = new Promise((resolve, reject) => {
+		proc.on("exit", (code, signal) => resolve({
+			code,
+			signal
+		}));
+		proc.on("error", (err) => reject(err));
+	});
 	if (proc.stdin) proc.stdin.write(inputPlan.stdin, () => {
 		proc.stdin?.end();
 	});
@@ -208786,13 +210340,7 @@ const spawnAgent = async (options) => {
 				}
 			} };
 		} },
-		exit: new Promise((resolve, reject) => {
-			proc.on("exit", (code, signal) => resolve({
-				code,
-				signal
-			}));
-			proc.on("error", (err) => reject(err));
-		}),
+		exit,
 		kill: (signal = "SIGINT") => killProcessTree(proc, signal),
 		pid: proc.pid,
 		get sessionId() {
@@ -210657,6 +212205,7 @@ function registerMigrateCommand(program) {
 
 //#endregion
 //#region src/commands/model.ts
+const isVisibleModel = (model) => model.visible !== false;
 function registerModelCommand(program) {
 	const model = program.command("model").description("Manage AI models");
 	model.command("list <providerId>").description("List models for a provider").option("-L, --limit <n>", "Maximum number of items", "50").option("--enabled", "Only show enabled models").option("--type <type>", "Filter by model type (chat|embedding|tts|stt|image|video|text2music|realtime)").option("--json [fields]", "Output JSON, optionally specify fields (comma-separated)").action(async (providerId, options) => {
@@ -210666,7 +212215,7 @@ function registerModelCommand(program) {
 		if (options.enabled) input.enabled = true;
 		if (options.type) input.type = options.type;
 		const result = await client.aiModel.getAiProviderModelList.query(input);
-		let items = Array.isArray(result) ? result : result.items ?? [];
+		let items = (Array.isArray(result) ? result : result.items ?? []).filter(isVisibleModel);
 		if (options.type) items = items.filter((m) => m.type === options.type);
 		if (options.json !== void 0) {
 			const fields = typeof options.json === "string" ? options.json : void 0;
@@ -212067,7 +213616,7 @@ function registerReviewCommands(task) {
 			"CONFIG"
 		]);
 	});
-	rc.command("add <id>").description("Add a review rubric").requiredOption("-n, --name <name>", "Rubric name (e.g. \"内容准确性\")").option("--type <type>", "Rubric type (default: llm-rubric)", "llm-rubric").option("-t, --threshold <n>", "Pass threshold 0-100 (converted to 0-1)").option("-d, --description <text>", "Criteria description (for llm-rubric type)").option("--value <value>", "Expected value (for contains/equals type)").option("--pattern <pattern>", "Regex pattern (for regex type)").option("-w, --weight <n>", "Weight for scoring (default: 1)").option("--recursive", "Add to all subtasks as well").action(async (id, options) => {
+	rc.command("add <id>").description("Add a review rubric").requiredOption("-n, --name <name>", "Rubric name (e.g. \"Content Accuracy\")").option("--type <type>", "Rubric type (default: llm-rubric)", "llm-rubric").option("-t, --threshold <n>", "Pass threshold 0-100 (converted to 0-1)").option("-d, --description <text>", "Criteria description (for llm-rubric type)").option("--value <value>", "Expected value (for contains/equals type)").option("--pattern <pattern>", "Regex pattern (for regex type)").option("-w, --weight <n>", "Weight for scoring (default: 1)").option("--recursive", "Add to all subtasks as well").action(async (id, options) => {
 		const client = await getTrpcClient();
 		const buildConfig = () => {
 			switch (options.type) {
@@ -212964,7 +214513,6 @@ function createProgram() {
 	registerAgentCommand(program);
 	registerAgentGroupCommand(program);
 	registerBotCommand(program);
-	registerCronCommand(program);
 	registerGenerateCommand(program);
 	registerFileCommand(program);
 	registerHeteroCommand(program);