@gatanot/qualia_web 0.1.0

package/build/server/chunks/config-d3FC8naq.js

@@ -0,0 +1,4907 @@
+import { p as pendingSteering } from './chat-steering-DTefLITL.js';
+import { D as DEFAULT_SYSTEM_PROMPT, S as SYSTEM_CONTEXT } from './prompts-tcGD1LCs.js';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname, resolve, isAbsolute, sep } from 'node:path';
+import { stat, readFile, mkdir, rm, writeFile, chmod, rename } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { spawn, execSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { g as getDefaultExportFromCjs } from './index.js-N7Sh42pC.js';
+import require$$0 from 'fs';
+import require$$1 from 'path';
+import require$$2 from 'util';
+
+var lib = {exports: {}};
+
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+var util = {};
+
+var hasRequiredUtil;
+
+function requireUtil () {
+	if (hasRequiredUtil) return util;
+	hasRequiredUtil = 1;
+
+	util.getBooleanOption = (options, key) => {
+		let value = false;
+		if (key in options && typeof (value = options[key]) !== 'boolean') {
+			throw new TypeError(`Expected the "${key}" option to be a boolean`);
+		}
+		return value;
+	};
+
+	util.cppdb = Symbol();
+	util.inspect = Symbol.for('nodejs.util.inspect.custom');
+	return util;
+}
+
+var sqliteError;
+var hasRequiredSqliteError;
+
+function requireSqliteError () {
+	if (hasRequiredSqliteError) return sqliteError;
+	hasRequiredSqliteError = 1;
+	const descriptor = { value: 'SqliteError', writable: true, enumerable: false, configurable: true };
+
+	function SqliteError(message, code) {
+		if (new.target !== SqliteError) {
+			return new SqliteError(message, code);
+		}
+		if (typeof code !== 'string') {
+			throw new TypeError('Expected second argument to be a string');
+		}
+		Error.call(this, message);
+		descriptor.value = '' + message;
+		Object.defineProperty(this, 'message', descriptor);
+		Error.captureStackTrace(this, SqliteError);
+		this.code = code;
+	}
+	Object.setPrototypeOf(SqliteError, Error);
+	Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+	Object.defineProperty(SqliteError.prototype, 'name', descriptor);
+	sqliteError = SqliteError;
+	return sqliteError;
+}
+
+var bindings = {exports: {}};
+
+var fileUriToPath_1;
+var hasRequiredFileUriToPath;
+
+function requireFileUriToPath () {
+	if (hasRequiredFileUriToPath) return fileUriToPath_1;
+	hasRequiredFileUriToPath = 1;
+	/**
+	 * Module dependencies.
+	 */
+
+	var sep = require$$1.sep || '/';
+
+	/**
+	 * Module exports.
+	 */
+
+	fileUriToPath_1 = fileUriToPath;
+
+	/**
+	 * File URI to Path function.
+	 *
+	 * @param {String} uri
+	 * @return {String} path
+	 * @api public
+	 */
+
+	function fileUriToPath (uri) {
+	  if ('string' != typeof uri ||
+	      uri.length <= 7 ||
+	      'file://' != uri.substring(0, 7)) {
+	    throw new TypeError('must pass in a file:// URI to convert to a file path');
+	  }
+
+	  var rest = decodeURI(uri.substring(7));
+	  var firstSlash = rest.indexOf('/');
+	  var host = rest.substring(0, firstSlash);
+	  var path = rest.substring(firstSlash + 1);
+
+	  // 2.  Scheme Definition
+	  // As a special case, <host> can be the string "localhost" or the empty
+	  // string; this is interpreted as "the machine from which the URL is
+	  // being interpreted".
+	  if ('localhost' == host) host = '';
+
+	  if (host) {
+	    host = sep + sep + host;
+	  }
+
+	  // 3.2  Drives, drive letters, mount points, file system root
+	  // Drive letters are mapped into the top of a file URI in various ways,
+	  // depending on the implementation; some applications substitute
+	  // vertical bar ("|") for the colon after the drive letter, yielding
+	  // "file:///c|/tmp/test.txt".  In some cases, the colon is left
+	  // unchanged, as in "file:///c:/tmp/test.txt".  In other cases, the
+	  // colon is simply omitted, as in "file:///c/tmp/test.txt".
+	  path = path.replace(/^(.+)\|/, '$1:');
+
+	  // for Windows, we need to invert the path separators from what a URI uses
+	  if (sep == '\\') {
+	    path = path.replace(/\//g, '\\');
+	  }
+
+	  if (/^.+\:/.test(path)) ; else {
+	    // unix path…
+	    path = sep + path;
+	  }
+
+	  return host + path;
+	}
+	return fileUriToPath_1;
+}
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredBindings;
+
+function requireBindings () {
+	if (hasRequiredBindings) return bindings.exports;
+	hasRequiredBindings = 1;
+	(function (module, exports) {
+		var fs = require$$0,
+		  path = require$$1,
+		  fileURLToPath = requireFileUriToPath(),
+		  join = path.join,
+		  dirname = path.dirname,
+		  exists =
+		    (fs.accessSync &&
+		      function(path) {
+		        try {
+		          fs.accessSync(path);
+		        } catch (e) {
+		          return false;
+		        }
+		        return true;
+		      }) ||
+		    fs.existsSync ||
+		    path.existsSync,
+		  defaults = {
+		    arrow: process.env.NODE_BINDINGS_ARROW || ' → ',
+		    compiled: process.env.NODE_BINDINGS_COMPILED_DIR || 'compiled',
+		    platform: process.platform,
+		    arch: process.arch,
+		    nodePreGyp:
+		      'node-v' +
+		      process.versions.modules +
+		      '-' +
+		      process.platform +
+		      '-' +
+		      process.arch,
+		    version: process.versions.node,
+		    bindings: 'bindings.node',
+		    try: [
+		      // node-gyp's linked version in the "build" dir
+		      ['module_root', 'build', 'bindings'],
+		      // node-waf and gyp_addon (a.k.a node-gyp)
+		      ['module_root', 'build', 'Debug', 'bindings'],
+		      ['module_root', 'build', 'Release', 'bindings'],
+		      // Debug files, for development (legacy behavior, remove for node v0.9)
+		      ['module_root', 'out', 'Debug', 'bindings'],
+		      ['module_root', 'Debug', 'bindings'],
+		      // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+		      ['module_root', 'out', 'Release', 'bindings'],
+		      ['module_root', 'Release', 'bindings'],
+		      // Legacy from node-waf, node <= 0.4.x
+		      ['module_root', 'build', 'default', 'bindings'],
+		      // Production "Release" buildtype binary (meh...)
+		      ['module_root', 'compiled', 'version', 'platform', 'arch', 'bindings'],
+		      // node-qbs builds
+		      ['module_root', 'addon-build', 'release', 'install-root', 'bindings'],
+		      ['module_root', 'addon-build', 'debug', 'install-root', 'bindings'],
+		      ['module_root', 'addon-build', 'default', 'install-root', 'bindings'],
+		      // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+		      ['module_root', 'lib', 'binding', 'nodePreGyp', 'bindings']
+		    ]
+		  };
+
+		/**
+		 * The main `bindings()` function loads the compiled bindings for a given module.
+		 * It uses V8's Error API to determine the parent filename that this function is
+		 * being invoked from, which is then used to find the root directory.
+		 */
+
+		function bindings(opts) {
+		  // Argument surgery
+		  if (typeof opts == 'string') {
+		    opts = { bindings: opts };
+		  } else if (!opts) {
+		    opts = {};
+		  }
+
+		  // maps `defaults` onto `opts` object
+		  Object.keys(defaults).map(function(i) {
+		    if (!(i in opts)) opts[i] = defaults[i];
+		  });
+
+		  // Get the module root
+		  if (!opts.module_root) {
+		    opts.module_root = exports.getRoot(exports.getFileName());
+		  }
+
+		  // Ensure the given bindings name ends with .node
+		  if (path.extname(opts.bindings) != '.node') {
+		    opts.bindings += '.node';
+		  }
+
+		  // https://github.com/webpack/webpack/issues/4175#issuecomment-342931035
+		  var requireFunc =
+		    typeof __webpack_require__ === 'function'
+		      ? __non_webpack_require__
+		      : commonjsRequire;
+
+		  var tries = [],
+		    i = 0,
+		    l = opts.try.length,
+		    n,
+		    b,
+		    err;
+
+		  for (; i < l; i++) {
+		    n = join.apply(
+		      null,
+		      opts.try[i].map(function(p) {
+		        return opts[p] || p;
+		      })
+		    );
+		    tries.push(n);
+		    try {
+		      b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+		      if (!opts.path) {
+		        b.path = n;
+		      }
+		      return b;
+		    } catch (e) {
+		      if (e.code !== 'MODULE_NOT_FOUND' &&
+		          e.code !== 'QUALIFIED_PATH_RESOLUTION_FAILED' &&
+		          !/not find/i.test(e.message)) {
+		        throw e;
+		      }
+		    }
+		  }
+
+		  err = new Error(
+		    'Could not locate the bindings file. Tried:\n' +
+		      tries
+		        .map(function(a) {
+		          return opts.arrow + a;
+		        })
+		        .join('\n')
+		  );
+		  err.tries = tries;
+		  throw err;
+		}
+		module.exports = exports = bindings;
+
+		/**
+		 * Gets the filename of the JavaScript file that invokes this function.
+		 * Used to help find the root directory of a module.
+		 * Optionally accepts an filename argument to skip when searching for the invoking filename
+		 */
+
+		exports.getFileName = function getFileName(calling_file) {
+		  var origPST = Error.prepareStackTrace,
+		    origSTL = Error.stackTraceLimit,
+		    dummy = {},
+		    fileName;
+
+		  Error.stackTraceLimit = 10;
+
+		  Error.prepareStackTrace = function(e, st) {
+		    for (var i = 0, l = st.length; i < l; i++) {
+		      fileName = st[i].getFileName();
+		      if (fileName !== __filename) {
+		        if (calling_file) {
+		          if (fileName !== calling_file) {
+		            return;
+		          }
+		        } else {
+		          return;
+		        }
+		      }
+		    }
+		  };
+
+		  // run the 'prepareStackTrace' function above
+		  Error.captureStackTrace(dummy);
+		  dummy.stack;
+
+		  // cleanup
+		  Error.prepareStackTrace = origPST;
+		  Error.stackTraceLimit = origSTL;
+
+		  // handle filename that starts with "file://"
+		  var fileSchema = 'file://';
+		  if (fileName.indexOf(fileSchema) === 0) {
+		    fileName = fileURLToPath(fileName);
+		  }
+
+		  return fileName;
+		};
+
+		/**
+		 * Gets the root directory of a module, given an arbitrary filename
+		 * somewhere in the module tree. The "root directory" is the directory
+		 * containing the `package.json` file.
+		 *
+		 *   In:  /home/nate/node-native-module/lib/index.js
+		 *   Out: /home/nate/node-native-module
+		 */
+
+		exports.getRoot = function getRoot(file) {
+		  var dir = dirname(file),
+		    prev;
+		  while (true) {
+		    if (dir === '.') {
+		      // Avoids an infinite loop in rare cases, like the REPL
+		      dir = process.cwd();
+		    }
+		    if (
+		      exists(join(dir, 'package.json')) ||
+		      exists(join(dir, 'node_modules'))
+		    ) {
+		      // Found the 'package.json' file or 'node_modules' dir; we're done
+		      return dir;
+		    }
+		    if (prev === dir) {
+		      // Got to the top
+		      throw new Error(
+		        'Could not find module root given file: "' +
+		          file +
+		          '". Do you have a `package.json` file? '
+		      );
+		    }
+		    // Try the parent dir next
+		    prev = dir;
+		    dir = join(dir, '..');
+		  }
+		}; 
+	} (bindings, bindings.exports));
+	return bindings.exports;
+}
+
+var wrappers = {};
+
+var hasRequiredWrappers;
+
+function requireWrappers () {
+	if (hasRequiredWrappers) return wrappers;
+	hasRequiredWrappers = 1;
+	const { cppdb } = requireUtil();
+
+	wrappers.prepare = function prepare(sql) {
+		return this[cppdb].prepare(sql, this, false);
+	};
+
+	wrappers.exec = function exec(sql) {
+		this[cppdb].exec(sql);
+		return this;
+	};
+
+	wrappers.close = function close() {
+		this[cppdb].close();
+		return this;
+	};
+
+	wrappers.loadExtension = function loadExtension(...args) {
+		this[cppdb].loadExtension(...args);
+		return this;
+	};
+
+	wrappers.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+		this[cppdb].defaultSafeIntegers(...args);
+		return this;
+	};
+
+	wrappers.unsafeMode = function unsafeMode(...args) {
+		this[cppdb].unsafeMode(...args);
+		return this;
+	};
+
+	wrappers.getters = {
+		name: {
+			get: function name() { return this[cppdb].name; },
+			enumerable: true,
+		},
+		open: {
+			get: function open() { return this[cppdb].open; },
+			enumerable: true,
+		},
+		inTransaction: {
+			get: function inTransaction() { return this[cppdb].inTransaction; },
+			enumerable: true,
+		},
+		readonly: {
+			get: function readonly() { return this[cppdb].readonly; },
+			enumerable: true,
+		},
+		memory: {
+			get: function memory() { return this[cppdb].memory; },
+			enumerable: true,
+		},
+	};
+	return wrappers;
+}
+
+var transaction;
+var hasRequiredTransaction;
+
+function requireTransaction () {
+	if (hasRequiredTransaction) return transaction;
+	hasRequiredTransaction = 1;
+	const { cppdb } = requireUtil();
+	const controllers = new WeakMap();
+
+	transaction = function transaction(fn) {
+		if (typeof fn !== 'function') throw new TypeError('Expected first argument to be a function');
+
+		const db = this[cppdb];
+		const controller = getController(db, this);
+		const { apply } = Function.prototype;
+
+		// Each version of the transaction function has these same properties
+		const properties = {
+			default: { value: wrapTransaction(apply, fn, db, controller.default) },
+			deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+			immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+			exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+			database: { value: this, enumerable: true },
+		};
+
+		Object.defineProperties(properties.default.value, properties);
+		Object.defineProperties(properties.deferred.value, properties);
+		Object.defineProperties(properties.immediate.value, properties);
+		Object.defineProperties(properties.exclusive.value, properties);
+
+		// Return the default version of the transaction function
+		return properties.default.value;
+	};
+
+	// Return the database's cached transaction controller, or create a new one
+	const getController = (db, self) => {
+		let controller = controllers.get(db);
+		if (!controller) {
+			const shared = {
+				commit: db.prepare('COMMIT', self, false),
+				rollback: db.prepare('ROLLBACK', self, false),
+				savepoint: db.prepare('SAVEPOINT `\t_bs3.\t`', self, false),
+				release: db.prepare('RELEASE `\t_bs3.\t`', self, false),
+				rollbackTo: db.prepare('ROLLBACK TO `\t_bs3.\t`', self, false),
+			};
+			controllers.set(db, controller = {
+				default: Object.assign({ begin: db.prepare('BEGIN', self, false) }, shared),
+				deferred: Object.assign({ begin: db.prepare('BEGIN DEFERRED', self, false) }, shared),
+				immediate: Object.assign({ begin: db.prepare('BEGIN IMMEDIATE', self, false) }, shared),
+				exclusive: Object.assign({ begin: db.prepare('BEGIN EXCLUSIVE', self, false) }, shared),
+			});
+		}
+		return controller;
+	};
+
+	// Return a new transaction function by wrapping the given function
+	const wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+		let before, after, undo;
+		if (db.inTransaction) {
+			before = savepoint;
+			after = release;
+			undo = rollbackTo;
+		} else {
+			before = begin;
+			after = commit;
+			undo = rollback;
+		}
+		before.run();
+		try {
+			const result = apply.call(fn, this, arguments);
+			if (result && typeof result.then === 'function') {
+				throw new TypeError('Transaction function cannot return a promise');
+			}
+			after.run();
+			return result;
+		} catch (ex) {
+			if (db.inTransaction) {
+				undo.run();
+				if (undo !== rollback) after.run();
+			}
+			throw ex;
+		}
+	};
+	return transaction;
+}
+
+var pragma;
+var hasRequiredPragma;
+
+function requirePragma () {
+	if (hasRequiredPragma) return pragma;
+	hasRequiredPragma = 1;
+	const { getBooleanOption, cppdb } = requireUtil();
+
+	pragma = function pragma(source, options) {
+		if (options == null) options = {};
+		if (typeof source !== 'string') throw new TypeError('Expected first argument to be a string');
+		if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
+		const simple = getBooleanOption(options, 'simple');
+
+		const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+		return simple ? stmt.pluck().get() : stmt.all();
+	};
+	return pragma;
+}
+
+var backup;
+var hasRequiredBackup;
+
+function requireBackup () {
+	if (hasRequiredBackup) return backup;
+	hasRequiredBackup = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const { promisify } = require$$2;
+	const { cppdb } = requireUtil();
+	const fsAccess = promisify(fs.access);
+
+	backup = async function backup(filename, options) {
+		if (options == null) options = {};
+
+		// Validate arguments
+		if (typeof filename !== 'string') throw new TypeError('Expected first argument to be a string');
+		if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
+
+		// Interpret options
+		filename = filename.trim();
+		const attachedName = 'attached' in options ? options.attached : 'main';
+		const handler = 'progress' in options ? options.progress : null;
+
+		// Validate interpreted options
+		if (!filename) throw new TypeError('Backup filename cannot be an empty string');
+		if (filename === ':memory:') throw new TypeError('Invalid backup filename ":memory:"');
+		if (typeof attachedName !== 'string') throw new TypeError('Expected the "attached" option to be a string');
+		if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+		if (handler != null && typeof handler !== 'function') throw new TypeError('Expected the "progress" option to be a function');
+
+		// Make sure the specified directory exists
+		await fsAccess(path.dirname(filename)).catch(() => {
+			throw new TypeError('Cannot save backup because the directory does not exist');
+		});
+
+		const isNewFile = await fsAccess(filename).then(() => false, () => true);
+		return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+	};
+
+	const runBackup = (backup, handler) => {
+		let rate = 0;
+		let useDefault = true;
+
+		return new Promise((resolve, reject) => {
+			setImmediate(function step() {
+				try {
+					const progress = backup.transfer(rate);
+					if (!progress.remainingPages) {
+						backup.close();
+						resolve(progress);
+						return;
+					}
+					if (useDefault) {
+						useDefault = false;
+						rate = 100;
+					}
+					if (handler) {
+						const ret = handler(progress);
+						if (ret !== undefined) {
+							if (typeof ret === 'number' && ret === ret) rate = Math.max(0, Math.min(0x7fffffff, Math.round(ret)));
+							else throw new TypeError('Expected progress callback to return a number or undefined');
+						}
+					}
+					setImmediate(step);
+				} catch (err) {
+					backup.close();
+					reject(err);
+				}
+			});
+		});
+	};
+	return backup;
+}
+
+var serialize;
+var hasRequiredSerialize;
+
+function requireSerialize () {
+	if (hasRequiredSerialize) return serialize;
+	hasRequiredSerialize = 1;
+	const { cppdb } = requireUtil();
+
+	serialize = function serialize(options) {
+		if (options == null) options = {};
+
+		// Validate arguments
+		if (typeof options !== 'object') throw new TypeError('Expected first argument to be an options object');
+
+		// Interpret and validate options
+		const attachedName = 'attached' in options ? options.attached : 'main';
+		if (typeof attachedName !== 'string') throw new TypeError('Expected the "attached" option to be a string');
+		if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+
+		return this[cppdb].serialize(attachedName);
+	};
+	return serialize;
+}
+
+var _function;
+var hasRequired_function;
+
+function require_function () {
+	if (hasRequired_function) return _function;
+	hasRequired_function = 1;
+	const { getBooleanOption, cppdb } = requireUtil();
+
+	_function = function defineFunction(name, options, fn) {
+		// Apply defaults
+		if (options == null) options = {};
+		if (typeof options === 'function') { fn = options; options = {}; }
+
+		// Validate arguments
+		if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
+		if (typeof fn !== 'function') throw new TypeError('Expected last argument to be a function');
+		if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
+		if (!name) throw new TypeError('User-defined function name cannot be an empty string');
+
+		// Interpret options
+		const safeIntegers = 'safeIntegers' in options ? +getBooleanOption(options, 'safeIntegers') : 2;
+		const deterministic = getBooleanOption(options, 'deterministic');
+		const directOnly = getBooleanOption(options, 'directOnly');
+		const varargs = getBooleanOption(options, 'varargs');
+		let argCount = -1;
+
+		// Determine argument count
+		if (!varargs) {
+			argCount = fn.length;
+			if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError('Expected function.length to be a positive integer');
+			if (argCount > 100) throw new RangeError('User-defined functions cannot have more than 100 arguments');
+		}
+
+		this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+		return this;
+	};
+	return _function;
+}
+
+var aggregate;
+var hasRequiredAggregate;
+
+function requireAggregate () {
+	if (hasRequiredAggregate) return aggregate;
+	hasRequiredAggregate = 1;
+	const { getBooleanOption, cppdb } = requireUtil();
+
+	aggregate = function defineAggregate(name, options) {
+		// Validate arguments
+		if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
+		if (typeof options !== 'object' || options === null) throw new TypeError('Expected second argument to be an options object');
+		if (!name) throw new TypeError('User-defined function name cannot be an empty string');
+
+		// Interpret options
+		const start = 'start' in options ? options.start : null;
+		const step = getFunctionOption(options, 'step', true);
+		const inverse = getFunctionOption(options, 'inverse', false);
+		const result = getFunctionOption(options, 'result', false);
+		const safeIntegers = 'safeIntegers' in options ? +getBooleanOption(options, 'safeIntegers') : 2;
+		const deterministic = getBooleanOption(options, 'deterministic');
+		const directOnly = getBooleanOption(options, 'directOnly');
+		const varargs = getBooleanOption(options, 'varargs');
+		let argCount = -1;
+
+		// Determine argument count
+		if (!varargs) {
+			argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+			if (argCount > 0) argCount -= 1;
+			if (argCount > 100) throw new RangeError('User-defined functions cannot have more than 100 arguments');
+		}
+
+		this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+		return this;
+	};
+
+	const getFunctionOption = (options, key, required) => {
+		const value = key in options ? options[key] : null;
+		if (typeof value === 'function') return value;
+		if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+		if (required) throw new TypeError(`Missing required option "${key}"`);
+		return null;
+	};
+
+	const getLength = ({ length }) => {
+		if (Number.isInteger(length) && length >= 0) return length;
+		throw new TypeError('Expected function.length to be a positive integer');
+	};
+	return aggregate;
+}
+
+var table;
+var hasRequiredTable;
+
+function requireTable () {
+	if (hasRequiredTable) return table;
+	hasRequiredTable = 1;
+	const { cppdb } = requireUtil();
+
+	table = function defineTable(name, factory) {
+		// Validate arguments
+		if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
+		if (!name) throw new TypeError('Virtual table module name cannot be an empty string');
+
+		// Determine whether the module is eponymous-only or not
+		let eponymous = false;
+		if (typeof factory === 'object' && factory !== null) {
+			eponymous = true;
+			factory = defer(parseTableDefinition(factory, 'used', name));
+		} else {
+			if (typeof factory !== 'function') throw new TypeError('Expected second argument to be a function or a table definition object');
+			factory = wrapFactory(factory);
+		}
+
+		this[cppdb].table(factory, name, eponymous);
+		return this;
+	};
+
+	function wrapFactory(factory) {
+		return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+			const thisObject = {
+				module: moduleName,
+				database: databaseName,
+				table: tableName,
+			};
+
+			// Generate a new table definition by invoking the factory
+			const def = apply.call(factory, thisObject, args);
+			if (typeof def !== 'object' || def === null) {
+				throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+			}
+
+			return parseTableDefinition(def, 'returned', moduleName);
+		};
+	}
+
+	function parseTableDefinition(def, verb, moduleName) {
+		// Validate required properties
+		if (!hasOwnProperty.call(def, 'rows')) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+		}
+		if (!hasOwnProperty.call(def, 'columns')) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+		}
+
+		// Validate "rows" property
+		const rows = def.rows;
+		if (typeof rows !== 'function' || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+		}
+
+		// Validate "columns" property
+		let columns = def.columns;
+		if (!Array.isArray(columns) || !(columns = [...columns]).every(x => typeof x === 'string')) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+		}
+		if (columns.length !== new Set(columns).size) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+		}
+		if (!columns.length) {
+			throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+		}
+
+		// Validate "parameters" property
+		let parameters;
+		if (hasOwnProperty.call(def, 'parameters')) {
+			parameters = def.parameters;
+			if (!Array.isArray(parameters) || !(parameters = [...parameters]).every(x => typeof x === 'string')) {
+				throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+			}
+		} else {
+			parameters = inferParameters(rows);
+		}
+		if (parameters.length !== new Set(parameters).size) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+		}
+		if (parameters.length > 32) {
+			throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+		}
+		for (const parameter of parameters) {
+			if (columns.includes(parameter)) {
+				throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+			}
+		}
+
+		// Validate "safeIntegers" option
+		let safeIntegers = 2;
+		if (hasOwnProperty.call(def, 'safeIntegers')) {
+			const bool = def.safeIntegers;
+			if (typeof bool !== 'boolean') {
+				throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+			}
+			safeIntegers = +bool;
+		}
+
+		// Validate "directOnly" option
+		let directOnly = false;
+		if (hasOwnProperty.call(def, 'directOnly')) {
+			directOnly = def.directOnly;
+			if (typeof directOnly !== 'boolean') {
+				throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+			}
+		}
+
+		// Generate SQL for the virtual table definition
+		const columnDefinitions = [
+			...parameters.map(identifier).map(str => `${str} HIDDEN`),
+			...columns.map(identifier),
+		];
+		return [
+			`CREATE TABLE x(${columnDefinitions.join(', ')});`,
+			wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+			parameters,
+			safeIntegers,
+			directOnly,
+		];
+	}
+
+	function wrapGenerator(generator, columnMap, moduleName) {
+		return function* virtualTable(...args) {
+			/*
+				We must defensively clone any buffers in the arguments, because
+				otherwise the generator could mutate one of them, which would cause
+				us to return incorrect values for hidden columns, potentially
+				corrupting the database.
+			 */
+			const output = args.map(x => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+			for (let i = 0; i < columnMap.size; ++i) {
+				output.push(null); // Fill with nulls to prevent gaps in array (v8 optimization)
+			}
+			for (const row of generator(...args)) {
+				if (Array.isArray(row)) {
+					extractRowArray(row, output, columnMap.size, moduleName);
+					yield output;
+				} else if (typeof row === 'object' && row !== null) {
+					extractRowObject(row, output, columnMap, moduleName);
+					yield output;
+				} else {
+					throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+				}
+			}
+		};
+	}
+
+	function extractRowArray(row, output, columnCount, moduleName) {
+		if (row.length !== columnCount) {
+			throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+		}
+		const offset = output.length - columnCount;
+		for (let i = 0; i < columnCount; ++i) {
+			output[i + offset] = row[i];
+		}
+	}
+
+	function extractRowObject(row, output, columnMap, moduleName) {
+		let count = 0;
+		for (const key of Object.keys(row)) {
+			const index = columnMap.get(key);
+			if (index === undefined) {
+				throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+			}
+			output[index] = row[key];
+			count += 1;
+		}
+		if (count !== columnMap.size) {
+			throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+		}
+	}
+
+	function inferParameters({ length }) {
+		if (!Number.isInteger(length) || length < 0) {
+			throw new TypeError('Expected function.length to be a positive integer');
+		}
+		const params = [];
+		for (let i = 0; i < length; ++i) {
+			params.push(`$${i + 1}`);
+		}
+		return params;
+	}
+
+	const { hasOwnProperty } = Object.prototype;
+	const { apply } = Function.prototype;
+	const GeneratorFunctionPrototype = Object.getPrototypeOf(function*(){});
+	const identifier = str => `"${str.replace(/"/g, '""')}"`;
+	const defer = x => () => x;
+	return table;
+}
+
+var inspect;
+var hasRequiredInspect;
+
+function requireInspect () {
+	if (hasRequiredInspect) return inspect;
+	hasRequiredInspect = 1;
+	const DatabaseInspection = function Database() {};
+
+	inspect = function inspect(depth, opts) {
+		return Object.assign(new DatabaseInspection(), this);
+	};
+	return inspect;
+}
+
+var database;
+var hasRequiredDatabase;
+
+function requireDatabase () {
+	if (hasRequiredDatabase) return database;
+	hasRequiredDatabase = 1;
+	const fs = require$$0;
+	const path = require$$1;
+	const util = requireUtil();
+	const SqliteError = requireSqliteError();
+
+	let DEFAULT_ADDON;
+
+	function Database(filenameGiven, options) {
+		if (new.target == null) {
+			return new Database(filenameGiven, options);
+		}
+
+		// Apply defaults
+		let buffer;
+		if (Buffer.isBuffer(filenameGiven)) {
+			buffer = filenameGiven;
+			filenameGiven = ':memory:';
+		}
+		if (filenameGiven == null) filenameGiven = '';
+		if (options == null) options = {};
+
+		// Validate arguments
+		if (typeof filenameGiven !== 'string') throw new TypeError('Expected first argument to be a string');
+		if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
+		if ('readOnly' in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+		if ('memory' in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+
+		// Interpret options
+		const filename = filenameGiven.trim();
+		const anonymous = filename === '' || filename === ':memory:';
+		const readonly = util.getBooleanOption(options, 'readonly');
+		const fileMustExist = util.getBooleanOption(options, 'fileMustExist');
+		const timeout = 'timeout' in options ? options.timeout : 5000;
+		const verbose = 'verbose' in options ? options.verbose : null;
+		const nativeBinding = 'nativeBinding' in options ? options.nativeBinding : null;
+
+		// Validate interpreted options
+		if (readonly && anonymous && !buffer) throw new TypeError('In-memory/temporary databases cannot be readonly');
+		if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+		if (timeout > 0x7fffffff) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+		if (verbose != null && typeof verbose !== 'function') throw new TypeError('Expected the "verbose" option to be a function');
+		if (nativeBinding != null && typeof nativeBinding !== 'string' && typeof nativeBinding !== 'object') throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+
+		// Load the native addon
+		let addon;
+		if (nativeBinding == null) {
+			addon = DEFAULT_ADDON || (DEFAULT_ADDON = requireBindings()('better_sqlite3.node'));
+		} else if (typeof nativeBinding === 'string') {
+			// See <https://webpack.js.org/api/module-variables/#__non_webpack_require__-webpack-specific>
+			const requireFunc = typeof __non_webpack_require__ === 'function' ? __non_webpack_require__ : commonjsRequire;
+			addon = requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, '.node'));
+		} else {
+			// See <https://github.com/WiseLibs/better-sqlite3/issues/972>
+			addon = nativeBinding;
+		}
+
+		if (!addon.isInitialized) {
+			addon.setErrorConstructor(SqliteError);
+			addon.isInitialized = true;
+		}
+
+		// Make sure the specified directory exists
+		if (!anonymous && !filename.startsWith('file:') && !fs.existsSync(path.dirname(filename))) {
+			throw new TypeError('Cannot open database because the directory does not exist');
+		}
+
+		Object.defineProperties(this, {
+			[util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+			...wrappers.getters,
+		});
+	}
+
+	const wrappers = requireWrappers();
+	Database.prototype.prepare = wrappers.prepare;
+	Database.prototype.transaction = requireTransaction();
+	Database.prototype.pragma = requirePragma();
+	Database.prototype.backup = requireBackup();
+	Database.prototype.serialize = requireSerialize();
+	Database.prototype.function = require_function();
+	Database.prototype.aggregate = requireAggregate();
+	Database.prototype.table = requireTable();
+	Database.prototype.loadExtension = wrappers.loadExtension;
+	Database.prototype.exec = wrappers.exec;
+	Database.prototype.close = wrappers.close;
+	Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+	Database.prototype.unsafeMode = wrappers.unsafeMode;
+	Database.prototype[util.inspect] = requireInspect();
+
+	database = Database;
+	return database;
+}
+
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib.exports;
+	hasRequiredLib = 1;
+	lib.exports = requireDatabase();
+	lib.exports.SqliteError = requireSqliteError();
+	return lib.exports;
+}
+
+var libExports = requireLib();
+var Database = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
+//#region ../core/dist/ai/models.js
+var OPENAI_MODELS = [{
+	id: "gpt-4o",
+	name: "GPT-4o",
+	contextWindow: 128e3,
+	supportsReasoning: false,
+	reasoningEffortValues: [],
+	supportsVision: false
+}, {
+	id: "gpt-4o-mini",
+	name: "GPT-4o Mini",
+	contextWindow: 128e3,
+	supportsReasoning: false,
+	reasoningEffortValues: [],
+	supportsVision: false
+}];
+var DEEPSEEK_MODELS = [{
+	id: "deepseek-v4-pro",
+	name: "DeepSeek V4 Pro",
+	contextWindow: 1048576,
+	supportsReasoning: true,
+	reasoningEffortValues: ["high", "max"],
+	supportsVision: false
+}, {
+	id: "deepseek-v4-flash",
+	name: "DeepSeek V4 Flash",
+	contextWindow: 1048576,
+	supportsReasoning: true,
+	reasoningEffortValues: ["high", "max"],
+	supportsVision: false
+}];
+var XIAOMI_MODELS = [{
+	id: "mimo-v2.5",
+	name: "MiMo V2.5",
+	contextWindow: 1048576,
+	supportsReasoning: true,
+	reasoningEffortValues: [],
+	supportsVision: true
+}, {
+	id: "mimo-v2.5-pro",
+	name: "MiMo V2.5 Pro",
+	contextWindow: 1048576,
+	supportsReasoning: true,
+	reasoningEffortValues: [],
+	supportsVision: false
+}];
+function getDefaultModels(type) {
+	switch (type) {
+		case "openai": return [...OPENAI_MODELS];
+		case "deepseek": return [...DEEPSEEK_MODELS];
+		case "xiaomi": return [...XIAOMI_MODELS];
+		default: return [];
+	}
+}
+//#endregion
+//#region ../core/dist/ai/utils.js
+/**
+* 供应商请求错误
+*/
+var ProviderError = class extends Error {
+	status;
+	body;
+	constructor(message, status, body) {
+		super(message);
+		this.status = status;
+		this.body = body;
+		this.name = "ProviderError";
+	}
+};
+/**
+* 异步延时
+* @param ms - 毫秒
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* 带自动重试的 fetch 封装
+*
+* 仅对 5xx 错误和网络错误进行指数退避重试。
+* 4xx 错误直接抛出 ProviderError，不重试。
+*
+* @param fetchFn - fetch 调用工厂函数
+* @param maxRetries - 最大重试次数
+* @param baseDelayMs - 基础延迟（毫秒），每次重试延迟加倍
+* @returns Response
+* @throws ProviderError
+*/
+async function fetchWithRetry(fetchFn, maxRetries, baseDelayMs = 1e3) {
+	let lastError;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		try {
+			const response = await fetchFn();
+			if (response.ok) return response;
+			if (response.status < 500 || attempt === maxRetries) {
+				const body = await response.json().catch(() => null);
+				throw new ProviderError(`API returned status ${response.status}`, response.status, body);
+			}
+		} catch (error) {
+			if (error instanceof ProviderError) throw error;
+			lastError = error;
+		}
+		if (attempt < maxRetries) await sleep(baseDelayMs * Math.pow(2, attempt));
+	}
+	throw lastError;
+}
+/**
+* 解析 SSE (Server-Sent Events) 流为 StreamChunk 异步生成器
+*
+* @param reader - ReadableStream reader
+* @returns AsyncGenerator<StreamChunk>
+*/
+async function* parseSSEStream(reader) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (!trimmed || !trimmed.startsWith("data:")) continue;
+				const data = trimmed.slice(5).trim();
+				if (data === "[DONE]") return;
+				try {
+					const parsed = JSON.parse(data);
+					const choice = parsed.choices?.[0];
+					if (!choice) continue;
+					const delta = choice.delta || {};
+					const rawUsage = parsed.usage || choice.usage;
+					yield {
+						content: delta.content || "",
+						reasoning_content: delta.reasoning_content || "",
+						tool_calls: extractToolCalls(delta.tool_calls),
+						finish_reason: choice.finish_reason || null,
+						usage: rawUsage ? parseUsage(rawUsage) : void 0
+					};
+				} catch {}
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+function extractToolCalls(raw) {
+	if (!Array.isArray(raw)) return [];
+	return raw.map((tc) => ({
+		index: tc.index ?? 0,
+		id: tc.id,
+		type: tc.type,
+		function: tc.function ? {
+			name: tc.function.name,
+			arguments: tc.function.arguments
+		} : void 0
+	}));
+}
+/**
+* 将 API 返回的原始 usage 对象解析为类型化的 Usage
+*
+* @param raw - API 响应的 usage 字段
+*/
+function parseUsage(raw) {
+	return {
+		prompt_tokens: raw.prompt_tokens ?? 0,
+		completion_tokens: raw.completion_tokens ?? 0,
+		total_tokens: raw.total_tokens ?? 0,
+		prompt_cache_hit_tokens: raw.prompt_cache_hit_tokens,
+		prompt_cache_miss_tokens: raw.prompt_cache_miss_tokens,
+		completion_tokens_details: raw.completion_tokens_details ? { reasoning_tokens: raw.completion_tokens_details.reasoning_tokens ?? 0 } : void 0
+	};
+}
+//#endregion
+//#region ../core/dist/ai/openai.js
+/**
+* OpenAI 兼容格式的 AI 供应商实现
+*
+* 封装 fetch 调用 /v1/chat/completions 端点，支持：
+* - 非流式调用（chat）
+* - SSE 流式调用（chatStream）
+* - 自动重试（仅 5xx 错误 + 网络错误，指数退避）
+* - 超时控制（AbortController）
+* - usage / reasoning_content 透传
+*/
+var OpenAIProvider = class {
+	apiKey;
+	baseURL;
+	model;
+	timeout;
+	maxRetries;
+	constructor(config) {
+		this.apiKey = config.apiKey;
+		this.baseURL = config.baseURL.replace(/\/$/, "");
+		this.model = config.model;
+		this.timeout = config.timeout ?? 6e4;
+		this.maxRetries = config.maxRetries ?? 2;
+	}
+	async chat(request) {
+		const body = this.buildBody({
+			...request,
+			stream: false
+		});
+		const json = await (await fetchWithRetry(() => this.doFetch(body), this.maxRetries)).json();
+		return this.parseResponse(json);
+	}
+	async *chatStream(request) {
+		const body = this.buildBody({
+			...request,
+			stream: true
+		});
+		const response = await fetchWithRetry(() => this.doFetch(body), this.maxRetries);
+		if (!response.body) throw new ProviderError("Response body is empty", 0, null);
+		yield* parseSSEStream(response.body.getReader());
+	}
+	buildBodyObject(request) {
+		return {
+			model: request.model || this.model,
+			messages: request.messages,
+			tools: request.tools,
+			tool_choice: request.tool_choice,
+			max_tokens: request.max_tokens,
+			temperature: request.temperature,
+			stream: request.stream
+		};
+	}
+	buildBody(request) {
+		return JSON.stringify(this.buildBodyObject(request));
+	}
+	async doFetch(body) {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.timeout);
+		try {
+			return await fetch(`${this.baseURL}/chat/completions`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${this.apiKey}`
+				},
+				body,
+				signal: controller.signal
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	parseResponse(json) {
+		const choice = json.choices?.[0];
+		if (!choice) throw new ProviderError("No choices in response", 0, json);
+		const message = choice.message;
+		const usage = json.usage;
+		return {
+			content: message?.content || null,
+			reasoning_content: message?.reasoning_content,
+			tool_calls: message?.tool_calls || [],
+			finish_reason: choice.finish_reason || "stop",
+			usage: usage ? parseUsage(usage) : void 0,
+			model: json.model || this.model
+		};
+	}
+};
+//#endregion
+//#region ../core/dist/ai/deepseek.js
+var DeepSeekProvider = class extends OpenAIProvider {
+	reasoningEffort;
+	supportsReasoning;
+	constructor(config) {
+		super(config);
+		this.reasoningEffort = config.reasoningEffort;
+		this.supportsReasoning = config.supportsReasoning || false;
+	}
+	buildBodyObject(request) {
+		const body = super.buildBodyObject(request);
+		if (this.supportsReasoning) if (this.reasoningEffort) {
+			body.thinking = { type: "enabled" };
+			body.reasoning_effort = this.reasoningEffort;
+		} else body.thinking = { type: "disabled" };
+		return body;
+	}
+};
+//#endregion
+//#region ../core/dist/ai/xiaomi.js
+var XiaomiProvider = class extends OpenAIProvider {
+	reasoningEffort;
+	supportsReasoning;
+	constructor(config) {
+		super(config);
+		this.reasoningEffort = config.reasoningEffort;
+		this.supportsReasoning = config.supportsReasoning || false;
+	}
+	buildBodyObject(request) {
+		const body = super.buildBodyObject(request);
+		if (this.supportsReasoning) if (this.reasoningEffort) body.thinking = { type: "enabled" };
+		else body.thinking = { type: "disabled" };
+		return body;
+	}
+};
+//#endregion
+//#region ../core/dist/ai/ollama.js
+var OllamaProvider = class extends OpenAIProvider {
+	ollamaURL;
+	constructor(config) {
+		const baseURL = config.baseURL || `${config.ollamaURL || "http://localhost:11434"}/v1`;
+		const normalizedBase = baseURL.endsWith("/v1") ? baseURL : baseURL.replace(/\/+$/, "") + "/v1";
+		super({
+			apiKey: config.apiKey || "ollama",
+			baseURL: normalizedBase,
+			model: config.model,
+			timeout: config.timeout,
+			maxRetries: config.maxRetries
+		});
+		this.ollamaURL = config.ollamaURL || "http://localhost:11434";
+	}
+	async listModels() {
+		try {
+			const res = await fetch(`${this.ollamaURL}/api/tags`);
+			if (!res.ok) return [];
+			return ((await res.json()).models || []).map((m) => ({
+				id: m.name,
+				name: m.name
+			}));
+		} catch {
+			return [];
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/ai/factory.js
+function createProvider(config) {
+	const activeModel = config.activeModel || "";
+	const supportsReasoning = getDefaultModels(config.type).find((m) => m.id === activeModel)?.supportsReasoning || false;
+	switch (config.type) {
+		case "openai": return new OpenAIProvider({
+			apiKey: config.apiKey,
+			baseURL: config.baseURL,
+			model: activeModel,
+			timeout: config.timeout,
+			maxRetries: config.maxRetries ?? 5
+		});
+		case "deepseek": return new DeepSeekProvider({
+			apiKey: config.apiKey,
+			baseURL: config.baseURL,
+			model: activeModel,
+			timeout: config.timeout,
+			maxRetries: config.maxRetries ?? 5,
+			reasoningEffort: config.reasoningEffort,
+			supportsReasoning
+		});
+		case "xiaomi": return new XiaomiProvider({
+			apiKey: config.apiKey,
+			baseURL: config.baseURL,
+			model: activeModel,
+			timeout: config.timeout,
+			maxRetries: config.maxRetries ?? 5,
+			reasoningEffort: config.reasoningEffort,
+			supportsReasoning
+		});
+		case "ollama": return new OllamaProvider({
+			apiKey: config.apiKey,
+			baseURL: config.baseURL || "",
+			model: activeModel,
+			timeout: config.timeout,
+			maxRetries: config.maxRetries ?? 3,
+			ollamaURL: config.ollamaURL
+		});
+		default: throw new Error(`Unsupported provider type: ${config.type}`);
+	}
+}
+//#endregion
+//#region ../core/dist/tool/registry.js
+/**
+* 工具注册表
+*
+* 管理工具的注册、查询和调度。
+* 提供 getDefinitions() 将已注册工具转为 OpenAI function calling 格式。
+* 支持 sourceId 追踪，可按来源批量卸载（为 extension 系统提供基础）。
+*/
+var ToolRegistry = class {
+	tools = /* @__PURE__ */ new Map();
+	sources = /* @__PURE__ */ new Map();
+	/**
+	* 注册一个工具
+	* @param tool - 工具定义
+	* @param sourceId - 来源标识，默认为 'builtin'。用于批量卸载时按来源清理。
+	*/
+	register(tool, sourceId = "builtin") {
+		this.tools.set(tool.name, tool);
+		if (!this.sources.has(sourceId)) this.sources.set(sourceId, /* @__PURE__ */ new Set());
+		this.sources.get(sourceId).add(tool.name);
+	}
+	/** 注销一个工具 */
+	unregister(name) {
+		for (const [, names] of this.sources) names.delete(name);
+		return this.tools.delete(name);
+	}
+	/**
+	* 按来源批量注销工具
+	* @param sourceId - 来源标识
+	* @returns 被注销的工具数量
+	*/
+	unregisterSource(sourceId) {
+		const names = this.sources.get(sourceId);
+		if (!names) return 0;
+		let count = 0;
+		for (const name of names) if (this.tools.delete(name)) count++;
+		this.sources.delete(sourceId);
+		return count;
+	}
+	/** 按名称获取工具 */
+	get(name) {
+		return this.tools.get(name);
+	}
+	/** 获取 OpenAI function calling 格式的工具定义列表 */
+	getDefinitions() {
+		return Array.from(this.tools.values()).map((tool) => ({
+			type: "function",
+			function: {
+				name: tool.name,
+				description: tool.description,
+				parameters: tool.parameters
+			}
+		}));
+	}
+	/**
+	* 按名称执行工具
+	*
+	* @param name - 工具名称
+	* @param args - 调用参数，支持 __confirmed 标记跳过确认流程
+	* @param ctx - 工具执行上下文
+	* @returns 执行结果
+	* @throws PendingConfirmation 需要用户确认时
+	*/
+	async execute(name, args, ctx) {
+		const tool = this.tools.get(name);
+		if (!tool) return {
+			success: false,
+			output: "",
+			error: `未知工具: ${name}`
+		};
+		return tool.execute(args, ctx);
+	}
+};
+//#endregion
+//#region ../core/dist/tool/types.js
+/**
+* 待确认异常
+*
+* 工具执行时如需要用户确认，抛出此异常。
+* 上层 Agent Loop 捕获后通过 SSE 推送确认请求到前端，
+* 用户确认后以 __confirmed: true 重新调用工具。
+*/
+var PendingConfirmation = class extends Error {
+	toolName;
+	args;
+	reason;
+	constructor(toolName, args, reason) {
+		super(`Tool "${toolName}" requires confirmation: ${reason}`);
+		this.toolName = toolName;
+		this.args = args;
+		this.reason = reason;
+		this.name = "PendingConfirmation";
+	}
+	toJSON() {
+		return {
+			toolName: this.toolName,
+			args: this.args,
+			reason: this.reason
+		};
+	}
+};
+//#endregion
+//#region ../core/dist/tool/safeguard.js
+var READONLY_PATTERNS = [
+	/^\s*(?:Get-ChildItem|dir|ls|Get-Content|cat|type|Get-Process|ps|Get-Service|Get-Location|pwd|gl|Get-Item|gi|Get-ItemProperty|gp|Get-Date|Get-Host|Get-Variable|gv|Get-Command|gcm|Get-Member|gm|Get-Alias|gal|Get-History|history|ghy|Select-String|sls|findstr|Test-Path|Measure-Object|measure|Sort-Object|sort|Group-Object|group|Select-Object|select|Format-List|fl|Format-Table|ft|Format-Wide|fw|Format-Hex|Write-Output|echo|write|Compare-Object|diff|compare|Where-Object|Join-Path|Split-Path|Resolve-Path|ConvertFrom-Json|ConvertFrom-Csv)\b/i,
+	/^\s*(?:head|tail|less|more|grep|egrep|fgrep|rg|find|wc|sort|uniq|cut|tr|file|stat|df|du|which|whereis|command|whoami|id|groups|printf|uname|hostname|basename|dirname|readlink|realpath)\b/i,
+	/^\s*git\s+(?:status|log|diff|show|branch|tag|stash\s+list|remote\s+(?:-v|show)|config\s+(?:--list|--get\b)|ls-files|rev-parse|rev-list|describe|shortlog|blame|grep|notes\s+list|reflog|cherry|for-each-ref|name-rev)\b/i,
+	/^\s*npm\s+(?:ls|list|view|info|outdated|version|config\s+list)\b/i
+];
+var DANGEROUS_PATTERNS = [
+	/^\s*del\b/i,
+	/^\s*rmdir\b/i,
+	/^\s*Remove-Item\b/i,
+	/\bformat\b/i,
+	/\bdiskpart\b/i,
+	/reg\s+(delete|add)/i,
+	/Set-ExecutionPolicy/i,
+	/\bshutdown\b/i,
+	/Restart-Computer\b/i,
+	/Stop-Process\s+.*(svchost|winlogon|lsass|csrss)/i,
+	/Stop-Service\b/i,
+	/\|\s*iex\b/i,
+	/\|\s*Invoke-Expression\b/i,
+	/\|\s*cmd\b/i,
+	/>\s*%SystemRoot%/i,
+	/>\s*C:\\Windows/i,
+	/\brm\s+-rf?\b/,
+	/\bfind\b.*\bdelete\b/,
+	/\bdd\s+if=/,
+	/\bmkfs\./,
+	/\bchmod\s+777\s+\//,
+	/\bshutdown\b/,
+	/\breboot\b/,
+	/\binit\s+[06]/,
+	/>\s*\/etc\//,
+	/>\s*\/bin\//,
+	/>\s*\/boot\//,
+	/\|\s*(ba)?sh\b/,
+	/\|\s*zsh\b/,
+	/\bdrop\s+table\b/i,
+	/\bdrop\s+database\b/i,
+	/\bgit\s+push\s+--force\b/i,
+	/\bgit\s+reset\s+--hard\b/i
+];
+var SYSTEM_DIRS = [
+	"C:\\Windows",
+	"C:\\Program Files",
+	"C:\\Program Files (x86)",
+	"/etc",
+	"/bin",
+	"/sbin",
+	"/usr/bin",
+	"/usr/sbin",
+	"/boot",
+	"/sys",
+	"/dev",
+	"/proc"
+];
+function isDangerousCommand(command) {
+	if (DANGEROUS_PATTERNS.some((pattern) => pattern.test(command))) return true;
+	for (const segment of command.split("|")) if (DANGEROUS_PATTERNS.some((pattern) => pattern.test(segment))) return true;
+	return false;
+}
+function isReadonlyCommand(command) {
+	for (const segment of command.split("|")) if (!READONLY_PATTERNS.some((pattern) => pattern.test(segment))) return false;
+	return true;
+}
+function isPathInWorkspace(targetPath, workspaceRoot) {
+	const resolved = normalizePath(targetPath, workspaceRoot);
+	const normalizedRoot = resolve(workspaceRoot).toLowerCase();
+	return resolve(resolved).toLowerCase().startsWith(normalizedRoot + sep);
+}
+function isSystemPath(targetPath, workspaceRoot) {
+	const normalized = resolve(normalizePath(targetPath, workspaceRoot)).toLowerCase();
+	return SYSTEM_DIRS.some((sysDir) => normalized.startsWith(sysDir.toLowerCase()));
+}
+function expandEnvVars(command) {
+	let result = command.replace(/%(\w+)%/g, (_, name) => {
+		return process.env[name] ?? `%${name}%`;
+	});
+	result = result.replace(/\$\{(\w+)\}/g, (_, name) => {
+		return process.env[name] ?? `\$\{${name}\}`;
+	});
+	result = result.replace(/\$([A-Za-z_]\w*)/g, (_, name) => {
+		return process.env[name] ?? `$${name}`;
+	});
+	return result;
+}
+function collectPaths(source, paths) {
+	const winAbsRe = /[A-Za-z]:\\(?:[^\\/:*?"<>|\r\n]+\\)*[^\\/:*?"<>|\r\n]*/g;
+	let match;
+	while ((match = winAbsRe.exec(source)) !== null) paths.push(match[0]);
+	const unixAbsRe = /(?<!\w)\/(?:[^\s'"]+)/g;
+	while ((match = unixAbsRe.exec(source)) !== null) {
+		const p = match[0];
+		if (p.length > 1 && !/^\/\d/.test(p) && !/\/$/.test(p)) paths.push(p);
+	}
+	const tildeRe = /(?<!\w)~\/(?:[^\s'"]+)/g;
+	while ((match = tildeRe.exec(source)) !== null) paths.push(match[0]);
+}
+function extractPaths(command) {
+	const paths = [];
+	collectPaths(command, paths);
+	const expanded = expandEnvVars(command);
+	if (expanded !== command) collectPaths(expanded, paths);
+	const winRelRe = /(?:\.\.\\)+(?:[^\s'"]+)/g;
+	let match;
+	while ((match = winRelRe.exec(command)) !== null) paths.push(match[0]);
+	const unixRelRe = /(?<!\w)(?:\.\.\/)+(?:[^\s'"]+)/g;
+	while ((match = unixRelRe.exec(command)) !== null) {
+		const p = match[0];
+		if (p.length > 1 && !/\/$/.test(p)) paths.push(p);
+	}
+	return paths;
+}
+/**
+* 分类命令的安全性
+*
+* 判定顺序：
+* 1. reject  — 明确禁止（format, diskpart）
+* 2. confirm — 命中危险模式（删除、系统修改、管道注入等）
+* 3. safe    — 只读命令，无需后续路径检查
+* 4. confirm — 路径在工作区外或系统目录
+* 5. safe    — 其余放行
+*
+* @returns 'safe' 可直接执行 / 'confirm' 需用户确认 / 'reject' 拒绝执行
+*/
+function classifyCommand(command, workspaceRoot) {
+	if (/^\s*(format|diskpart)\b/i.test(command.trim())) return "reject";
+	if (isDangerousCommand(command)) return "confirm";
+	if (isReadonlyCommand(command)) return "safe";
+	const paths = extractPaths(command);
+	for (const p of paths) {
+		if (isSystemPath(p, workspaceRoot)) return "confirm";
+		if (!isPathInWorkspace(p, workspaceRoot)) return "confirm";
+	}
+	return "safe";
+}
+/**
+* 分类文件路径的安全性
+*
+* @returns 'safe' 可直接操作 / 'confirm' 需用户确认
+*/
+function classifyFilePath(targetPath, workspaceRoot) {
+	const normalized = normalizePath(targetPath, workspaceRoot);
+	if (isSystemPath(normalized, workspaceRoot)) return "reject";
+	if (!isPathInWorkspace(normalized, workspaceRoot)) return "confirm";
+	return "safe";
+}
+function normalizePath(targetPath, workspaceRoot) {
+	let resolved = targetPath;
+	if (resolved.startsWith("~")) {
+		const home = process.env.HOME || process.env.USERPROFILE || "";
+		resolved = resolved.replace(/^~/, home);
+	}
+	if (isAbsolute(resolved)) return resolved;
+	return resolve(workspaceRoot, resolved);
+}
+//#endregion
+//#region ../core/dist/tool/env.js
+/**
+* ToolContext — 工具执行上下文
+*
+* 封装工作区根目录、路径解析和安全检查。
+* 替换原来分散在工具中的 resolve() + classifyFilePath/classifyCommand 模式。
+*/
+var ToolContext = class {
+	root;
+	onUpdate;
+	constructor(root) {
+		this.root = root;
+	}
+	/** 解析用户输入的路径，同时做安全检查 */
+	resolvePath(userPath) {
+		const resolved = resolve(this.root, userPath);
+		return {
+			path: resolved,
+			classification: classifyFilePath(resolved, this.root)
+		};
+	}
+	/** 分类终端命令的安全性 */
+	classifyCommand(command) {
+		return classifyCommand(command, this.root);
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/file-utils.js
+var BOM = "";
+function stripBom(content) {
+	if (content.startsWith(BOM)) return content.slice(1);
+	return content;
+}
+function detectLineEnding(content) {
+	if (content.includes("\r\n")) return "CRLF";
+	return "LF";
+}
+function detectMeta(content) {
+	return {
+		bom: content.startsWith(BOM),
+		lineEnding: detectLineEnding(content)
+	};
+}
+function normalizeLineEndings(content, target) {
+	if (target === "CRLF") return content.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n");
+	return content.replace(/\r\n/g, "\n");
+}
+function normalizeToLF(content) {
+	return content.replace(/\r\n/g, "\n");
+}
+function applyMeta(content, meta) {
+	let result = normalizeLineEndings(content, meta.lineEnding);
+	if (meta.bom && !result.startsWith(BOM)) result = BOM + result;
+	else if (!meta.bom && result.startsWith(BOM)) result = result.slice(1);
+	return result;
+}
+async function atomicWrite(filePath, content, meta) {
+	let finalContent = content;
+	let targetMode = null;
+	try {
+		const info = await stat(filePath);
+		if (info.isFile()) targetMode = info.mode;
+	} catch {}
+	if (meta) finalContent = applyMeta(content, meta);
+	dirname(filePath);
+	const tmpPath = filePath + "." + randomUUID() + ".tmp";
+	await writeFile(tmpPath, finalContent, "utf-8");
+	if (targetMode !== null) await chmod(tmpPath, targetMode);
+	await rename(tmpPath, filePath);
+}
+//#endregion
+//#region ../core/dist/tool/tools/read-file.js
+var MAX_FILE_SIZE = 1024 * 1024;
+var DEFAULT_OFFSET = 1;
+var DEFAULT_LIMIT = 500;
+function validateParam(name, value) {
+	if (value === void 0 || value === null) return NaN;
+	const n = Number(value);
+	if (!Number.isInteger(n)) return NaN;
+	if (n < 1) return NaN;
+	return n;
+}
+/**
+* read_file — 读取文件内容
+*
+* 工作区内文件直接读取；工作区外文件需用户确认。
+* 文件大小限制 1 MB，超限返回错误。
+* 支持 offset / limit 按行翻页，不指定时默认读前 500 行。
+*/
+var readFileTool = {
+	name: "read_file",
+	description: "Read file contents. Supports offset/limit for paginated line-by-line reading. Use for viewing code, config, docs, etc.",
+	parameters: {
+		type: "object",
+		properties: {
+			path: {
+				type: "string",
+				description: "File path (relative to workspace or absolute)"
+			},
+			offset: {
+				type: "integer",
+				description: "Starting line number (1-based), default 1"
+			},
+			limit: {
+				type: "integer",
+				description: "Max lines to read, default 500"
+			}
+		},
+		required: ["path"]
+	},
+	async execute(args, ctx) {
+		const userPath = args.path;
+		if (!userPath) return {
+			success: false,
+			output: "",
+			error: "缺少参数: path"
+		};
+		let offset = DEFAULT_OFFSET;
+		let limit = DEFAULT_LIMIT;
+		if ("offset" in args && args.offset !== void 0 && args.offset !== null) {
+			const parsed = validateParam("offset", args.offset);
+			if (isNaN(parsed)) return {
+				success: false,
+				output: "",
+				error: "offset 必须是大于等于 1 的整数"
+			};
+			offset = parsed;
+		}
+		if ("limit" in args && args.limit !== void 0 && args.limit !== null) {
+			const parsed = validateParam("limit", args.limit);
+			if (isNaN(parsed)) return {
+				success: false,
+				output: "",
+				error: "limit 必须是大于等于 1 的整数"
+			};
+			limit = parsed;
+		}
+		const { path: filePath, classification } = ctx.resolvePath(userPath);
+		if (!args.__confirmed) {
+			if (classification === "reject") return {
+				success: false,
+				output: "",
+				error: `拒绝读取系统路径: ${userPath}`
+			};
+			if (classification === "confirm") throw new PendingConfirmation("read_file", {
+				path: userPath,
+				offset,
+				limit
+			}, `文件 "${userPath}" 在工作区之外，确认读取？`);
+		}
+		try {
+			const info = await stat(filePath);
+			if (!info.isFile()) return {
+				success: false,
+				output: "",
+				error: `路径不是文件: ${userPath}`
+			};
+			if (info.size > MAX_FILE_SIZE) return {
+				success: false,
+				output: "",
+				error: `文件过大 (${(info.size / 1024 / 1024).toFixed(1)} MB)，最大支持 1 MB`
+			};
+			const lines = stripBom(await readFile(filePath, "utf-8")).split("\n");
+			const totalLines = lines.length;
+			const startIdx = offset - 1;
+			if (startIdx >= totalLines) return {
+				success: true,
+				output: `=== ${userPath} (第 ${offset}-${offset + limit - 1} 行 / 共 ${totalLines} 行) ===\n\n（起始行号超出文件末尾）`
+			};
+			const endIdx = Math.min(startIdx + limit, totalLines);
+			const slice = lines.slice(startIdx, endIdx);
+			const atEnd = endIdx >= totalLines;
+			return {
+				success: true,
+				output: `=== ${userPath} ${`(第 ${offset}-${startIdx + slice.length} 行 / 共 ${totalLines} 行${atEnd ? "，已达文件末尾" : ""})`} ===\n${slice.join("\n")}`
+			};
+		} catch (error) {
+			if (error.code === "ENOENT") return {
+				success: false,
+				output: "",
+				error: `文件不存在: ${userPath}`
+			};
+			return {
+				success: false,
+				output: "",
+				error: `读取失败: ${error.message}`
+			};
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/write-file.js
+/**
+* write_file — 写入文件内容
+*
+* 自动创建不存在的父目录。覆盖已有文件。
+* 使用原子写入（临时文件 + rename），崩溃时不留残缺文件。
+* 覆盖已有文件时自动保留原文件的 BOM 和行尾格式（CRLF/LF）。
+* 工作区内文件直接写入；工作区外需用户确认。
+*/
+var writeFileTool = {
+	name: "write_file",
+	description: "Write content to a file (overwrites). Creates missing parent directories automatically. Preserves existing file encoding (BOM, line endings) when overwriting.",
+	parameters: {
+		type: "object",
+		properties: {
+			path: {
+				type: "string",
+				description: "File path (relative to workspace or absolute)"
+			},
+			content: {
+				type: "string",
+				description: "Complete file content to write"
+			}
+		},
+		required: ["path", "content"]
+	},
+	async execute(args, ctx) {
+		const userPath = args.path;
+		const content = args.content;
+		if (!userPath) return {
+			success: false,
+			output: "",
+			error: "缺少参数: path"
+		};
+		if (content === void 0 || content === null) return {
+			success: false,
+			output: "",
+			error: "缺少参数: content"
+		};
+		const { path: filePath, classification } = ctx.resolvePath(userPath);
+		if (!args.__confirmed) {
+			if (classification === "reject") return {
+				success: false,
+				output: "",
+				error: `拒绝写入系统路径: ${userPath}`
+			};
+			if (classification === "confirm") throw new PendingConfirmation("write_file", {
+				path: userPath,
+				content
+			}, `文件 "${userPath}" 在工作区之外，确认写入？`);
+		}
+		try {
+			await mkdir(dirname(filePath), { recursive: true });
+			let existed = false;
+			let meta = void 0;
+			try {
+				existed = (await stat(filePath)).isFile();
+				if (existed) meta = detectMeta(await readFile(filePath, "utf-8"));
+			} catch {}
+			await atomicWrite(filePath, content, meta);
+			return {
+				success: true,
+				output: `${existed ? "已更新" : "已创建"}文件: ${userPath} (${content.split("\n").length} 行, ${Buffer.byteLength(content, "utf-8")} 字节${meta?.bom ? " (已保留 BOM)" : ""})`
+			};
+		} catch (error) {
+			return {
+				success: false,
+				output: "",
+				error: `写入失败: ${error.message}`
+			};
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/delete-file.js
+/**
+* delete_file — 删除文件
+*
+* 删除操作始终需要用户确认（不可逆）。
+* 仅支持删除文件，不支持删除目录。
+* 系统路径始终拒绝。
+*/
+var deleteFileTool = {
+	name: "delete_file",
+	description: "Delete a file. Always requires user confirmation.",
+	parameters: {
+		type: "object",
+		properties: { path: {
+			type: "string",
+			description: "File path (relative to workspace or absolute)"
+		} },
+		required: ["path"]
+	},
+	async execute(args, ctx) {
+		const userPath = args.path;
+		if (!userPath) return {
+			success: false,
+			output: "",
+			error: "缺少参数: path"
+		};
+		const { path: filePath, classification } = ctx.resolvePath(userPath);
+		if (!args.__confirmed) throw new PendingConfirmation("delete_file", { path: userPath }, `确认删除 "${userPath}"？此操作不可恢复。`);
+		if (classification === "reject") return {
+			success: false,
+			output: "",
+			error: `拒绝删除系统路径: ${userPath}`
+		};
+		try {
+			if ((await stat(filePath)).isDirectory()) return {
+				success: false,
+				output: "",
+				error: `目标是目录而非文件: ${userPath}`
+			};
+			await rm(filePath);
+			return {
+				success: true,
+				output: `已删除文件: ${userPath}`
+			};
+		} catch (error) {
+			if (error.code === "ENOENT") return {
+				success: false,
+				output: "",
+				error: `路径不存在: ${userPath}`
+			};
+			return {
+				success: false,
+				output: "",
+				error: `删除失败: ${error.message}`
+			};
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/edit.js
+function escapeNewlines(s) {
+	return s.replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+function formatDiff(original, replacement) {
+	return `- ${escapeNewlines(original)}\n+ ${escapeNewlines(replacement)}`;
+}
+function countOccurrences(haystack, needle) {
+	if (!needle) return 0;
+	let count = 0;
+	let pos = 0;
+	while (true) {
+		pos = haystack.indexOf(needle, pos);
+		if (pos === -1) break;
+		count++;
+		pos += needle.length;
+	}
+	return count;
+}
+/**
+* edit — 精确字符串替换编辑文件
+*
+* 在文件中查找 oldString 并替换为 newString。
+* 使用原子写入，自动保留原文件的 BOM 和行尾格式。
+* 非 replaceAll 模式下，oldString 必须在文件中恰好出现一次。
+*/
+var editTool = {
+	name: "edit",
+	description: "Perform exact string replacement in a file. Find oldString and replace with newString. In non-replaceAll mode, oldString must appear exactly once (prevents accidental changes). Preserves BOM and line endings (CRLF/LF).",
+	parameters: {
+		type: "object",
+		properties: {
+			path: {
+				type: "string",
+				description: "File path (relative to workspace or absolute)"
+			},
+			oldString: {
+				type: "string",
+				description: "Original text to replace (must match file content exactly, including indentation and blank lines)"
+			},
+			newString: {
+				type: "string",
+				description: "Replacement text"
+			},
+			replaceAll: {
+				type: "boolean",
+				description: "Replace all occurrences. Default false — oldString must appear exactly once in the file."
+			}
+		},
+		required: [
+			"path",
+			"oldString",
+			"newString"
+		]
+	},
+	async execute(args, ctx) {
+		const userPath = args.path;
+		const oldString = args.oldString;
+		const newString = args.newString;
+		const replaceAll = args.replaceAll === true;
+		if (!userPath) return {
+			success: false,
+			output: "",
+			error: "缺少参数: path"
+		};
+		if (oldString === void 0 || oldString === null) return {
+			success: false,
+			output: "",
+			error: "缺少参数: oldString"
+		};
+		if (newString === void 0 || newString === null) return {
+			success: false,
+			output: "",
+			error: "缺少参数: newString"
+		};
+		if (oldString === "") return {
+			success: false,
+			output: "",
+			error: "oldString 不能为空"
+		};
+		if (oldString === newString) return {
+			success: false,
+			output: "",
+			error: "oldString 与 newString 相同，无需替换"
+		};
+		const { path: filePath, classification } = ctx.resolvePath(userPath);
+		if (!args.__confirmed) {
+			if (classification === "reject") return {
+				success: false,
+				output: "",
+				error: `拒绝编辑系统路径: ${userPath}`
+			};
+			if (classification === "confirm") throw new PendingConfirmation("edit", {
+				path: userPath,
+				oldString,
+				newString,
+				replaceAll
+			}, `文件 "${userPath}" 在工作区之外，确认编辑？`);
+		}
+		try {
+			const raw = await readFile(filePath, "utf-8");
+			const meta = detectMeta(raw);
+			const content = stripBom(raw);
+			let matchCount = countOccurrences(content, oldString);
+			if (matchCount === 0) {
+				const lfContent = normalizeToLF(content);
+				const lfOld = normalizeToLF(oldString);
+				const lfCount = countOccurrences(lfContent, lfOld);
+				if (lfCount > 0) {
+					matchCount = lfCount;
+					const lfNew = normalizeToLF(newString);
+					let result;
+					if (replaceAll) result = lfContent.split(lfOld).join(lfNew);
+					else result = lfContent.replace(lfOld, lfNew);
+					if (meta.lineEnding === "CRLF") result = result.replace(/\n/g, "\r\n");
+					await atomicWrite(filePath, result, meta);
+					return {
+						success: true,
+						output: `已编辑: ${userPath}\n替换 ${replaceAll ? matchCount : 1} 处:\n${formatDiff(oldString, newString)}`
+					};
+				}
+			}
+			if (matchCount === 0) return {
+				success: false,
+				output: "",
+				error: `未在文件中找到 oldString。请确保 oldString 与文件内容完全一致（包括缩进和空行）。\n文件路径: ${userPath}\noldString: ${escapeNewlines(oldString.slice(0, 200))}`
+			};
+			if (!replaceAll && matchCount > 1) return {
+				success: false,
+				output: "",
+				error: `oldString 在文件中出现了 ${matchCount} 次。请提供更多上下文使匹配唯一，或设置 replaceAll: true 替换全部。`
+			};
+			await atomicWrite(filePath, replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString), meta);
+			return {
+				success: true,
+				output: `已编辑: ${userPath}\n替换 ${replaceAll ? matchCount : 1} 处:\n${formatDiff(oldString, newString)}`
+			};
+		} catch (error) {
+			if (error.code === "ENOENT") return {
+				success: false,
+				output: "",
+				error: `文件不存在: ${userPath}`
+			};
+			if (error instanceof PendingConfirmation) throw error;
+			return {
+				success: false,
+				output: "",
+				error: `编辑失败: ${error.message}`
+			};
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/exec.js
+var DEFAULT_TIMEOUT = 3e5;
+var MAX_ALLOWED_TIMEOUT = 36e5;
+var MAX_OUTPUT = 5e4;
+var IS_WINDOWS = process.platform === "win32";
+function killProcessTree(pid) {
+	if (pid == null) return false;
+	if (IS_WINDOWS) try {
+		execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+	try {
+		process.kill(pid, "SIGKILL");
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* execute_command — 执行终端命令
+*
+* 安全策略：
+* - 安全命令 + 工作区路径 → 直接执行
+* - 危险命令 → 需用户确认
+* - format/diskpart → 拒绝
+* - 默认超时 5 分钟，输出上限 50KB
+*/
+var execTool = {
+	name: "execute_command",
+	description: "Execute a terminal command in the workspace directory and return output. For development tasks only, non-interactive. Default timeout 5 minutes.",
+	parameters: {
+		type: "object",
+		properties: {
+			command: {
+				type: "string",
+				description: "The terminal command to execute"
+			},
+			timeout: {
+				type: "number",
+				description: "Timeout in seconds, default 300 (5 min), max 3600 (1 hour)"
+			}
+		},
+		required: ["command"]
+	},
+	async execute(args, ctx) {
+		const command = args.command;
+		if (!command) return {
+			success: false,
+			output: "",
+			error: "缺少参数: command"
+		};
+		let timeoutSec = typeof args.timeout === "number" && args.timeout > 0 ? args.timeout : DEFAULT_TIMEOUT / 1e3;
+		if (timeoutSec > MAX_ALLOWED_TIMEOUT / 1e3) timeoutSec = MAX_ALLOWED_TIMEOUT / 1e3;
+		const timeoutMs = timeoutSec * 1e3;
+		const classification = ctx.classifyCommand(command);
+		if (classification === "reject") return {
+			success: false,
+			output: "",
+			error: `拒绝执行危险命令: ${command.slice(0, 80)}`
+		};
+		if (classification === "confirm" && !args.__confirmed) throw new PendingConfirmation("execute_command", { ...args }, `需要确认执行命令:\n${command}`);
+		if (args.__confirmed) {
+			if (ctx.classifyCommand(command) === "reject") return {
+				success: false,
+				output: "",
+				error: `拒绝执行危险命令: ${command.slice(0, 80)}`
+			};
+		}
+		return new Promise((resolve) => {
+			const stdoutChunks = [];
+			const stderrChunks = [];
+			let resolved = false;
+			let totalOutput = 0;
+			const resolveResult = (success, error) => {
+				if (resolved) return;
+				resolved = true;
+				clearTimeout(timer);
+				const out = Buffer.concat(stdoutChunks).toString();
+				const err = Buffer.concat(stderrChunks).toString();
+				resolve({
+					success,
+					output: [out, err ? `\n[stderr]\n${err}` : ""].filter(Boolean).join("").slice(0, MAX_OUTPUT) || "(无输出)",
+					error
+				});
+			};
+			const timer = setTimeout(() => {
+				if (!resolved) {
+					if (!killProcessTree(child.pid)) try {
+						child.kill();
+					} catch {}
+					resolveResult(false, `命令执行超时 (${timeoutSec} 秒)`);
+				}
+			}, timeoutMs);
+			const child = spawn(command, [], {
+				cwd: ctx.root,
+				shell: IS_WINDOWS ? "powershell.exe" : "/bin/bash",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			child.stdout?.on("data", (data) => {
+				stdoutChunks.push(data);
+				totalOutput += data.length;
+				if (totalOutput > MAX_OUTPUT) {
+					if (!resolved) {
+						if (!killProcessTree(child.pid)) try {
+							child.kill();
+						} catch {}
+						resolveResult(false, "命令输出超过上限 (50KB)");
+					}
+				} else ctx.onUpdate?.(data.toString());
+			});
+			child.stderr?.on("data", (data) => {
+				stderrChunks.push(data);
+				totalOutput += data.length;
+				if (totalOutput > MAX_OUTPUT) {
+					if (!resolved) {
+						if (!killProcessTree(child.pid)) try {
+							child.kill();
+						} catch {}
+						resolveResult(false, "命令输出超过上限 (50KB)");
+					}
+				} else ctx.onUpdate?.(data.toString());
+			});
+			child.on("close", (code) => {
+				if (resolved) return;
+				resolveResult(code === 0, code !== 0 ? `命令退出码: ${code}` : void 0);
+			});
+			child.on("error", (err) => {
+				if (resolved) return;
+				resolveResult(false, err.message);
+			});
+		});
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/web-search.js
+async function searchSearXNG(query, num, baseURL) {
+	const url = `${baseURL.replace(/\/+$/, "")}/search?format=json&q=${encodeURIComponent(query)}`;
+	const res = await fetch(url);
+	if (!res.ok) throw new Error(`SearXNG returned ${res.status}`);
+	return ((await res.json()).results || []).slice(0, num).map((r) => ({
+		title: r.title,
+		url: r.url,
+		snippet: r.content || ""
+	}));
+}
+async function searchTavily(query, num, apiKey) {
+	const res = await fetch("https://api.tavily.com/search", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`
+		},
+		body: JSON.stringify({
+			query,
+			max_results: num,
+			include_answer: false
+		})
+	});
+	if (!res.ok) throw new Error(`Tavily returned ${res.status}`);
+	return ((await res.json()).results || []).slice(0, num).map((r) => ({
+		title: r.title,
+		url: r.url,
+		snippet: r.content || ""
+	}));
+}
+var webSearchTool = {
+	name: "web_search",
+	description: "Search the internet for information. Use for latest news, documentation lookup, fact verification, etc. Only use when real-time or external knowledge is needed. Results include title, URL, and snippet.",
+	parameters: {
+		type: "object",
+		properties: {
+			query: {
+				type: "string",
+				description: "Search query (keyword or question)"
+			},
+			num: {
+				type: "integer",
+				description: "Number of results, default 5, max 10"
+			}
+		},
+		required: ["query"]
+	},
+	async execute(args, _ctx) {
+		const query = args.query?.trim();
+		if (!query) return {
+			success: false,
+			output: "",
+			error: "缺少参数: query"
+		};
+		const num = Math.min(Math.max(typeof args.num === "number" ? args.num : 5, 1), 10);
+		const config = readConfig();
+		if (!config.searchEnabled) return {
+			success: false,
+			output: "",
+			error: "搜索功能未启用，请在设置中开启"
+		};
+		const provider = config.searchProvider || "searxng";
+		try {
+			let results;
+			if (provider === "tavily") {
+				if (!config.tavilyApiKey) return {
+					success: false,
+					output: "",
+					error: "未配置 Tavily API Key，请在设置中填写"
+				};
+				results = await searchTavily(query, num, config.tavilyApiKey);
+			} else results = await searchSearXNG(query, num, config.searxngURL || "http://localhost:8080");
+			if (results.length === 0) return {
+				success: true,
+				output: `未找到与「${query}」相关的结果。`
+			};
+			const formatted = results.map((r, i) => `${i + 1}. **[${r.title}](${r.url})**\n   ${r.snippet}`).join("\n\n");
+			return {
+				success: true,
+				output: `搜索「${query}」的结果（共 ${results.length} 条）：\n\n${formatted}`
+			};
+		} catch (error) {
+			return {
+				success: false,
+				output: "",
+				error: `搜索失败: ${error.message}`
+			};
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/paths.js
+var QUALIA_HOME = join(homedir(), ".qualia");
+var DATA_DIR = join(QUALIA_HOME, "data");
+function getDataDir() {
+	return DATA_DIR;
+}
+function getDataPath(...segments) {
+	return join(DATA_DIR, ...segments);
+}
+function getConfigPath() {
+	return join(QUALIA_HOME, "config.json");
+}
+//#endregion
+//#region ../core/dist/tool/tools/read-memory.js
+var MEMORY_PATH$2 = getDataPath("memory.md");
+var readMemoryTool = {
+	name: "read_memory",
+	description: "Read long-term memory (data/memory.md). Optionally pass a query for keyword search — returns matching lines with their category headers. Without query, returns the full memory content. Use when you need to recall previously stored information about users, yourself, or important events. Note: the memory snapshot taken at session creation may be stale; this tool always returns the latest.",
+	parameters: {
+		type: "object",
+		properties: { query: {
+			type: "string",
+			description: "Optional. Search keyword (case-insensitive). Returns matching lines with their category headers. Omit to return all memory."
+		} },
+		required: []
+	},
+	async execute(args, _ctx) {
+		try {
+			if (!existsSync(MEMORY_PATH$2)) return {
+				success: true,
+				output: "（暂无记忆内容）"
+			};
+			const content = readFileSync(MEMORY_PATH$2, "utf-8");
+			if (!content.trim()) return {
+				success: true,
+				output: "（暂无记忆内容）"
+			};
+			const query = args.query;
+			if (!query?.trim()) return {
+				success: true,
+				output: content
+			};
+			const lines = content.split("\n");
+			const lowerQuery = query.trim().toLowerCase();
+			const resultLines = [];
+			let lastHeader = "";
+			for (const line of lines) {
+				if (line.startsWith("## ")) lastHeader = line;
+				if (line.trim() !== "" && !line.startsWith("## ") && line.toLowerCase().includes(lowerQuery)) {
+					if (lastHeader && !resultLines.includes(lastHeader)) {
+						resultLines.push(lastHeader);
+						resultLines.push("");
+					}
+					resultLines.push(line);
+				}
+			}
+			if (resultLines.length === 0) return {
+				success: true,
+				output: `（记忆中没有找到与 "${query.trim()}" 相关的内容）`
+			};
+			return {
+				success: true,
+				output: resultLines.join("\n")
+			};
+		} catch (error) {
+			return {
+				success: false,
+				output: "",
+				error: `读取记忆失败: ${error.message}`
+			};
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/write-memory.js
+var SECTION_META = `
+## 关于我自己 (Qualia)
+我是一个运行在本地环境中的 AI 伴侣，帮助用户完成开发工作和日常任务。
+
+## 关于用户
+（待记录）
+
+## 重要事件
+（待记录）
+`;
+var MEMORY_PATH$1 = getDataPath("memory.md");
+function ensureMemoryFile() {
+	const dir = getDataDir();
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	if (!existsSync(MEMORY_PATH$1) || !readFileSync(MEMORY_PATH$1, "utf-8").includes("## 关于用户")) writeFileSync(MEMORY_PATH$1, SECTION_META.trim().replace(/\r/g, "") + "\n", "utf-8");
+}
+var CATEGORY_HEADERS = {
+	self: "## 关于我自己 (Qualia)",
+	user: "## 关于用户",
+	event: "## 重要事件"
+};
+function updateSection(current, category, content) {
+	const header = CATEGORY_HEADERS[category];
+	if (!header) return current;
+	let result = "";
+	let inTarget = false;
+	let done = false;
+	for (const line of current.split("\n")) {
+		if (line.startsWith("## ")) {
+			if (inTarget) {
+				result += content + "\n\n";
+				done = true;
+			}
+			inTarget = line === header;
+		} else if (inTarget && !done) continue;
+		result += line + "\n";
+	}
+	if (inTarget && !done) result += content;
+	return result.trim() + "\n";
+}
+var writeMemoryTool = {
+	name: "write_memory",
+	description: "Write important information to long-term memory (memory.md). Only use for information worth remembering long-term. Content is automatically injected into the system prompt of future sessions. Three categories: self (about yourself), user (about the user), event (important milestones). Each call overwrites the entire content of the given category.",
+	parameters: {
+		type: "object",
+		properties: {
+			category: {
+				type: "string",
+				description: "Memory category: self (about yourself), user (about the user), event (important events)",
+				enum: [
+					"self",
+					"user",
+					"event"
+				]
+			},
+			content: {
+				type: "string",
+				description: "New content for this category (replaces existing). Write in Chinese, concise and brief, one item per line."
+			}
+		},
+		required: ["category", "content"]
+	},
+	async execute(args, _ctx) {
+		const category = args.category;
+		const content = args.content;
+		if (!category || !CATEGORY_HEADERS[category]) return {
+			success: false,
+			output: "",
+			error: `无效的类别: ${category}，可选: self, user, event`
+		};
+		if (!content?.trim()) return {
+			success: false,
+			output: "",
+			error: "content 不能为空"
+		};
+		try {
+			ensureMemoryFile();
+			writeFileSync(MEMORY_PATH$1, updateSection(readFileSync(MEMORY_PATH$1, "utf-8").replace(/\r/g, ""), category, content.trim()), "utf-8");
+			return {
+				success: true,
+				output: `已更新记忆: ${CATEGORY_HEADERS[category]}\n${content}`
+			};
+		} catch (error) {
+			return {
+				success: false,
+				output: "",
+				error: `写入失败: ${error.message}`
+			};
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/concurrency/file-mutex.js
+var FileMutex = class {
+	locks = /* @__PURE__ */ new Map();
+	async run(key, fn) {
+		await this.acquire(key);
+		try {
+			return await fn();
+		} finally {
+			this.release(key);
+		}
+	}
+	acquire(key) {
+		let entry = this.locks.get(key);
+		if (!entry) {
+			entry = {
+				locked: false,
+				waiters: []
+			};
+			this.locks.set(key, entry);
+		}
+		if (!entry.locked) {
+			entry.locked = true;
+			return Promise.resolve();
+		}
+		return new Promise((resolve, reject) => {
+			entry.waiters.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	release(key) {
+		const entry = this.locks.get(key);
+		if (!entry) return;
+		const next = entry.waiters.shift();
+		if (next) next.resolve();
+		else {
+			entry.locked = false;
+			this.locks.delete(key);
+		}
+	}
+};
+var fileMutex = new FileMutex();
+//#endregion
+//#region ../core/dist/concurrency/background-worker.js
+var BackgroundWorker = class {
+	tasks = /* @__PURE__ */ new Map();
+	states = /* @__PURE__ */ new Map();
+	started = false;
+	schedule(name, intervalMs, fn) {
+		if (this.tasks.has(name)) throw new Error(`BackgroundWorker: task "${name}" already registered`);
+		this.tasks.set(name, {
+			name,
+			intervalMs,
+			fn
+		});
+		this.states.set(name, {
+			running: false,
+			timerId: null
+		});
+		if (this.started) this.scheduleNext(name);
+	}
+	start() {
+		if (this.started) return;
+		this.started = true;
+		for (const name of this.tasks.keys()) this.scheduleNext(name);
+	}
+	stop() {
+		this.started = false;
+		for (const [name, state] of this.states) {
+			if (state.timerId) {
+				clearTimeout(state.timerId);
+				state.timerId = null;
+			}
+			state.running = false;
+		}
+	}
+	scheduleNext(name) {
+		const task = this.tasks.get(name);
+		const state = this.states.get(name);
+		if (!task || !state) return;
+		state.timerId = setTimeout(() => this.execute(name), task.intervalMs);
+	}
+	async execute(name) {
+		const task = this.tasks.get(name);
+		const state = this.states.get(name);
+		if (!task || !state) return;
+		if (state.running) return;
+		state.running = true;
+		try {
+			await task.fn();
+		} catch (e) {
+			console.error(`[BackgroundWorker] task "${name}" error:`, e.message);
+		} finally {
+			state.running = false;
+			if (this.started) this.scheduleNext(name);
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/concurrency/session-lock.js
+var SessionLock = class {
+	sessions = /* @__PURE__ */ new Map();
+	createRelease(sessionId) {
+		let released = false;
+		return () => {
+			if (released) throw new Error(`SessionLock: session "${sessionId}" already released`);
+			released = true;
+			this.release(sessionId);
+		};
+	}
+	async acquire(sessionId) {
+		let entry = this.sessions.get(sessionId);
+		if (!entry) {
+			entry = {
+				locked: false,
+				waiters: []
+			};
+			this.sessions.set(sessionId, entry);
+		}
+		if (!entry.locked) {
+			entry.locked = true;
+			return this.createRelease(sessionId);
+		}
+		return new Promise((resolve, reject) => {
+			entry.waiters.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	release(sessionId) {
+		const entry = this.sessions.get(sessionId);
+		if (!entry) return;
+		const next = entry.waiters.shift();
+		if (next) next.resolve(this.createRelease(sessionId));
+		else {
+			entry.locked = false;
+			this.sessions.delete(sessionId);
+		}
+	}
+};
+var sessionLock = new SessionLock();
+//#endregion
+//#region ../core/dist/task/store.js
+var MAX_AGE_MS = 10080 * 60 * 1e3;
+function getPath() {
+	return getDataPath("tasks.json");
+}
+function readAll() {
+	const path = getPath();
+	if (!existsSync(path)) return [];
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+		return parsed;
+	} catch {
+		return [];
+	}
+}
+function writeAll(tasks) {
+	const path = getPath();
+	const dir = getDataDir();
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const now = Date.now();
+	const pruned = tasks.filter((t) => t.status === "pending" || t.status === "running" || t.status === "paused" || now - t.createdAt < MAX_AGE_MS).slice(-100);
+	const tmpPath = path + ".tmp";
+	writeFileSync(tmpPath, JSON.stringify(pruned, null, "	"), "utf-8");
+	renameSync(tmpPath, path);
+}
+var TASKS_MUTEX_KEY = "tasks.json";
+async function createTask(name, prompt, scheduledAt) {
+	return fileMutex.run(TASKS_MUTEX_KEY, async () => {
+		const task = {
+			id: crypto.randomUUID(),
+			name,
+			prompt,
+			createdAt: Date.now(),
+			scheduledAt,
+			status: "pending"
+		};
+		const all = readAll();
+		all.push(task);
+		writeAll(all);
+		return task;
+	});
+}
+function getAllTasks() {
+	return readAll().sort((a, b) => b.createdAt - a.createdAt);
+}
+function getPendingTasks() {
+	return readAll().filter((t) => t.status === "pending" && t.scheduledAt <= Date.now());
+}
+async function updateTaskStatus(id, status, extra) {
+	return fileMutex.run(TASKS_MUTEX_KEY, async () => {
+		const all = readAll();
+		const task = all.find((t) => t.id === id);
+		if (!task) return false;
+		if (!{
+			pending: ["running", "paused"],
+			running: ["completed", "failed"],
+			completed: [],
+			failed: [],
+			paused: ["pending"]
+		}[status].includes(task.status)) return false;
+		task.status = status;
+		if (status === "completed") {
+			task.completedAt = Date.now();
+			task.result = extra?.result;
+		}
+		if (status === "failed") {
+			task.completedAt = Date.now();
+			task.error = extra?.error;
+		}
+		writeAll(all);
+		return true;
+	});
+}
+async function pauseTask(id) {
+	return fileMutex.run(TASKS_MUTEX_KEY, async () => {
+		const all = readAll();
+		const task = all.find((t) => t.id === id);
+		if (!task || task.status !== "pending") return false;
+		task.status = "paused";
+		writeAll(all);
+		return true;
+	});
+}
+async function resumeTask(id) {
+	return fileMutex.run(TASKS_MUTEX_KEY, async () => {
+		const all = readAll();
+		const task = all.find((t) => t.id === id);
+		if (!task || task.status !== "paused") return false;
+		task.status = "pending";
+		writeAll(all);
+		return true;
+	});
+}
+async function deleteTask(id) {
+	return fileMutex.run(TASKS_MUTEX_KEY, async () => {
+		const all = readAll();
+		const idx = all.findIndex((t) => t.id === id);
+		if (idx === -1) return false;
+		all.splice(idx, 1);
+		writeAll(all);
+		return true;
+	});
+}
+function formatTasksForAI(tasks) {
+	if (tasks.length === 0) return "暂无任务。";
+	const statusLabel = {
+		pending: "等待中",
+		running: "执行中",
+		completed: "已完成",
+		failed: "失败",
+		paused: "已暂停"
+	};
+	return tasks.map((t) => {
+		const created = new Date(t.createdAt).toISOString().replace("T", " ").slice(0, 19);
+		const scheduled = new Date(t.scheduledAt).toISOString().replace("T", " ").slice(0, 19);
+		let entry = `## ${t.name}\n`;
+		entry += `- ID: ${t.id.slice(0, 8)}\n`;
+		entry += `- 状态: ${statusLabel[t.status] || t.status}\n`;
+		entry += `- 创建时间: ${created}\n`;
+		entry += `- 计划执行: ${scheduled}\n`;
+		if (t.prompt) entry += `- 任务描述: ${t.prompt.slice(0, 200)}${t.prompt.length > 200 ? "..." : ""}\n`;
+		if (t.result) entry += `- 执行结果: ${t.result.slice(0, 500)}${t.result.length > 500 ? "..." : ""}\n`;
+		if (t.error) entry += `- 错误: ${t.error.slice(0, 200)}\n`;
+		if (t.completedAt) {
+			const comp = new Date(t.completedAt).toISOString().replace("T", " ").slice(0, 19);
+			entry += `- 完成时间: ${comp}\n`;
+		}
+		return entry;
+	}).join("\n");
+}
+//#endregion
+//#region ../core/dist/storage/utils.js
+function formatSessionTitle(today, count) {
+	return `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, "0")}-${String(today.getDate()).padStart(2, "0")}-${String(count).padStart(2, "0")}`;
+}
+//#endregion
+//#region ../core/dist/storage/memory.js
+/**
+* MemoryStorage — 基于内存 Map 的存储实现
+*
+* 所有数据存储在内存中，进程重启后数据丢失。
+* 适用于开发测试或关闭持久化时使用。
+*/
+var MemoryStorage = class {
+	sessions = /* @__PURE__ */ new Map();
+	messages = /* @__PURE__ */ new Map();
+	messageById = /* @__PURE__ */ new Map();
+	seqCounter = /* @__PURE__ */ new Map();
+	async createSession(title, memorySnapshot, workspace) {
+		const id = crypto.randomUUID();
+		const now = Date.now();
+		const today = new Date(now);
+		const startOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate()).getTime();
+		let count = 0;
+		for (const s of this.sessions.values()) if (s.created_at >= startOfDay) count++;
+		const session = {
+			id,
+			title: title || formatSessionTitle(today, count + 1),
+			created_at: now,
+			updated_at: now,
+			parent_id: null,
+			status: "active",
+			token_count: 0,
+			summary: "",
+			last_summarized_at: null,
+			memory_snapshot: memorySnapshot || "",
+			workspace: workspace || ""
+		};
+		this.sessions.set(id, session);
+		this.messages.set(id, []);
+		this.seqCounter.set(id, 0);
+		return session;
+	}
+	async getSession(id) {
+		return this.sessions.get(id) || null;
+	}
+	async listSessions() {
+		return Array.from(this.sessions.values()).sort((a, b) => b.updated_at - a.updated_at);
+	}
+	async deleteSession(id) {
+		this.sessions.delete(id);
+		const msgs = this.messages.get(id) || [];
+		for (const msg of msgs) this.messageById.delete(msg.id);
+		this.messages.delete(id);
+		this.seqCounter.delete(id);
+	}
+	async archiveSession(id) {
+		const session = this.sessions.get(id);
+		if (session) {
+			session.status = "archived";
+			session.updated_at = Date.now();
+		}
+	}
+	async forkSession(id) {
+		const parent = this.sessions.get(id);
+		if (!parent) throw new Error(`会话不存在: ${id}`);
+		const newSession = await this.createSession(`[分叉] ${parent.title}`, parent.memory_snapshot);
+		newSession.parent_id = id;
+		newSession.token_count = parent.token_count;
+		this.sessions.set(newSession.id, newSession);
+		const parentMessages = this.messages.get(id) || [];
+		const copiedMsgs = [];
+		let seq = 0;
+		for (const msg of parentMessages) {
+			seq++;
+			const copy = {
+				...msg,
+				id: crypto.randomUUID(),
+				session_id: newSession.id,
+				seq
+			};
+			copiedMsgs.push(copy);
+			this.messageById.set(copy.id, copy);
+		}
+		this.messages.set(newSession.id, copiedMsgs);
+		this.seqCounter.set(newSession.id, seq);
+		return newSession;
+	}
+	async addMessage(sessionId, message) {
+		const session = this.sessions.get(sessionId);
+		if (!session) throw new Error(`会话不存在: ${sessionId}`);
+		const seq = (this.seqCounter.get(sessionId) || 0) + 1;
+		this.seqCounter.set(sessionId, seq);
+		const record = {
+			...message,
+			id: message.id || crypto.randomUUID(),
+			created_at: Date.now(),
+			seq
+		};
+		const list = this.messages.get(sessionId) || [];
+		list.push(record);
+		this.messages.set(sessionId, list);
+		this.messageById.set(record.id, record);
+		session.updated_at = Date.now();
+		return record;
+	}
+	async getMessages(sessionId, options) {
+		let list = this.messages.get(sessionId) || [];
+		if (options?.before !== void 0) list = list.filter((m) => m.seq < options.before);
+		if (options?.limit !== void 0) list = list.slice(-options.limit);
+		return list;
+	}
+	async getMessage(id) {
+		return this.messageById.get(id) || null;
+	}
+	async deleteMessage(id) {
+		const msg = this.messageById.get(id);
+		if (!msg) return;
+		this.messageById.delete(id);
+		const list = this.messages.get(msg.session_id);
+		if (list) {
+			const idx = list.findIndex((m) => m.id === id);
+			if (idx !== -1) list.splice(idx, 1);
+		}
+	}
+	async deleteMessagesFrom(sessionId, messageId) {
+		const list = this.messages.get(sessionId);
+		if (!list) return;
+		const idx = list.findIndex((m) => m.id === messageId);
+		if (idx === -1) return;
+		const toDelete = list.splice(idx);
+		for (const msg of toDelete) this.messageById.delete(msg.id);
+	}
+	async getTokenCount(sessionId) {
+		return this.sessions.get(sessionId)?.token_count || 0;
+	}
+	async updateTokenCount(sessionId, count) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.token_count = count;
+	}
+	async setSessionTitle(sessionId, title) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.title = title;
+	}
+	async getStaleSessions(idleMs) {
+		const now = Date.now();
+		const result = [];
+		for (const s of this.sessions.values()) {
+			if (s.status !== "active") continue;
+			if (idleMs !== null && now - s.updated_at <= idleMs) continue;
+			if (s.last_summarized_at !== null && s.last_summarized_at >= s.updated_at) continue;
+			const msgs = this.messages.get(s.id);
+			if (!msgs || msgs.length === 0) continue;
+			result.push(s);
+		}
+		result.sort((a, b) => a.updated_at - b.updated_at);
+		return result;
+	}
+	async getMessagesSinceSeq(sessionId, seq) {
+		return (this.messages.get(sessionId) || []).filter((m) => m.seq > seq);
+	}
+	async updateSummary(sessionId, summary) {
+		const session = this.sessions.get(sessionId);
+		if (session) {
+			session.summary = summary;
+			session.last_summarized_at = Date.now();
+		}
+	}
+	async getTodayUpdatedSessions() {
+		const now = /* @__PURE__ */ new Date();
+		const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+		const endOfDay = startOfDay + 864e5;
+		const result = [];
+		for (const s of this.sessions.values()) if (s.summary && s.last_summarized_at && s.last_summarized_at >= startOfDay && s.last_summarized_at < endOfDay) result.push(s);
+		result.sort((a, b) => (a.last_summarized_at || 0) - (b.last_summarized_at || 0));
+		return result;
+	}
+	async setMemorySnapshot(sessionId, snapshot) {
+		const session = this.sessions.get(sessionId);
+		if (session) session.memory_snapshot = snapshot;
+	}
+	async searchMessages(query, sessionId, limit = 10) {
+		const lowerQuery = query.toLowerCase();
+		const results = [];
+		for (const [sid, msgs] of this.messages) {
+			if (sessionId && sid !== sessionId) continue;
+			const session = this.sessions.get(sid);
+			for (const msg of msgs) {
+				if (!msg.content.toLowerCase().includes(lowerQuery)) continue;
+				results.push({
+					sessionId: sid,
+					sessionTitle: session?.title || "",
+					messageId: msg.id,
+					role: msg.role,
+					content: msg.content,
+					createdAt: msg.created_at
+				});
+			}
+		}
+		results.sort((a, b) => b.createdAt - a.createdAt);
+		return results.slice(0, limit);
+	}
+	async setAudioPath(messageId, path) {
+		const msg = this.messageById.get(messageId);
+		if (msg) msg.audio_path = path;
+	}
+	async getMostRecentSession() {
+		for (const s of this.sessions.values()) if (s.status === "active") return s;
+		return null;
+	}
+	async listWorkspaces() {
+		const workspaces = /* @__PURE__ */ new Set();
+		for (const s of this.sessions.values()) if (s.status === "active" && s.workspace) workspaces.add(s.workspace);
+		return Array.from(workspaces).sort();
+	}
+};
+//#endregion
+//#region ../core/dist/storage/sqlite.js
+/**
+* SQLiteStorage — 基于 better-sqlite3 的持久化存储
+*
+* 使用 WAL 模式，支持外键约束。
+* 自动建表，联合索引 (session_id, seq)。
+*/
+var SQLiteStorage = class {
+	db;
+	stmts;
+	constructor(dbPath) {
+		this.db = new Database(dbPath);
+		this.db.pragma("journal_mode = WAL");
+		this.db.pragma("foreign_keys = ON");
+		this.initTables();
+		this.stmts = this.prepareStatements();
+	}
+	initTables() {
+		this.db.exec(`
+		CREATE TABLE IF NOT EXISTS sessions (
+			id          TEXT PRIMARY KEY,
+			title       TEXT NOT NULL DEFAULT '',
+			created_at  INTEGER NOT NULL,
+			updated_at  INTEGER NOT NULL,
+			parent_id   TEXT,
+			status      TEXT NOT NULL DEFAULT 'active',
+			token_count INTEGER NOT NULL DEFAULT 0,
+			summary     TEXT NOT NULL DEFAULT '',
+			last_summarized_at INTEGER,
+			memory_snapshot TEXT NOT NULL DEFAULT '',
+			workspace   TEXT NOT NULL DEFAULT ''
+		);
+			CREATE TABLE IF NOT EXISTS messages (
+				id                 TEXT PRIMARY KEY,
+				session_id         TEXT NOT NULL,
+				role               TEXT NOT NULL,
+				content            TEXT NOT NULL DEFAULT '',
+				reasoning_content  TEXT,
+				tool_calls         TEXT,
+				tool_call_id       TEXT,
+				name               TEXT,
+				usage              TEXT,
+				audio_path         TEXT,
+				created_at         INTEGER NOT NULL,
+				seq                INTEGER NOT NULL,
+				FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+			);
+			CREATE INDEX IF NOT EXISTS idx_messages_session_seq
+				ON messages(session_id, seq);
+		`);
+		this.migrate();
+	}
+	migrate() {
+		const cols = this.db.pragma("table_info(sessions)");
+		const columnNames = new Set(cols.map((c) => c.name));
+		if (!columnNames.has("summary")) this.db.exec(`ALTER TABLE sessions ADD COLUMN summary TEXT NOT NULL DEFAULT ''`);
+		if (!columnNames.has("last_summarized_at")) this.db.exec(`ALTER TABLE sessions ADD COLUMN last_summarized_at INTEGER`);
+		if (!columnNames.has("memory_snapshot")) this.db.exec(`ALTER TABLE sessions ADD COLUMN memory_snapshot TEXT NOT NULL DEFAULT ''`);
+		if (!columnNames.has("workspace")) this.db.exec(`ALTER TABLE sessions ADD COLUMN workspace TEXT NOT NULL DEFAULT ''`);
+	}
+	prepareStatements() {
+		return {
+			createSession: this.db.prepare(`INSERT INTO sessions (id, title, created_at, updated_at, parent_id, status, token_count, summary, last_summarized_at, memory_snapshot, workspace) VALUES (?, ?, ?, ?, ?, ?, ?, '', NULL, ?, ?)`),
+			getSession: this.db.prepare(`SELECT * FROM sessions WHERE id = ?`),
+			listAllSessions: this.db.prepare(`SELECT * FROM sessions ORDER BY updated_at DESC`),
+			deleteSession: this.db.prepare(`DELETE FROM sessions WHERE id = ?`),
+			updateSessionStatus: this.db.prepare(`UPDATE sessions SET status = ?, updated_at = ? WHERE id = ?`),
+			updateSession: this.db.prepare(`UPDATE sessions SET title = ?, updated_at = ?, token_count = ? WHERE id = ?`),
+			insertMessage: this.db.prepare(`INSERT INTO messages (id, session_id, role, content, reasoning_content, tool_calls, tool_call_id, name, usage, audio_path, created_at, seq) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`),
+			getMessages: this.db.prepare(`SELECT * FROM messages WHERE session_id = ? AND (? IS NULL OR seq < ?) ORDER BY seq ASC`),
+			getMessagesSinceSeq: this.db.prepare(`SELECT * FROM messages WHERE session_id = ? AND seq > ? ORDER BY seq ASC`),
+			getMessage: this.db.prepare(`SELECT * FROM messages WHERE id = ?`),
+			deleteMessage: this.db.prepare(`DELETE FROM messages WHERE id = ?`),
+			getMaxSeq: this.db.prepare(`SELECT COALESCE(MAX(seq), 0) as max_seq FROM messages WHERE session_id = ?`),
+			updateAudioPath: this.db.prepare(`UPDATE messages SET audio_path = ? WHERE id = ?`),
+			deleteFromSeq: this.db.prepare(`DELETE FROM messages WHERE session_id = ? AND seq >= ?`),
+			setTitle: this.db.prepare(`UPDATE sessions SET title = ? WHERE id = ?`),
+			updateSummary: this.db.prepare(`UPDATE sessions SET summary = ?, last_summarized_at = ? WHERE id = ?`),
+			getStaleSessions: this.db.prepare(`SELECT * FROM sessions WHERE status = 'active' AND (? - updated_at > ?) AND (last_summarized_at IS NULL OR last_summarized_at < updated_at) AND id IN (SELECT DISTINCT session_id FROM messages) ORDER BY updated_at ASC`),
+			getAllUnsummarized: this.db.prepare(`SELECT * FROM sessions WHERE status = 'active' AND (last_summarized_at IS NULL OR last_summarized_at < updated_at) AND id IN (SELECT DISTINCT session_id FROM messages) ORDER BY updated_at ASC`),
+			getTodayUpdated: this.db.prepare(`SELECT * FROM sessions WHERE summary != '' AND last_summarized_at >= ? AND last_summarized_at < ? ORDER BY last_summarized_at ASC`),
+			setMemorySnapshot: this.db.prepare(`UPDATE sessions SET memory_snapshot = ? WHERE id = ?`),
+			countToday: this.db.prepare(`SELECT COUNT(*) as cnt FROM sessions WHERE created_at >= ? AND created_at < ?`),
+			searchMessages: this.db.prepare(`SELECT m.id as messageId, m.session_id as sessionId, m.role, m.content, m.created_at as createdAt, s.title as sessionTitle FROM messages m JOIN sessions s ON m.session_id = s.id WHERE m.content LIKE ? AND (? IS NULL OR m.session_id = ?) ORDER BY m.created_at DESC LIMIT ?`)
+		};
+	}
+	async createSession(title, memorySnapshot, workspace) {
+		const id = crypto.randomUUID();
+		const now = Date.now();
+		const effectiveTitle = title || this.generateDefaultTitle(now);
+		this.stmts.createSession.run(id, effectiveTitle, now, now, null, "active", 0, memorySnapshot || "", workspace || "");
+		return await this.getSession(id);
+	}
+	generateDefaultTitle(now) {
+		const today = new Date(now);
+		const startOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate()).getTime();
+		const endOfDay = startOfDay + 864e5;
+		const { cnt } = this.stmts.countToday.get(startOfDay, endOfDay);
+		return formatSessionTitle(today, cnt + 1);
+	}
+	async getSession(id) {
+		const row = this.stmts.getSession.get(id);
+		return row ? this.rowToSession(row) : null;
+	}
+	async listSessions() {
+		return this.stmts.listAllSessions.all().map((row) => this.rowToSession(row));
+	}
+	async deleteSession(id) {
+		this.stmts.deleteSession.run(id);
+	}
+	async archiveSession(id) {
+		this.stmts.updateSessionStatus.run("archived", Date.now(), id);
+	}
+	async forkSession(id) {
+		const parent = await this.getSession(id);
+		if (!parent) throw new Error(`会话不存在: ${id}`);
+		const newSession = await this.createSession(`[分叉] ${parent.title}`, parent.memory_snapshot);
+		const now = Date.now();
+		this.db.prepare("UPDATE sessions SET parent_id = ? WHERE id = ?").run(id, newSession.id);
+		const parentMessages = await this.getMessages(id);
+		let seq = 0;
+		for (const msg of parentMessages) {
+			seq++;
+			this.stmts.insertMessage.run(crypto.randomUUID(), newSession.id, msg.role, msg.content, msg.reasoning_content || null, msg.tool_calls ? JSON.stringify(msg.tool_calls) : null, msg.tool_call_id || null, msg.name || null, msg.usage ? JSON.stringify(msg.usage) : null, msg.audio_path || null, msg.created_at, seq);
+		}
+		this.db.prepare("UPDATE sessions SET token_count = ?, updated_at = ? WHERE id = ?").run(parent.token_count, now, newSession.id);
+		return await this.getSession(newSession.id);
+	}
+	async addMessage(sessionId, message) {
+		const session = await this.getSession(sessionId);
+		if (!session) throw new Error(`会话不存在: ${sessionId}`);
+		const { max_seq } = this.stmts.getMaxSeq.get(sessionId);
+		const seq = max_seq + 1;
+		const id = message.id || crypto.randomUUID();
+		const now = Date.now();
+		this.stmts.insertMessage.run(id, sessionId, message.role, message.content, message.reasoning_content || null, message.tool_calls ? JSON.stringify(message.tool_calls) : null, message.tool_call_id || null, message.name || null, message.usage ? JSON.stringify(message.usage) : null, message.audio_path || null, now, seq);
+		this.stmts.updateSession.run(session.title, now, session.token_count, sessionId);
+		return await this.getMessage(id);
+	}
+	async getMessages(sessionId, options) {
+		const before = options?.before ?? null;
+		let result = this.stmts.getMessages.all(sessionId, before, before).map((row) => this.rowToMessage(row));
+		if (options?.limit !== void 0) result = result.slice(-options.limit);
+		return result;
+	}
+	async getMessage(id) {
+		const row = this.stmts.getMessage.get(id);
+		return row ? this.rowToMessage(row) : null;
+	}
+	async deleteMessage(id) {
+		this.stmts.deleteMessage.run(id);
+	}
+	async deleteMessagesFrom(sessionId, messageId) {
+		const msg = this.stmts.getMessage.get(messageId);
+		if (!msg) return;
+		this.stmts.deleteFromSeq.run(sessionId, msg.seq);
+	}
+	async getTokenCount(sessionId) {
+		return (await this.getSession(sessionId))?.token_count || 0;
+	}
+	async updateTokenCount(sessionId, count) {
+		const session = await this.getSession(sessionId);
+		if (session) this.stmts.updateSession.run(session.title, Date.now(), count, sessionId);
+	}
+	async setSessionTitle(sessionId, title) {
+		this.stmts.setTitle.run(title, sessionId);
+	}
+	async searchMessages(query, sessionId, limit = 10) {
+		const pattern = `%${query}%`;
+		return this.stmts.searchMessages.all(pattern, sessionId || null, sessionId || null, limit).map((r) => ({
+			sessionId: r.sessionId,
+			sessionTitle: r.sessionTitle,
+			messageId: r.messageId,
+			role: r.role,
+			content: r.content,
+			createdAt: r.createdAt
+		}));
+	}
+	async setAudioPath(messageId, path) {
+		this.stmts.updateAudioPath.run(path, messageId);
+	}
+	async getMostRecentSession() {
+		const rows = this.stmts.listAllSessions.all();
+		for (const row of rows) if (row.status === "active") return this.rowToSession(row);
+		return null;
+	}
+	async listWorkspaces() {
+		return this.db.prepare(`SELECT DISTINCT workspace FROM sessions WHERE status = 'active' AND workspace != '' ORDER BY workspace ASC`).all().map((r) => r.workspace);
+	}
+	async getStaleSessions(idleMs) {
+		let rows;
+		if (idleMs === null) rows = this.stmts.getAllUnsummarized.all();
+		else {
+			const now = Date.now();
+			rows = this.stmts.getStaleSessions.all(now, idleMs);
+		}
+		return rows.map((row) => this.rowToSession(row));
+	}
+	async getMessagesSinceSeq(sessionId, seq) {
+		return this.stmts.getMessagesSinceSeq.all(sessionId, seq).map((row) => this.rowToMessage(row));
+	}
+	async updateSummary(sessionId, summary) {
+		this.stmts.updateSummary.run(summary, Date.now(), sessionId);
+	}
+	async getTodayUpdatedSessions() {
+		const now = /* @__PURE__ */ new Date();
+		const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+		const endOfDay = startOfDay + 864e5;
+		return this.stmts.getTodayUpdated.all(startOfDay, endOfDay).map((row) => this.rowToSession(row));
+	}
+	async setMemorySnapshot(sessionId, snapshot) {
+		this.stmts.setMemorySnapshot.run(snapshot, sessionId);
+	}
+	rowToSession(row) {
+		return {
+			id: row.id,
+			title: row.title,
+			created_at: row.created_at,
+			updated_at: row.updated_at,
+			parent_id: row.parent_id,
+			status: row.status,
+			token_count: row.token_count,
+			summary: row.summary || "",
+			last_summarized_at: row.last_summarized_at ?? null,
+			memory_snapshot: row.memory_snapshot || "",
+			workspace: row.workspace || ""
+		};
+	}
+	rowToMessage(row) {
+		return {
+			id: row.id,
+			session_id: row.session_id,
+			role: row.role,
+			content: row.content,
+			reasoning_content: row.reasoning_content || void 0,
+			tool_calls: row.tool_calls ? JSON.parse(row.tool_calls) : void 0,
+			tool_call_id: row.tool_call_id || void 0,
+			name: row.name || void 0,
+			usage: row.usage ? JSON.parse(row.usage) : void 0,
+			audio_path: row.audio_path || void 0,
+			created_at: row.created_at,
+			seq: row.seq
+		};
+	}
+};
+//#endregion
+//#region ../core/dist/storage/index.js
+var _memory = null;
+var _sqlite = null;
+function createStorage(config) {
+	if (config.enabled) {
+		if (!_sqlite) _sqlite = new SQLiteStorage(config.dbPath || getDataPath("db.sqlite"));
+		return _sqlite;
+	}
+	if (!_memory) _memory = new MemoryStorage();
+	return _memory;
+}
+//#endregion
+//#region ../core/dist/task/executor.js
+var TASK_TIMEOUT_MS = 600 * 1e3;
+async function executeTask(task, onComplete) {
+	if (!await updateTaskStatus(task.id, "running")) return;
+	let result = "";
+	let error;
+	try {
+		const config = readConfig();
+		if (!config.activeModel) throw new Error("未选择模型");
+		const providerConfig = getProviderForModel(config.activeModel);
+		if (!providerConfig) throw new Error("未找到供应商配置");
+		const model = getActiveModel();
+		const provider = createProvider({
+			...providerConfig,
+			activeModel: model?.id || config.activeModel,
+			contextWindow: model?.contextWindow || 1048576
+		});
+		const storage = createStorage({ enabled: false });
+		const registry = new ToolRegistry();
+		for (const t of CORE_TOOLS) if (t.name !== "write_memory") registry.register(t);
+		registry.register(createSearchHistoryTool(storage));
+		const abortController = new AbortController();
+		const timeout = setTimeout(() => abortController.abort(), TASK_TIMEOUT_MS);
+		try {
+			const buildResult = {
+				messages: [{
+					role: "system",
+					content: `You are a background automation agent. Execute the task description strictly and output a concise result summary in Chinese.
+Do not ask the user any questions. Do not wait for confirmation. Do not create new scheduled tasks.
+If an operation requires confirmation, skip it and explain why.`
+				}, {
+					role: "user",
+					content: task.prompt
+				}],
+				contextWindow: getContextWindow()
+			};
+			const agent = new AgentLoop(provider, storage, registry, async () => false, abortController.signal, new AgentLogger(`task-${task.id.slice(0, 8)}`), config.compressionMode, config.compressionThreshold);
+			const sid = (await storage.createSession(void 0, void 0, process.cwd())).id;
+			for await (const event of agent.run(sid, task.prompt, buildResult)) if (event.type === "content") result += event.text;
+			else if (event.type === "error") error = event.message;
+			else if (event.type === "retry_exhausted") error = event.message;
+		} finally {
+			clearTimeout(timeout);
+		}
+		if (error) await updateTaskStatus(task.id, "failed", { error });
+		else {
+			result = result.trim();
+			await updateTaskStatus(task.id, "completed", { result });
+		}
+		await onComplete(result, error);
+	} catch (e) {
+		error = e.message;
+		await updateTaskStatus(task.id, "failed", { error });
+		await onComplete("", error);
+	}
+}
+//#endregion
+//#region ../core/dist/task/scheduler.js
+var SCAN_INTERVAL_MS = 15e3;
+var worker = null;
+var notificationCallback = null;
+function setTaskNotificationHandler(fn) {
+	notificationCallback = fn;
+}
+async function tick() {
+	const pending = getPendingTasks();
+	for (const task of pending) await executeTask(task, async (result, error) => {
+		if (notificationCallback) if (error) await notificationCallback({
+			title: `任务失败: ${task.name}`,
+			body: error,
+			type: "error"
+		});
+		else {
+			const preview = result.slice(0, 300) + (result.length > 300 ? "..." : "");
+			await notificationCallback({
+				title: `任务完成: ${task.name}`,
+				body: preview,
+				type: "task_complete"
+			});
+		}
+	});
+}
+function startScheduler() {
+	if (worker) return;
+	worker = new BackgroundWorker();
+	worker.schedule("task-tick", SCAN_INTERVAL_MS, tick);
+	worker.start();
+}
+//#endregion
+//#region ../core/dist/tool/tools/schedule-task.js
+var scheduleTaskTool = {
+	name: "schedule_task",
+	description: "Create a scheduled one-shot task. The task runs automatically at the specified future time (no conversation context) and the user is notified on completion. Before using, run exec to get the current system time to ensure scheduledAt is in the future.",
+	parameters: {
+		type: "object",
+		properties: {
+			name: {
+				type: "string",
+				description: "Task name (short description, e.g. \"Data processing\")"
+			},
+			prompt: {
+				type: "string",
+				description: "Task description — this is the sole instruction the model receives when executing in the background with no conversation context. Must be self-contained: what to do, expected output format, any necessary details"
+			},
+			scheduledAt: {
+				type: "string",
+				description: "ISO 8601 datetime string (e.g. 2026-06-16T14:30:00Z). Must be in the future. Use exec to get current system time first."
+			}
+		},
+		required: [
+			"name",
+			"prompt",
+			"scheduledAt"
+		]
+	},
+	execute: async (args) => {
+		const name = args.name;
+		const prompt = args.prompt;
+		const scheduledAtStr = args.scheduledAt;
+		if (!name?.trim() || !prompt?.trim() || !scheduledAtStr?.trim()) return {
+			success: false,
+			output: "",
+			error: "参数不完整：name、prompt、scheduledAt 均为必填"
+		};
+		const scheduledAt = new Date(scheduledAtStr).getTime();
+		if (isNaN(scheduledAt)) return {
+			success: false,
+			output: "",
+			error: `无法解析时间 "${scheduledAtStr}"，请使用 ISO 8601 格式，如 2026-06-16T14:30:00Z`
+		};
+		const now = Date.now();
+		if (scheduledAt <= now) return {
+			success: false,
+			output: "",
+			error: `计划执行时间 ${scheduledAtStr} 已过期。当前时间是 ${new Date(now).toISOString()}，请设置一个未来的时间`
+		};
+		if (scheduledAt > now + 720 * 60 * 60 * 1e3) return {
+			success: false,
+			output: "",
+			error: `计划执行时间不能超过 30 天后`
+		};
+		const task = await createTask(name.trim(), prompt.trim(), scheduledAt);
+		const formatted = new Date(scheduledAt).toISOString().replace("T", " ").slice(0, 19);
+		return {
+			success: true,
+			output: `任务已创建:\n- ID: ${task.id.slice(0, 8)}\n- 名称: ${task.name}\n- 计划执行: ${formatted}\n\n任务将在指定时间自动执行，完成后通过 Email 通知你。`
+		};
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/read-tasks.js
+var readTasksTool = {
+	name: "read_tasks",
+	description: "Query scheduled task list and results. View all tasks (pending, running, completed, failed, paused) or filter by status. The AI is NOT automatically notified of completions — you must manually call this tool to check.",
+	parameters: {
+		type: "object",
+		properties: { status: {
+			type: "string",
+			description: "Filter by status: pending, running, completed, failed, paused. Omit to return all."
+		} },
+		required: []
+	},
+	execute: async (args) => {
+		const statusFilter = args.status?.trim();
+		let tasks = getAllTasks();
+		if (statusFilter) {
+			const valid = [
+				"pending",
+				"running",
+				"completed",
+				"failed",
+				"paused"
+			];
+			if (!valid.includes(statusFilter)) return {
+				success: false,
+				output: "",
+				error: `无效的状态值 "${statusFilter}"，可选: ${valid.join(", ")}`
+			};
+			tasks = tasks.filter((t) => t.status === statusFilter);
+		}
+		return {
+			success: true,
+			output: formatTasksForAI(tasks)
+		};
+	}
+};
+//#endregion
+//#region ../core/dist/tool/tools/search-history.js
+function formatResults(results, query) {
+	if (results.length === 0) return `（未在历史对话中找到与 "${query}" 相关的内容）`;
+	const lines = [`找到 ${results.length} 条与 "${query}" 相关的结果：`];
+	let lastSession = "";
+	for (const r of results) {
+		if (r.sessionTitle !== lastSession) {
+			lastSession = r.sessionTitle;
+			lines.push("", `--- ${r.sessionTitle} ---`);
+		}
+		const date = new Date(r.createdAt).toLocaleString("zh-CN");
+		const roleLabel = r.role === "user" ? "用户" : r.role === "assistant" ? "AI" : r.role;
+		const snippet = r.content.length > 200 ? r.content.slice(0, 200) + "..." : r.content;
+		lines.push(`[${date}] ${roleLabel}: ${snippet}`);
+	}
+	return lines.join("\n");
+}
+function createSearchHistoryTool(storage) {
+	return {
+		name: "search_history",
+		description: "Search conversation history across all sessions with fuzzy text matching. Use when you need to recall what the user discussed before. Note: this searches chat records, not long-term memory (use read_memory for that).",
+		parameters: {
+			type: "object",
+			properties: {
+				query: {
+					type: "string",
+					description: "Search keyword or phrase (case-insensitive). Matches content field of all messages."
+				},
+				session_id: {
+					type: "string",
+					description: "Optional. Limit search to a specific session. Omit to search all sessions."
+				},
+				limit: {
+					type: "number",
+					description: "Optional. Max results, default 10."
+				}
+			},
+			required: ["query"]
+		},
+		async execute(args, _ctx) {
+			const query = args.query;
+			const sessionId = args.session_id;
+			const limit = args.limit || 10;
+			if (!query?.trim()) return {
+				success: false,
+				output: "",
+				error: "query 不能为空"
+			};
+			try {
+				return {
+					success: true,
+					output: formatResults(await storage.searchMessages(query.trim(), sessionId || void 0, limit), query.trim())
+				};
+			} catch (error) {
+				return {
+					success: false,
+					output: "",
+					error: `搜索失败: ${error.message}`
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region ../core/dist/tool/index.js
+/** 核心工具集：文件操作 + 搜索 + 记忆（Chat / Gateway 使用，再拼接 SCHEDULING_TOOLS 即为全量） */
+var CORE_TOOLS = [
+	readFileTool,
+	writeFileTool,
+	deleteFileTool,
+	editTool,
+	execTool,
+	webSearchTool,
+	readMemoryTool,
+	writeMemoryTool
+];
+/** 调度工具集 */
+var SCHEDULING_TOOLS = [scheduleTaskTool, readTasksTool];
+//#endregion
+//#region ../core/dist/agent/types.js
+/**
+* AgentLoop 状态机状态枚举
+*
+* 每个状态对应循环中的一个确定阶段，状态转换时触发对应的 LoopHooks 回调。
+*/
+var AgentState;
+(function(AgentState) {
+	AgentState["INIT"] = "INIT";
+	AgentState["PRE_LLM"] = "PRE_LLM";
+	AgentState["LLM_STREAMING"] = "LLM_STREAMING";
+	AgentState["POST_LLM"] = "POST_LLM";
+	AgentState["LLM_RETRY_WAIT"] = "LLM_RETRY_WAIT";
+	AgentState["PRE_TOOL"] = "PRE_TOOL";
+	AgentState["TOOL_EXECUTING"] = "TOOL_EXECUTING";
+	AgentState["AWAIT_CONFIRM"] = "AWAIT_CONFIRM";
+	AgentState["POST_TOOL"] = "POST_TOOL";
+	AgentState["PERSIST_TURN"] = "PERSIST_TURN";
+	AgentState["DONE"] = "DONE";
+	AgentState["ERROR"] = "ERROR";
+})(AgentState || (AgentState = {}));
+//#endregion
+//#region ../core/dist/agent/message-sanitizer.js
+function extractTextContent$1(content) {
+	if (typeof content === "string") return content;
+	return content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+function mergeContent(a, b) {
+	return extractTextContent$1(a) + "\n\n" + extractTextContent$1(b);
+}
+var SURROGATE_RE = /[\uD800-\uDFFF]/g;
+function stripSurrogates(text) {
+	return text.replace(SURROGATE_RE, "�");
+}
+function cleanContent(content) {
+	if (typeof content === "string") return stripSurrogates(content);
+	return content.map((part) => {
+		if (part.type === "text") return {
+			...part,
+			text: stripSurrogates(part.text)
+		};
+		return part;
+	});
+}
+/**
+* 修复相邻相同角色消息：
+* - 连续 user → 合并为一条（内容拼接）
+* - 连续 assistant（不含 tool_calls）→ 合并
+* - 连续 assistant 其中之一有 tool_calls → 保留两者（tool_calls 不能合并）
+*/
+function repairRoleAlternation(messages) {
+	if (messages.length <= 1) return messages;
+	const result = [messages[0]];
+	for (let i = 1; i < messages.length; i++) {
+		const prev = result[result.length - 1];
+		const curr = messages[i];
+		if (prev.role === curr.role && curr.role === "user") result[result.length - 1] = {
+			role: "user",
+			content: mergeContent(prev.content, curr.content)
+		};
+		else if (prev.role === curr.role && curr.role === "assistant") if (prev.tool_calls || curr.tool_calls) result.push(curr);
+		else {
+			const merged = {
+				role: "assistant",
+				content: mergeContent(prev.content, curr.content)
+			};
+			if (prev.reasoning_content || curr.reasoning_content) merged.reasoning_content = [prev.reasoning_content, curr.reasoning_content].filter(Boolean).join("\n\n");
+			if (prev.name) merged.name = prev.name;
+			result[result.length - 1] = merged;
+		}
+		else result.push(curr);
+	}
+	return result;
+}
+/**
+* 移除孤儿 tool 结果：
+* tool role 消息的 tool_call_id 必须在前面的 assistant.tool_calls 中存在。
+*/
+function stripOrphanToolResults(messages) {
+	const activeToolIds = /* @__PURE__ */ new Set();
+	for (const msg of messages) if (msg.role === "assistant" && msg.tool_calls) for (const tc of msg.tool_calls) activeToolIds.add(tc.id);
+	return messages.filter((msg) => {
+		if (msg.role !== "tool") return true;
+		if (!msg.tool_call_id) return false;
+		return activeToolIds.has(msg.tool_call_id);
+	});
+}
+function stripEmptyMessages(messages) {
+	return messages.filter((msg) => {
+		if (extractTextContent$1(msg.content).trim() === "" && !msg.tool_calls && msg.role !== "tool") return false;
+		return true;
+	});
+}
+/**
+* 消息清洗管道
+*
+* 1. 移除空消息（无内容且无 tool_calls）
+* 2. 清除 Unicode surrogate（\uD800-\uDFFF）
+* 3. 修复角色交替（合并连续 user/assistant）
+* 4. 移除孤儿 tool 结果（无匹配 tool_call_id）
+*
+* 返回新的 Message 数组，不修改原数组。
+*/
+function sanitizeMessages(messages) {
+	let result = stripEmptyMessages(messages);
+	result = result.map((msg) => {
+		const cleaned = {
+			role: msg.role,
+			content: cleanContent(msg.content)
+		};
+		if (msg.name) cleaned.name = stripSurrogates(msg.name);
+		if (msg.tool_call_id) cleaned.tool_call_id = stripSurrogates(msg.tool_call_id);
+		if (msg.reasoning_content) cleaned.reasoning_content = stripSurrogates(msg.reasoning_content);
+		if (msg.tool_calls) cleaned.tool_calls = msg.tool_calls.map((tc) => ({
+			...tc,
+			function: {
+				name: stripSurrogates(tc.function.name),
+				arguments: stripSurrogates(tc.function.arguments)
+			}
+		}));
+		return cleaned;
+	});
+	result = repairRoleAlternation(result);
+	result = stripOrphanToolResults(result);
+	return result;
+}
+//#endregion
+//#region ../core/dist/agent/loop.js
+function extractTextContent(content) {
+	if (typeof content === "string") return content;
+	return content.filter((p) => p.type === "text" && "text" in p).map((p) => p.text).join("\n");
+}
+var MAX_LLM_RETRIES = 5;
+var RETRY_BASE_DELAY = 1e3;
+var CONTEXT_WINDOW_DEFAULT = 1048576;
+var CONTINUE_THRESHOLD = 2e4;
+var MAX_TOOL_ITERATIONS$1 = 50;
+var COMPRESSION_THRESHOLD_DEFAULT = 256e3;
+function buildSummaryContent(messages, initialSystem) {
+	const relevant = messages.filter((m) => m.role !== "system").filter((m) => m.role !== "tool");
+	let header = "";
+	if (initialSystem) header = `原始系统提示词摘要: ${initialSystem.slice(0, 200)}\n\n`;
+	const lines = [];
+	for (const m of relevant) {
+		const role = m.role === "user" ? "用户" : "AI";
+		const text = extractTextContent(m.content);
+		lines.push(`[${role}] ${text.slice(0, 2e3)}`);
+	}
+	return header + lines.join("\n");
+}
+var AgentLoop = class {
+	provider;
+	storage;
+	registry;
+	onConfirm;
+	signal;
+	hooks;
+	state = AgentState.INIT;
+	effectiveSessionId = "";
+	contextWindow = CONTEXT_WINDOW_DEFAULT;
+	buildResult;
+	userMsg;
+	messages = [];
+	tools = [];
+	totalUsage;
+	iteration = 0;
+	fullContent = "";
+	fullReasoning = "";
+	collectedToolCalls = /* @__PURE__ */ new Map();
+	chunkUsage;
+	attempt = 0;
+	resolvedToolCalls = [];
+	toolIndex = 0;
+	toolResultMsgs = [];
+	currentToolCall;
+	currentArgs = {};
+	pendingConfirmation;
+	toolContext;
+	compressionMode;
+	compressionThreshold;
+	constructor(provider, storage, registry, onConfirm, signal, hooks = {}, compressionMode = "auto", compressionThreshold = COMPRESSION_THRESHOLD_DEFAULT) {
+		this.provider = provider;
+		this.storage = storage;
+		this.registry = registry;
+		this.onConfirm = onConfirm;
+		this.signal = signal;
+		this.hooks = hooks;
+		this.toolContext = new ToolContext(process.cwd());
+		this.compressionMode = compressionMode;
+		this.compressionThreshold = compressionThreshold;
+	}
+	async *run(sessionId, userMessage, buildResult, userMessageId) {
+		this.effectiveSessionId = sessionId;
+		this.contextWindow = buildResult.contextWindow || CONTEXT_WINDOW_DEFAULT;
+		this.buildResult = buildResult;
+		this.messages = [...buildResult.messages];
+		this.tools = this.registry.getDefinitions();
+		this.totalUsage = void 0;
+		this.iteration = 0;
+		this.state = AgentState.INIT;
+		const session = await this.storage.getSession(sessionId);
+		if (session?.workspace) this.toolContext = new ToolContext(session.workspace);
+		pendingSteering.delete(sessionId);
+		try {
+			while (true) {
+				if (this.state === AgentState.DONE || this.state === AgentState.ERROR) break;
+				switch (this.state) {
+					case AgentState.INIT:
+						yield* this.doInit(userMessage, userMessageId);
+						break;
+					case AgentState.PRE_LLM:
+						yield* this.doPreLlm();
+						break;
+					case AgentState.LLM_STREAMING:
+						yield* this.doLlmStreaming();
+						break;
+					case AgentState.POST_LLM:
+						yield* this.doPostLlm();
+						break;
+					case AgentState.LLM_RETRY_WAIT:
+						yield* this.doLlmRetryWait();
+						break;
+					case AgentState.PRE_TOOL:
+						yield* this.doPreTool();
+						break;
+					case AgentState.TOOL_EXECUTING:
+						yield* this.doToolExecuting();
+						break;
+					case AgentState.AWAIT_CONFIRM:
+						yield* this.doAwaitConfirm();
+						break;
+					case AgentState.POST_TOOL:
+						yield* this.doPostTool();
+						break;
+					case AgentState.PERSIST_TURN:
+						yield* this.doPersistTurn();
+						break;
+					case AgentState.DONE:
+					case AgentState.ERROR: break;
+				}
+			}
+		} catch (error) {
+			yield {
+				type: "error",
+				message: error.message || "未知错误"
+			};
+		}
+	}
+	async *doInit(userMessage, userMessageId) {
+		this.userMsg = await this.storage.addMessage(this.effectiveSessionId, {
+			id: userMessageId,
+			session_id: this.effectiveSessionId,
+			role: "user",
+			content: userMessage
+		});
+		this.state = AgentState.PRE_LLM;
+	}
+	async *doPreLlm() {
+		if (this.signal?.aborted) {
+			this.state = AgentState.DONE;
+			return;
+		}
+		if (this.iteration >= MAX_TOOL_ITERATIONS$1) {
+			yield {
+				type: "error",
+				message: `达到最大工具调用次数限制（${MAX_TOOL_ITERATIONS$1}次），请简化任务后重试`
+			};
+			this.state = AgentState.ERROR;
+			return;
+		}
+		this.fullContent = "";
+		this.fullReasoning = "";
+		this.collectedToolCalls.clear();
+		this.chunkUsage = void 0;
+		this.attempt = 0;
+		yield* this.consumeSteering();
+		const modified = await this.hooks.beforeLlmCall?.(this.messages);
+		if (modified) this.messages = modified;
+		this.state = AgentState.LLM_STREAMING;
+	}
+	async *consumeSteering() {
+		const steering = pendingSteering.get(this.effectiveSessionId);
+		if (!steering || steering.length === 0) return;
+		const drained = steering.splice(0);
+		for (const s of drained) {
+			await this.storage.addMessage(this.effectiveSessionId, {
+				session_id: this.effectiveSessionId,
+				role: "user",
+				content: s.text
+			});
+			this.messages.push({
+				role: "user",
+				content: s.text
+			});
+			yield {
+				type: "steering_consumed",
+				messageId: s.messageId
+			};
+		}
+	}
+	async *doLlmStreaming() {
+		try {
+			const apiMessages = sanitizeMessages(this.messages);
+			const stream = this.provider.chatStream({
+				messages: apiMessages,
+				tools: this.tools.length > 0 ? this.tools : void 0
+			});
+			for await (const chunk of stream) {
+				if (chunk.reasoning_content) {
+					this.fullReasoning += chunk.reasoning_content;
+					yield {
+						type: "reasoning",
+						text: chunk.reasoning_content
+					};
+				}
+				if (chunk.content) {
+					this.fullContent += chunk.content;
+					yield {
+						type: "content",
+						text: chunk.content
+					};
+				}
+				if (chunk.tool_calls) for (const tc of chunk.tool_calls) {
+					const existing = this.collectedToolCalls.get(tc.index);
+					if (existing) {
+						if (tc.function?.arguments) existing.function.arguments += tc.function.arguments;
+					} else if (tc.id) {
+						const newTc = {
+							id: tc.id,
+							type: "function",
+							function: {
+								name: tc.function?.name || "",
+								arguments: tc.function?.arguments || ""
+							}
+						};
+						this.collectedToolCalls.set(tc.index, newTc);
+					}
+				}
+				if (chunk.usage) this.chunkUsage = chunk.usage;
+			}
+			this.state = AgentState.POST_LLM;
+		} catch (llmError) {
+			this.fullContent = "";
+			this.collectedToolCalls.clear();
+			this.chunkUsage = void 0;
+			if (this.attempt >= MAX_LLM_RETRIES) {
+				const errorMessage = `[连接失败] ${llmError.message || "多次重试后仍无法连接"}`;
+				await this.storage.addMessage(this.effectiveSessionId, {
+					session_id: this.effectiveSessionId,
+					role: "assistant",
+					content: errorMessage
+				});
+				yield {
+					type: "retry_exhausted",
+					message: llmError.message || "连接失败",
+					partialContent: true
+				};
+				this.state = AgentState.ERROR;
+				return;
+			}
+			this.state = AgentState.LLM_RETRY_WAIT;
+		}
+	}
+	async *doLlmRetryWait() {
+		await this.hooks.onLlmRetry?.(this.attempt + 1, MAX_LLM_RETRIES, /* @__PURE__ */ new Error("LLM call failed"));
+		yield {
+			type: "retrying",
+			attempt: this.attempt + 1,
+			maxRetries: MAX_LLM_RETRIES
+		};
+		await sleep(RETRY_BASE_DELAY * Math.pow(2, this.attempt));
+		this.attempt++;
+		this.state = AgentState.LLM_STREAMING;
+	}
+	async *doPostLlm() {
+		if (this.chunkUsage) {
+			const cu = this.chunkUsage;
+			this.totalUsage = this.totalUsage ? {
+				prompt_tokens: (this.totalUsage.prompt_tokens || 0) + (cu.prompt_tokens || 0),
+				completion_tokens: (this.totalUsage.completion_tokens || 0) + (cu.completion_tokens || 0),
+				total_tokens: (this.totalUsage.total_tokens || 0) + (cu.total_tokens || 0)
+			} : { ...cu };
+		}
+		await this.hooks.afterLlmCall?.(this.totalUsage);
+		this.resolvedToolCalls = Array.from(this.collectedToolCalls.values());
+		if (this.resolvedToolCalls.length === 0) {
+			await this.storage.addMessage(this.effectiveSessionId, {
+				session_id: this.effectiveSessionId,
+				role: "assistant",
+				content: this.fullContent,
+				reasoning_content: this.fullReasoning || void 0,
+				usage: this.totalUsage
+			});
+			if (this.totalUsage) await this.storage.updateTokenCount(this.effectiveSessionId, this.totalUsage.total_tokens);
+			yield* this.tryForkIfWindowLow();
+			yield {
+				type: "done",
+				messageId: crypto.randomUUID(),
+				usage: this.totalUsage,
+				contextWindow: this.contextWindow
+			};
+			this.state = AgentState.DONE;
+			return;
+		}
+		this.messages.push({
+			role: "assistant",
+			content: this.fullContent || "",
+			tool_calls: this.resolvedToolCalls,
+			reasoning_content: this.fullReasoning || void 0
+		});
+		yield* this.tryForkIfWindowLow();
+		this.toolResultMsgs = [];
+		this.toolIndex = 0;
+		this.state = AgentState.PRE_TOOL;
+	}
+	async *doPreTool() {
+		if (this.signal?.aborted) {
+			this.state = AgentState.DONE;
+			return;
+		}
+		if (this.toolIndex >= this.resolvedToolCalls.length) {
+			this.state = AgentState.PERSIST_TURN;
+			return;
+		}
+		this.currentToolCall = this.resolvedToolCalls[this.toolIndex];
+		this.currentArgs = {};
+		try {
+			this.currentArgs = JSON.parse(this.currentToolCall.function.arguments);
+		} catch {}
+		const modifiedArgs = await this.hooks.beforeToolExecution?.(this.currentToolCall.function.name, this.currentArgs);
+		if (modifiedArgs) this.currentArgs = modifiedArgs;
+		yield {
+			type: "tool_call",
+			name: this.currentToolCall.function.name,
+			args: this.currentArgs
+		};
+		this.state = AgentState.TOOL_EXECUTING;
+	}
+	async *doToolExecuting() {
+		const tc = this.currentToolCall;
+		const name = tc.function.name;
+		const updateQueue = [];
+		let toolDone = false;
+		let toolResult;
+		let toolError;
+		let wakeUp = null;
+		this.toolContext.onUpdate = (chunk) => {
+			if (!toolDone) {
+				updateQueue.push(chunk);
+				wakeUp?.();
+			}
+		};
+		this.registry.execute(name, this.currentArgs, this.toolContext).then((r) => {
+			toolResult = r;
+		}).catch((e) => {
+			toolError = e;
+		}).finally(() => {
+			this.toolContext.onUpdate = void 0;
+			toolDone = true;
+			wakeUp?.();
+		});
+		while (!toolDone) if (updateQueue.length > 0) while (updateQueue.length > 0) yield {
+			type: "tool_execution_update",
+			name,
+			text: updateQueue.shift()
+		};
+		else await new Promise((resolve) => {
+			wakeUp = resolve;
+		});
+		if (toolError) {
+			if (toolError instanceof PendingConfirmation) {
+				this.pendingConfirmation = toolError;
+				this.state = AgentState.AWAIT_CONFIRM;
+				return;
+			}
+			const errMsg = toolError.message;
+			yield {
+				type: "tool_result",
+				name,
+				success: false,
+				output: errMsg
+			};
+			this.toolResultMsgs.push({
+				role: "tool",
+				content: `工具执行异常: ${errMsg}`,
+				tool_call_id: tc.id,
+				name
+			});
+			this.messages.push({
+				role: "tool",
+				content: `工具执行异常: ${errMsg}`,
+				tool_call_id: tc.id,
+				name
+			});
+			this.state = AgentState.POST_TOOL;
+			return;
+		}
+		const result = toolResult;
+		yield {
+			type: "tool_result",
+			name,
+			success: result.success,
+			output: result.output
+		};
+		const content = result.output || result.error || "";
+		this.toolResultMsgs.push({
+			role: "tool",
+			content,
+			tool_call_id: tc.id,
+			name
+		});
+		this.messages.push({
+			role: "tool",
+			content,
+			tool_call_id: tc.id,
+			name
+		});
+		await this.hooks.afterToolExecution?.(name, {
+			success: result.success,
+			output: result.output
+		});
+		this.state = AgentState.POST_TOOL;
+	}
+	async *doAwaitConfirm() {
+		const error = this.pendingConfirmation;
+		const tc = this.currentToolCall;
+		const confirmId = crypto.randomUUID();
+		await this.hooks.onConfirmRequired?.(error, confirmId);
+		yield {
+			type: "confirm_required",
+			confirmId,
+			confirmation: error
+		};
+		let abortCleanup;
+		const approved = await Promise.race([this.onConfirm(error, confirmId), new Promise((resolve) => {
+			if (this.signal) {
+				const onAbort = () => resolve(false);
+				this.signal.addEventListener("abort", onAbort, { once: true });
+				abortCleanup = () => this.signal?.removeEventListener("abort", onAbort);
+			}
+		})]);
+		abortCleanup?.();
+		if (approved) try {
+			const retryResult = await this.registry.execute(error.toolName, {
+				...error.args,
+				__confirmed: true
+			}, this.toolContext);
+			yield {
+				type: "tool_result",
+				name: error.toolName,
+				success: retryResult.success,
+				output: retryResult.output
+			};
+			const content = retryResult.output || retryResult.error || "";
+			this.toolResultMsgs.push({
+				role: "tool",
+				content,
+				tool_call_id: tc.id,
+				name: error.toolName
+			});
+			this.messages.push({
+				role: "tool",
+				content,
+				tool_call_id: tc.id,
+				name: error.toolName
+			});
+		} catch (retryError) {
+			const errMsg = retryError.message;
+			yield {
+				type: "tool_result",
+				name: error.toolName,
+				success: false,
+				output: errMsg
+			};
+			this.toolResultMsgs.push({
+				role: "tool",
+				content: `执行失败: ${errMsg}`,
+				tool_call_id: tc.id,
+				name: error.toolName
+			});
+			this.messages.push({
+				role: "tool",
+				content: `执行失败: ${errMsg}`,
+				tool_call_id: tc.id,
+				name: error.toolName
+			});
+		}
+		else {
+			const cancelMsg = "用户取消了此操作";
+			yield {
+				type: "tool_result",
+				name: error.toolName,
+				success: false,
+				output: cancelMsg
+			};
+			this.toolResultMsgs.push({
+				role: "tool",
+				content: cancelMsg,
+				tool_call_id: tc.id,
+				name: error.toolName
+			});
+			this.messages.push({
+				role: "tool",
+				content: cancelMsg,
+				tool_call_id: tc.id,
+				name: error.toolName
+			});
+		}
+		this.pendingConfirmation = void 0;
+		this.state = AgentState.POST_TOOL;
+	}
+	async *doPostTool() {
+		this.toolIndex++;
+		this.state = AgentState.PRE_TOOL;
+	}
+	async *doPersistTurn() {
+		await this.hooks.afterTurn?.(this.iteration);
+		await this.storage.addMessage(this.effectiveSessionId, {
+			session_id: this.effectiveSessionId,
+			role: "assistant",
+			content: this.fullContent || "",
+			reasoning_content: this.fullReasoning || void 0,
+			tool_calls: this.resolvedToolCalls,
+			usage: this.totalUsage
+		});
+		if (this.totalUsage) await this.storage.updateTokenCount(this.effectiveSessionId, this.totalUsage.total_tokens);
+		for (const t of this.toolResultMsgs) await this.storage.addMessage(this.effectiveSessionId, {
+			session_id: this.effectiveSessionId,
+			role: "tool",
+			content: t.content,
+			tool_call_id: t.tool_call_id,
+			name: t.name
+		});
+		if (this.signal?.aborted) {
+			this.state = AgentState.DONE;
+			return;
+		}
+		this.iteration++;
+		this.state = AgentState.PRE_LLM;
+	}
+	async *tryForkIfWindowLow() {
+		const tokensUsed = this.totalUsage?.total_tokens || 0;
+		if (tokensUsed <= 0) return;
+		if (this.compressionMode === "custom" ? tokensUsed > this.compressionThreshold : this.contextWindow - tokensUsed < CONTINUE_THRESHOLD) {
+			const newId = await this.createContinuation(this.effectiveSessionId, this.userMsg, this.messages, typeof this.buildResult.messages[0]?.content === "string" ? this.buildResult.messages[0]?.content : void 0);
+			if (newId) yield {
+				type: "forked",
+				newSessionId: newId
+			};
+		}
+	}
+	extractPriorCompression(messages) {
+		const systemMsg = messages.find((m) => m.role === "system");
+		if (!systemMsg) return void 0;
+		const content = extractTextContent(systemMsg.content);
+		const idx = content.indexOf("[此对话延续自");
+		if (idx === -1) return void 0;
+		return content.slice(idx);
+	}
+	async createContinuation(sessionId, userMsg, allMessages, systemPrompt) {
+		try {
+			const parentSession = await this.storage.getSession(sessionId);
+			if (!parentSession) return null;
+			const rawContent = buildSummaryContent(allMessages, systemPrompt);
+			let compression = "";
+			const priorCompression = this.extractPriorCompression(allMessages);
+			try {
+				let prompt = `The following is a conversation history that needs compression due to context length. Extract the **key information needed to continue the current task**, output in Chinese using the format below:
+
+## 目标
+- Core task the user wants to accomplish (1 sentence)
+
+## 进度
+- 已完成: <completed items>
+- 进行中: <in progress>
+- 阻塞: <blocked items, omit if none>
+
+## 关键决策
+- <key technical decisions, tool choices, approaches taken>
+
+## 用户偏好与约束
+- <user habits, preferences, explicit constraints>
+
+## 关键上下文
+- <file paths, key parameters, environment info>
+
+## 下一步
+- <next steps, ordered by priority>
+
+Conversation:
+${rawContent}`;
+				if (priorCompression) prompt += `\n\nBelow is an existing compression summary. Update it by preserving ALL existing information and adding new developments:\n${priorCompression}`;
+				compression = (await this.provider.chat({
+					messages: [{
+						role: "user",
+						content: prompt
+					}],
+					max_tokens: 2e3,
+					temperature: .3
+				})).content || "";
+			} catch {
+				compression = rawContent.slice(0, 2e3);
+			}
+			if (!compression) return null;
+			const newTitle = `[延续] ${parentSession.title}`;
+			const newSession = await this.storage.createSession(newTitle, parentSession.memory_snapshot, parentSession.workspace);
+			await this.storage.addMessage(newSession.id, {
+				session_id: newSession.id,
+				role: "system",
+				content: `[此对话延续自会话「${parentSession.title || sessionId}」，以下为上下文压缩]\n\n${compression}`
+			});
+			await this.storage.addMessage(newSession.id, {
+				session_id: newSession.id,
+				role: "user",
+				content: userMsg.content
+			});
+			const recentMessages = await this.storage.getMessagesSinceSeq(sessionId, userMsg.seq);
+			for (const msg of recentMessages) await this.storage.addMessage(newSession.id, {
+				session_id: newSession.id,
+				role: msg.role,
+				content: msg.content,
+				reasoning_content: msg.reasoning_content,
+				tool_calls: msg.tool_calls,
+				tool_call_id: msg.tool_call_id,
+				name: msg.name,
+				usage: msg.usage
+			});
+			return newSession.id;
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/agent/context-builder.js
+var DEFAULT_CONTEXT_WINDOW$1 = 1048576;
+var MEMORY_PATH = getDataPath("memory.md");
+function readMemoryFile() {
+	try {
+		if (existsSync(MEMORY_PATH)) return readFileSync(MEMORY_PATH, "utf-8").replace(/\r/g, "").trim();
+	} catch {}
+	return "";
+}
+function formatMemorySection(content) {
+	if (!content) return "";
+	return `\n\n## 用户信息\n\n以下是关于你和用户的已知信息，请据此调整你的行为：\n\n${content}`;
+}
+/**
+* ContextBuilder — 上下文构建器
+*
+* 负责拼装发给 LLM 的 messages 数组：
+* 1. 系统提示词（用户自定义 + 环境信息 + memory 快照）
+* 2. 会话历史消息
+* 3. 当前用户输入
+*
+* 工具描述通过 API 的 tools 参数传递，不写入 system prompt 文本。
+* memory 在会话首次构建时从 memory.md 读取并存入 session.memory_snapshot，
+* 后续构建直接使用快照，保证 system 消息稳定。
+*/
+var ContextBuilder = class {
+	async build(sessionId, userMessage, images, storage, contextWindow, systemPrompt) {
+		return {
+			messages: await this.buildMessages(sessionId, userMessage, images, storage, systemPrompt),
+			contextWindow: contextWindow || DEFAULT_CONTEXT_WINDOW$1
+		};
+	}
+	async resolveMemory(sessionId, storage) {
+		const session = await storage.getSession(sessionId);
+		if (session?.memory_snapshot) return session.memory_snapshot;
+		const content = readMemoryFile();
+		if (session) await storage.setMemorySnapshot(sessionId, content);
+		return content;
+	}
+	parseStoredContent(content) {
+		if (content.startsWith("[")) try {
+			return JSON.parse(content);
+		} catch {}
+		return content;
+	}
+	buildUserContent(text, images) {
+		if (images.length === 0) return text;
+		return [{
+			type: "text",
+			text
+		}, ...images];
+	}
+	async buildMessages(sessionId, userMessage, images, storage, systemPrompt) {
+		const messages = [];
+		let systemContent = systemPrompt || DEFAULT_SYSTEM_PROMPT;
+		systemContent += SYSTEM_CONTEXT;
+		const memoryContent = await this.resolveMemory(sessionId, storage);
+		systemContent += formatMemorySection(memoryContent);
+		const history = await storage.getMessages(sessionId);
+		for (const msg of history) if (msg.role === "system") systemContent += "\n\n" + (typeof msg.content === "string" ? msg.content : "");
+		messages.push({
+			role: "system",
+			content: systemContent
+		});
+		for (const msg of history) {
+			if (msg.role === "system") continue;
+			const m = {
+				role: msg.role,
+				content: this.parseStoredContent(msg.content)
+			};
+			if (msg.tool_calls) m.tool_calls = msg.tool_calls;
+			if (msg.tool_call_id) m.tool_call_id = msg.tool_call_id;
+			if (msg.name) m.name = msg.name;
+			messages.push(m);
+		}
+		messages.push({
+			role: "user",
+			content: this.buildUserContent(userMessage, images)
+		});
+		return messages;
+	}
+};
+//#endregion
+//#region ../core/dist/agent/summarizer.js
+function parseStoredContent(content) {
+	if (content.startsWith("[")) try {
+		return JSON.parse(content);
+	} catch {}
+	return content;
+}
+var _registry = new ToolRegistry();
+for (const t of CORE_TOOLS) {
+	if (t.name === "edit" || t.name === "read_memory") continue;
+	_registry.register(t);
+}
+var _toolContext = new ToolContext(process.cwd());
+var _toolDefs = _registry.getDefinitions();
+function buildSystemMessage() {
+	let content = readConfig().systemPrompt || DEFAULT_SYSTEM_PROMPT;
+	content += SYSTEM_CONTEXT;
+	return {
+		role: "system",
+		content
+	};
+}
+var MAX_TOOL_ITERATIONS = 10;
+async function completeWithToolLoop(provider, messages, maxTokens, temperature) {
+	const tools = _toolDefs;
+	for (let i = 0; i < MAX_TOOL_ITERATIONS; i++) {
+		const response = await provider.chat({
+			messages,
+			tools: tools.length > 0 ? tools : void 0,
+			max_tokens: maxTokens,
+			temperature
+		});
+		if (!response.tool_calls || response.tool_calls.length === 0) return {
+			content: response.content || "",
+			usage: response.usage
+		};
+		messages.push({
+			role: "assistant",
+			content: response.content || "",
+			tool_calls: response.tool_calls
+		});
+		for (const tc of response.tool_calls) {
+			let args = {};
+			try {
+				args = JSON.parse(tc.function.arguments);
+			} catch {}
+			try {
+				const result = await _registry.execute(tc.function.name, args, _toolContext);
+				messages.push({
+					role: "tool",
+					content: result.output || result.error || "",
+					tool_call_id: tc.id,
+					name: tc.function.name
+				});
+			} catch (error) {
+				if (error instanceof PendingConfirmation) messages.push({
+					role: "tool",
+					content: `后台任务无法执行需确认的操作: ${error.reason}`,
+					tool_call_id: tc.id,
+					name: error.toolName
+				});
+				else {
+					const errMsg = error.message;
+					messages.push({
+						role: "tool",
+						content: `工具执行异常: ${errMsg}`,
+						tool_call_id: tc.id,
+						name: tc.function.name
+					});
+				}
+			}
+		}
+	}
+	return { content: "" };
+}
+async function generateSummary(provider, storage, sessionId, existingSummary) {
+	const records = await storage.getMessages(sessionId);
+	if (records.length === 0) return "";
+	const messages = [buildSystemMessage()];
+	for (const r of records) {
+		if (r.role === "system") continue;
+		const m = {
+			role: r.role,
+			content: parseStoredContent(r.content)
+		};
+		if (r.tool_calls) m.tool_calls = r.tool_calls;
+		if (r.tool_call_id) m.tool_call_id = r.tool_call_id;
+		if (r.name) m.name = r.name;
+		messages.push(m);
+	}
+	let userInstruction = `Please summarize the conversation above. Output in Chinese using the structured format below:
+
+## 目标
+- The user's current main goal
+
+## 进度
+- 已完成: <completed items>
+- 进行中: <in progress>
+- 阻塞: <blocked items, omit if none>
+
+## 关键决策
+- <key decisions or choices made>
+
+## 用户偏好
+- <user habits, preferences, constraints>
+
+## 情感上下文
+- <user mood, attitude, and other context helpful for continuing the conversation>`;
+	if (existingSummary) userInstruction += `\n\nBelow is the existing summary. Update it by preserving all existing information and appending new developments:\n${existingSummary}`;
+	messages.push({
+		role: "user",
+		content: userInstruction
+	});
+	const { content, usage } = await completeWithToolLoop(provider, messages, 2e3, .3);
+	if (usage) {
+		const hit = usage.prompt_cache_hit_tokens ?? 0;
+		const miss = usage.prompt_cache_miss_tokens ?? 0;
+		console.log(`[summarize] session=${sessionId} messages=${records.length} hit=${hit} miss=${miss} total_tokens=${usage.total_tokens}`);
+	}
+	return content || "";
+}
+//#endregion
+//#region ../core/dist/agent/diary.js
+var DIARY_DIR = join(getDataPath("diary"));
+var MAX_RECENT_DAYS = 7;
+function getTodayDate() {
+	const now = /* @__PURE__ */ new Date();
+	let date = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+	if (now.getHours() < 8) date = /* @__PURE__ */ new Date(date.getTime() - 864e5);
+	const y = date.getFullYear();
+	const m = String(date.getMonth() + 1).padStart(2, "0");
+	const d = String(date.getDate()).padStart(2, "0");
+	return {
+		date,
+		y,
+		m,
+		d
+	};
+}
+function formatDatePath(y, m, d) {
+	return `data/diary/${y}-${m}-${d}.md`;
+}
+function getTodayFile() {
+	const { y, m, d } = getTodayDate();
+	return formatDatePath(y, m, d);
+}
+function readRecentDiaries(targetDate) {
+	const parts = [];
+	const cursor = new Date(targetDate);
+	for (let i = 1; i <= MAX_RECENT_DAYS; i++) {
+		cursor.setDate(cursor.getDate() - 1);
+		const y = cursor.getFullYear();
+		const m = String(cursor.getMonth() + 1).padStart(2, "0");
+		const d = String(cursor.getDate()).padStart(2, "0");
+		const filePath = join(DIARY_DIR, `${y}-${m}-${d}.md`);
+		if (existsSync(filePath)) {
+			const content = readFileSync(filePath, "utf-8").trim();
+			parts.push(`### ${y}-${m}-${d}\n${content.slice(0, 2e3)}`);
+		}
+	}
+	return parts.join("\n\n");
+}
+async function generateDiary(provider, storage) {
+	const sessions = await storage.getTodayUpdatedSessions();
+	if (sessions.length === 0) return;
+	const summaries = [];
+	for (const s of sessions) if (s.summary) summaries.push(`### ${s.title}\n${s.summary}`);
+	if (summaries.length === 0) return;
+	const { date } = getTodayDate();
+	const filePath = getTodayFile();
+	const recentDiaries = readRecentDiaries(date);
+	let userContent = `以下是今天各会话的摘要，请据此撰写一篇日记，记录当天和我一起完成了什么、有哪些重要交流。\n\n${summaries.join("\n\n")}`;
+	if (recentDiaries) userContent += `\n\n以下是前几天的日记内容，请参考以保持日记的连贯性和叙事感：\n\n${recentDiaries}`;
+	userContent += `\n\n请使用 write_file 工具将日记写入以下文件：${filePath}`;
+	await completeWithToolLoop(provider, [buildSystemMessage(), {
+		role: "user",
+		content: userContent
+	}], 2e3, .5);
+}
+//#endregion
+//#region ../core/dist/agent/background.js
+async function runSummarizeJob(force, idleMs) {
+	const config = readConfig();
+	if (!config.storageEnabled) throw new Error("对话存储未开启");
+	const providerConfig = getFirstProvider();
+	if (!providerConfig?.apiKey) throw new Error("未配置 AI 供应商");
+	const model = getActiveModel() || getDefaultModels(providerConfig.type)[0];
+	if (!model) throw new Error("未选择模型");
+	const provider = createProvider({
+		...providerConfig,
+		activeModel: model.id,
+		contextWindow: model.contextWindow
+	});
+	const storage = createStorage({ enabled: true });
+	let effectiveIdleMs;
+	if (force) effectiveIdleMs = -1;
+	else if (idleMs !== void 0) effectiveIdleMs = idleMs;
+	else effectiveIdleMs = (config.summaryIdleHours || 8) * 60 * 60 * 1e3;
+	const staleSessions = await storage.getStaleSessions(effectiveIdleMs);
+	let summarized = 0;
+	for (const session of staleSessions) try {
+		const summary = await generateSummary(provider, storage, session.id, session.summary || void 0);
+		if (summary) {
+			await storage.updateSummary(session.id, summary);
+			summarized++;
+		}
+	} catch (e) {
+		console.error(`[summarize] session=${session.id} failed:`, e.message);
+	}
+	let diary = false;
+	if (summarized > 0) try {
+		await generateDiary(provider, storage);
+		diary = true;
+	} catch (e) {
+		console.error("[diary] failed:", e.message);
+	}
+	return {
+		summarized,
+		diary
+	};
+}
+//#endregion
+//#region ../core/dist/agent/logger.js
+var AgentLogger = class {
+	sessionId;
+	turn = 0;
+	llmStart = 0;
+	turnLog = null;
+	constructor(sessionId) {
+		this.sessionId = sessionId;
+	}
+	async beforeLlmCall(messages) {
+		this.llmStart = Date.now();
+		this.turn++;
+		this.turnLog = {
+			turn: this.turn,
+			toolCalls: 0,
+			inputTokens: 0,
+			outputTokens: 0,
+			errors: 0
+		};
+		const msgCount = messages.length;
+		const lastRole = messages.length > 0 ? messages[messages.length - 1].role : "none";
+		console.log(`[agent ${this.sessionId.slice(0, 8)}] turn ${this.turn} LLM call (${msgCount} msgs, last=${lastRole})`);
+		return messages;
+	}
+	async afterLlmCall(usage) {
+		const latency = Date.now() - this.llmStart;
+		if (this.turnLog) this.turnLog.llmLatencyMs = latency;
+		if (usage) {
+			if (this.turnLog) {
+				this.turnLog.inputTokens = usage.prompt_tokens;
+				this.turnLog.outputTokens = usage.completion_tokens;
+			}
+			const cache = usage.prompt_cache_hit_tokens != null ? ` cache=${usage.prompt_cache_hit_tokens}+${usage.prompt_cache_miss_tokens}` : "";
+			console.log(`[agent ${this.sessionId.slice(0, 8)}] turn ${this.turn} done — latency=${latency}ms tokens=${usage.total_tokens} (${usage.prompt_tokens}+${usage.completion_tokens})${cache}`);
+		} else console.log(`[agent ${this.sessionId.slice(0, 8)}] turn ${this.turn} done — latency=${latency}ms`);
+	}
+	async onLlmRetry(attempt, maxRetries, error) {
+		console.log(`[agent ${this.sessionId.slice(0, 8)}] turn ${this.turn} retry ${attempt}/${maxRetries}: ${error.message}`);
+		if (this.turnLog) this.turnLog.errors++;
+	}
+	async beforeToolExecution(name, args) {
+		const preview = JSON.stringify(args).slice(0, 120);
+		console.log(`[agent ${this.sessionId.slice(0, 8)}] turn ${this.turn} tool: ${name}(${preview}${JSON.stringify(args).length > 120 ? "..." : ""})`);
+		return args;
+	}
+	async afterToolExecution(name, result) {
+		const outLen = result.output.length;
+		if (this.turnLog) this.turnLog.toolCalls++;
+		const status = result.success ? "OK" : "FAIL";
+		console.log(`[agent ${this.sessionId.slice(0, 8)}] turn ${this.turn} tool ${name} → ${status} (${outLen} chars)`);
+	}
+	async onConfirmRequired(confirmation, confirmId) {
+		console.log(`[agent ${this.sessionId.slice(0, 8)}] turn ${this.turn} confirm: ${confirmation.toolName} — ${confirmation.reason.slice(0, 80)}`);
+	}
+	async afterTurn(_iteration) {
+		if (this.turnLog) {
+			const t = this.turnLog;
+			console.log(`[agent ${this.sessionId.slice(0, 8)}] turn ${this.turn} summary — tools=${t.toolCalls} tokens=${t.inputTokens}+${t.outputTokens} latency=${t.llmLatencyMs}ms errors=${t.errors}`);
+		}
+	}
+};
+//#endregion
+//#region ../core/dist/agent/summarize-worker.js
+function getToday() {
+	const d = /* @__PURE__ */ new Date();
+	return `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
+}
+function createSummarizeWorker(notify) {
+	let worker = null;
+	let lastScheduledDate = "";
+	async function tick() {
+		const config = readConfig();
+		if (!config.autoSummarize || !config.storageEnabled) return;
+		let result;
+		if (config.summaryMode === "scheduled") {
+			const now = /* @__PURE__ */ new Date();
+			const today = getToday();
+			if (now.getHours() >= (config.summaryScheduleHour || 2) && today !== lastScheduledDate) {
+				lastScheduledDate = today;
+				result = await runSummarizeJob(false, null);
+			}
+		} else result = await runSummarizeJob();
+		if (result) {
+			const { summarized, diary } = result;
+			if (summarized > 0 || diary) {
+				const parts = [];
+				if (summarized > 0) parts.push(`已为 ${summarized} 个对话生成摘要`);
+				if (diary) parts.push("已生成日记条目");
+				await notify({
+					title: "Qualia 任务完成",
+					body: parts.join("\n"),
+					type: "task_complete"
+				});
+			}
+		}
+	}
+	return {
+		start() {
+			const config = readConfig();
+			if (!config.autoSummarize || !config.storageEnabled) return;
+			const intervalMin = config.summaryIntervalMin || 30;
+			worker = new BackgroundWorker();
+			worker.schedule("summarize", intervalMin * 60 * 1e3, tick);
+			worker.start();
+			tick();
+		},
+		stop() {
+			if (worker) {
+				worker.stop();
+				worker = null;
+			}
+		}
+	};
+}
+//#endregion
+//#region ../core/dist/config/store.js
+var DEFAULT_CONTEXT_WINDOW = 1048576;
+function ensureDataDir() {
+	const dir = getDataDir();
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+var defaultConfig = {
+	providers: [],
+	activeModel: "",
+	storageEnabled: false,
+	systemPrompt: DEFAULT_SYSTEM_PROMPT,
+	customBrandIcon: false,
+	autoSummarize: true,
+	summaryMode: "idle",
+	summaryIdleHours: 8,
+	summaryScheduleHour: 2,
+	summaryIntervalMin: 30,
+	compressionMode: "auto",
+	compressionThreshold: 256e3,
+	searchEnabled: false,
+	searchProvider: "searxng",
+	searxngURL: "http://localhost:8080",
+	tavilyApiKey: "",
+	emailNotifications: false,
+	emailSmtpHost: "",
+	emailSmtpPort: 465,
+	emailSmtpSecure: true,
+	emailSmtpUser: "",
+	emailSmtpPass: "",
+	emailFrom: "",
+	emailTo: "",
+	telegramEnabled: false,
+	telegramBotToken: "",
+	telegramAllowedUsers: ""
+};
+function normalizeProvider(p) {
+	return {
+		type: p.type || "openai",
+		name: p.name || "",
+		apiKey: p.apiKey || "",
+		baseURL: p.baseURL || "",
+		reasoningEffort: p.reasoningEffort,
+		timeout: p.timeout,
+		maxRetries: p.maxRetries,
+		ollamaURL: p.ollamaURL || "http://localhost:11434"
+	};
+}
+function readConfig() {
+	const path = getConfigPath();
+	if (!existsSync(path)) return structuredClone(defaultConfig);
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		return {
+			providers: Array.isArray(parsed.providers) ? parsed.providers.map((p) => normalizeProvider(p)) : [],
+			activeModel: parsed.activeModel || "",
+			storageEnabled: parsed.storageEnabled === true,
+			systemPrompt: parsed.systemPrompt || DEFAULT_SYSTEM_PROMPT,
+			customBrandIcon: parsed.customBrandIcon === true,
+			autoSummarize: parsed.autoSummarize !== false,
+			summaryMode: parsed.summaryMode === "scheduled" ? "scheduled" : "idle",
+			summaryIdleHours: typeof parsed.summaryIdleHours === "number" ? parsed.summaryIdleHours : 8,
+			summaryScheduleHour: typeof parsed.summaryScheduleHour === "number" ? parsed.summaryScheduleHour : 2,
+			summaryIntervalMin: typeof parsed.summaryIntervalMin === "number" ? parsed.summaryIntervalMin : 30,
+			compressionMode: parsed.compressionMode === "custom" ? "custom" : "auto",
+			compressionThreshold: typeof parsed.compressionThreshold === "number" ? parsed.compressionThreshold : 256e3,
+			searchEnabled: parsed.searchEnabled === true,
+			searchProvider: parsed.searchProvider === "searxng" || parsed.searchProvider === "tavily" ? parsed.searchProvider : "searxng",
+			searxngURL: typeof parsed.searxngURL === "string" ? parsed.searxngURL : "http://localhost:8080",
+			tavilyApiKey: typeof parsed.tavilyApiKey === "string" ? parsed.tavilyApiKey : "",
+			emailNotifications: parsed.emailNotifications === true,
+			emailSmtpHost: typeof parsed.emailSmtpHost === "string" ? parsed.emailSmtpHost : "",
+			emailSmtpPort: typeof parsed.emailSmtpPort === "number" ? parsed.emailSmtpPort : 465,
+			emailSmtpSecure: parsed.emailSmtpSecure !== false,
+			emailSmtpUser: typeof parsed.emailSmtpUser === "string" ? parsed.emailSmtpUser : "",
+			emailSmtpPass: typeof parsed.emailSmtpPass === "string" ? parsed.emailSmtpPass : "",
+			emailFrom: typeof parsed.emailFrom === "string" ? parsed.emailFrom : "",
+			emailTo: typeof parsed.emailTo === "string" ? parsed.emailTo : "",
+			telegramEnabled: parsed.telegramEnabled === true,
+			telegramBotToken: typeof parsed.telegramBotToken === "string" ? parsed.telegramBotToken : "",
+			telegramAllowedUsers: typeof parsed.telegramAllowedUsers === "string" ? parsed.telegramAllowedUsers : ""
+		};
+	} catch {
+		return structuredClone(defaultConfig);
+	}
+}
+function writeConfig(config) {
+	const path = getConfigPath();
+	ensureDataDir();
+	const tmpPath = path + ".tmp";
+	writeFileSync(tmpPath, JSON.stringify(config, null, "	"), "utf-8");
+	renameSync(tmpPath, path);
+}
+function addProvider(provider) {
+	const config = readConfig();
+	const existing = config.providers.findIndex((p) => p.name === provider.name);
+	if (existing !== -1) config.providers[existing] = provider;
+	else config.providers.push(provider);
+	if (!config.activeModel) config.activeModel = getDefaultModels(provider.type)[0]?.id || "";
+	writeConfig(config);
+	return config;
+}
+function removeProvider(name) {
+	const config = readConfig();
+	config.providers = config.providers.filter((p) => p.name !== name);
+	if (!getProviderForModel(config.activeModel)) {
+		const first = config.providers[0];
+		config.activeModel = first ? getDefaultModels(first.type)[0]?.id || "" : "";
+	}
+	writeConfig(config);
+	return config;
+}
+function setActiveModel(modelId) {
+	const config = readConfig();
+	config.activeModel = modelId;
+	for (const provider of config.providers) {
+		const models = getDefaultModels(provider.type);
+		if (models.length > 0) {
+			const model = models.find((m) => m.id === modelId);
+			if (model && !model.supportsReasoning) provider.reasoningEffort = void 0;
+		} else if (provider.type === "ollama") provider.reasoningEffort = void 0;
+	}
+	writeConfig(config);
+	return config;
+}
+function setReasoningEffort(value) {
+	const config = readConfig();
+	const provider = config.providers.find((p) => {
+		const models = getDefaultModels(p.type);
+		if (models.length > 0) return models.some((m) => m.id === config.activeModel);
+		return p.type === "ollama" && !!config.activeModel;
+	});
+	if (provider) {
+		provider.reasoningEffort = value || void 0;
+		writeConfig(config);
+	}
+	return config;
+}
+function getProviderForModel(modelId) {
+	const config = readConfig();
+	for (const provider of config.providers) if (getDefaultModels(provider.type).some((m) => m.id === modelId)) return provider;
+	const ollama = config.providers.find((p) => p.type === "ollama");
+	if (ollama) return ollama;
+}
+function getAllAvailableModels() {
+	const config = readConfig();
+	const result = [];
+	for (const provider of config.providers) for (const model of getDefaultModels(provider.type)) result.push({
+		model,
+		providerName: provider.name
+	});
+	return result;
+}
+function getFirstProvider() {
+	return readConfig().providers.find((p) => p.apiKey);
+}
+function getActiveModel() {
+	const config = readConfig();
+	if (!config.activeModel) return void 0;
+	for (const provider of config.providers) {
+		const model = getDefaultModels(provider.type).find((m) => m.id === config.activeModel);
+		if (model) return model;
+	}
+	if (config.providers.some((p) => p.type === "ollama")) return {
+		id: config.activeModel,
+		name: config.activeModel,
+		contextWindow: 128e3,
+		supportsReasoning: false,
+		reasoningEffortValues: [],
+		supportsVision: false
+	};
+}
+function getContextWindow() {
+	return getActiveModel()?.contextWindow || DEFAULT_CONTEXT_WINDOW;
+}
+
+export { AgentLoop as A, CORE_TOOLS as C, SCHEDULING_TOOLS as S, ToolRegistry as T, getDataPath as a, getProviderForModel as b, createStorage as c, getActiveModel as d, createProvider as e, getContextWindow as f, getDataDir as g, createSearchHistoryTool as h, ContextBuilder as i, AgentLogger as j, setReasoningEffort as k, setActiveModel as l, removeProvider as m, addProvider as n, getAllAvailableModels as o, runSummarizeJob as p, getAllTasks as q, readConfig as r, sessionLock as s, deleteTask as t, resumeTask as u, pauseTask as v, writeConfig as w, startScheduler as x, createSummarizeWorker as y, setTaskNotificationHandler as z };
+//# sourceMappingURL=config-d3FC8naq.js.map