@n1creator/openacp-cli 2026.712.12 → 2026.713.1

package/dist/index.js

@@ -291,12 +291,12 @@ function createSessionLogger(sessionId, parentLogger) {
 async function closeSessionLogger(logger) {
   const dest = logger.__sessionDest;
   if (!dest) return;
-  await new Promise((resolve7) => {
+  await new Promise((resolve8) => {
     let settled = false;
     const done = () => {
       if (!settled) {
         settled = true;
-        resolve7();
+        resolve8();
       }
     };
     const timeout = setTimeout(done, 3e3);
@@ -321,11 +321,11 @@ async function shutdownLogger() {
   logDir = void 0;
   initialized = false;
   if (transport) {
-    await new Promise((resolve7) => {
-      const timeout = setTimeout(resolve7, 3e3);
+    await new Promise((resolve8) => {
+      const timeout = setTimeout(resolve8, 3e3);
       transport.on("close", () => {
         clearTimeout(timeout);
-        resolve7();
+        resolve8();
       });
       transport.end();
     });
@@ -458,22 +458,22 @@ __export(config_registry_exports, {
   resolveOptions: () => resolveOptions,
   setFieldValueAsync: () => setFieldValueAsync
 });
-function getFieldDef(path38) {
-  return CONFIG_REGISTRY.find((f) => f.path === path38);
+function getFieldDef(path39) {
+  return CONFIG_REGISTRY.find((f) => f.path === path39);
 }
 function getSafeFields() {
   return CONFIG_REGISTRY.filter((f) => f.scope === "safe");
 }
-function isHotReloadable(path38) {
-  const def = getFieldDef(path38);
+function isHotReloadable(path39) {
+  const def = getFieldDef(path39);
   return def?.hotReload ?? false;
 }
 function resolveOptions(def, config) {
   if (!def.options) return void 0;
   return typeof def.options === "function" ? def.options(config) : def.options;
 }
-function getConfigValue(config, path38) {
-  const parts = path38.split(".");
+function getConfigValue(config, path39) {
+  const parts = path39.split(".");
   let current = config;
   for (const part of parts) {
     if (current && typeof current === "object" && part in current) {
@@ -1682,6 +1682,996 @@ var init_agent_installer = __esm({
   }
 });
 
+// src/core/plugin/plugin-installer.ts
+var plugin_installer_exports = {};
+__export(plugin_installer_exports, {
+  PluginInstallCrashSimulation: () => PluginInstallCrashSimulation,
+  PluginInstallError: () => PluginInstallError,
+  PluginInstallJournalController: () => PluginInstallJournalController,
+  acquirePluginInstallLock: () => acquirePluginInstallLock,
+  importFromDir: () => importFromDir,
+  installNpmPlugin: () => installNpmPlugin,
+  parseNpmPackageSpec: () => parseNpmPackageSpec,
+  pluginMutationLockHeld: () => pluginMutationLockHeld,
+  recoverPluginInstallTransaction: () => recoverPluginInstallTransaction,
+  stageNpmPlugin: () => stageNpmPlugin,
+  validateOpenACPPluginModule: () => validateOpenACPPluginModule,
+  withHeldPluginMutationLock: () => withHeldPluginMutationLock,
+  withPluginMutationLock: () => withPluginMutationLock
+});
+import { execFile } from "child_process";
+import { promisify } from "util";
+import * as fs15 from "fs/promises";
+import fsSync from "fs";
+import * as path14 from "path";
+import { pathToFileURL } from "url";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { AsyncLocalStorage } from "async_hooks";
+async function importFromDir(packageName, dir) {
+  const pkgDir = path14.join(dir, "node_modules", ...packageName.split("/"));
+  const pkgJsonPath = path14.join(pkgDir, "package.json");
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(await fs15.readFile(pkgJsonPath, "utf-8"));
+  } catch (err) {
+    throw new Error(`Cannot read package.json for "${packageName}" at ${pkgJsonPath}: ${err.message}`);
+  }
+  let entry;
+  const exportsMain = pkgJson.exports?.["."];
+  if (typeof exportsMain === "string") {
+    entry = exportsMain;
+  } else if (exportsMain?.import) {
+    entry = exportsMain.import;
+  } else {
+    entry = pkgJson.main ?? "index.js";
+  }
+  const entryPath = path14.join(pkgDir, entry);
+  try {
+    await fs15.access(entryPath);
+  } catch {
+    throw new Error(`Entry point "${entry}" not found for "${packageName}" at ${entryPath}`);
+  }
+  return import(pathToFileURL(entryPath).href);
+}
+function parseNpmPackageSpec(spec) {
+  if (!VALID_NPM_NAME.test(spec)) throw new PluginInstallError("PLUGIN_PACKAGE_SPEC_INVALID", "Plugin package spec is invalid.");
+  if (spec.startsWith("@")) {
+    const slash = spec.indexOf("/");
+    const versionAt2 = spec.indexOf("@", slash + 1);
+    return { packageName: versionAt2 === -1 ? spec : spec.slice(0, versionAt2), spec };
+  }
+  const versionAt = spec.lastIndexOf("@");
+  return { packageName: versionAt > 0 ? spec.slice(0, versionAt) : spec, spec };
+}
+function validateOpenACPPluginModule(module, manifest, packageName) {
+  const plugin = module?.default;
+  if (!plugin || typeof plugin !== "object" || plugin.name !== packageName || manifest.name !== packageName || typeof manifest.version !== "string" || plugin.version !== manifest.version || typeof plugin.setup !== "function" || typeof plugin.install !== "function") {
+    throw new PluginInstallError(
+      "PLUGIN_CONTRACT_INVALID",
+      "Package is not an installable OpenACP plugin: default export, matching name/version, setup(), and explicit install() are required."
+    );
+  }
+  return plugin;
+}
+function assertDirectoryBoundary(target, label) {
+  const stat = fsSync.lstatSync(target);
+  if (stat.isSymbolicLink() || !stat.isDirectory() || fsSync.realpathSync(target) !== path14.resolve(target)) {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `${label} must be a real directory without symbolic-link ancestors.`);
+  }
+}
+function assertInstanceBoundaries(instanceRoot) {
+  assertDirectoryBoundary(instanceRoot, "Plugin instance root");
+  const pluginsDir = path14.join(instanceRoot, "plugins");
+  if (fsSync.existsSync(pluginsDir)) assertDirectoryBoundary(pluginsDir, "Plugin package root");
+}
+function assertContainedPath(instanceRoot, target, label) {
+  const root = path14.resolve(instanceRoot);
+  const resolved = path14.resolve(target);
+  const relative2 = path14.relative(root, resolved);
+  if (relative2.startsWith("..") || path14.isAbsolute(relative2)) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `${label} escapes the trusted instance root.`);
+  let current = root;
+  for (const segment of relative2 ? relative2.split(path14.sep) : []) {
+    current = path14.join(current, segment);
+    if (!fsSync.existsSync(current)) break;
+    const stat = fsSync.lstatSync(current);
+    if (stat.isSymbolicLink()) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `${label} contains a symbolic-link boundary.`);
+    const real = fsSync.realpathSync(current);
+    if (real !== root && !real.startsWith(`${root}${path14.sep}`)) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `${label} resolves outside the trusted instance root.`);
+  }
+}
+function atomicJson(file, value) {
+  const directory = path14.dirname(file);
+  fsSync.mkdirSync(directory, { recursive: true, mode: 448 });
+  const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
+  try {
+    fsSync.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}
+`, { flag: "wx", mode: 384 });
+    fsSync.chmodSync(temporary, 384);
+    const fd = fsSync.openSync(temporary, "r");
+    fsSync.fsyncSync(fd);
+    fsSync.closeSync(fd);
+    fsSync.renameSync(temporary, file);
+    fsSync.chmodSync(file, 384);
+    try {
+      const dir = fsSync.openSync(directory, "r");
+      fsSync.fsyncSync(dir);
+      fsSync.closeSync(dir);
+    } catch {
+    }
+  } finally {
+    try {
+      if (fsSync.existsSync(temporary)) fsSync.unlinkSync(temporary);
+    } catch {
+    }
+  }
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+async function acquirePluginInstallLock(instanceRoot, options = {}) {
+  const lockPath = path14.join(instanceRoot, LOCK_FILE);
+  const reclaimPrefix = `${LOCK_FILE}.reclaim-`;
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const staleMs = options.staleMs ?? 3e4;
+  const transactionId = options.transactionId ?? randomUUID2();
+  fsSync.mkdirSync(instanceRoot, { recursive: true, mode: 448 });
+  const createOwnedLock = () => {
+    const fd = fsSync.openSync(lockPath, "wx", 384);
+    try {
+      fsSync.writeFileSync(fd, JSON.stringify({ version: 1, transactionId, pid: process.pid, createdAt: Date.now() }));
+      fsSync.fsyncSync(fd);
+    } finally {
+      fsSync.closeSync(fd);
+    }
+    fsSync.chmodSync(lockPath, 384);
+    let released = false;
+    return { transactionId, release: () => {
+      if (released) return;
+      released = true;
+      try {
+        const owner = JSON.parse(fsSync.readFileSync(lockPath, "utf8"));
+        if (owner.transactionId === transactionId) fsSync.unlinkSync(lockPath);
+      } catch {
+      }
+    } };
+  };
+  const started = Date.now();
+  while (Date.now() - started <= timeoutMs) {
+    try {
+      const reclaims = fsSync.readdirSync(instanceRoot).filter((name) => name.startsWith(reclaimPrefix));
+      for (const name of reclaims) {
+        const ownerId = name.slice(reclaimPrefix.length);
+        const reclaimPath = path14.join(instanceRoot, name);
+        const stat = fsSync.lstatSync(reclaimPath);
+        if (!TRANSACTION_ID.test(ownerId) || stat.isSymbolicLink() || !stat.isFile() || stat.size > 4096) {
+          throw new PluginInstallError("PLUGIN_INSTALL_BUSY", "Malformed stale-lock reclaim evidence requires operator inspection.");
+        }
+        const owner = JSON.parse(fsSync.readFileSync(reclaimPath, "utf8"));
+        const reclaimable = owner.transactionId === ownerId && Number.isInteger(owner.pid) && Number.isFinite(owner.createdAt) && Date.now() - Number(owner.createdAt) > staleMs && !processAlive(Number(owner.pid));
+        if (!reclaimable) throw new PluginInstallError("PLUGIN_INSTALL_BUSY", "A plugin lock reclaim is active or cannot be proven stale.");
+        if (!fsSync.existsSync(lockPath)) {
+          const lock = createOwnedLock();
+          fsSync.unlinkSync(reclaimPath);
+          return lock;
+        }
+        fsSync.unlinkSync(reclaimPath);
+      }
+      return createOwnedLock();
+    } catch (error) {
+      if (error instanceof PluginInstallError) throw error;
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const owner = JSON.parse(fsSync.readFileSync(lockPath, "utf8"));
+        const oldEnough = TRANSACTION_ID.test(owner.transactionId ?? "") && Number.isFinite(owner.createdAt) && Date.now() - Number(owner.createdAt) > staleMs;
+        const definitelyDead = Number.isInteger(owner.pid) && !processAlive(Number(owner.pid));
+        if (oldEnough && definitelyDead) {
+          const reclaimPath = path14.join(instanceRoot, `${reclaimPrefix}${owner.transactionId}`);
+          try {
+            if (fsSync.existsSync(reclaimPath)) continue;
+            fsSync.renameSync(lockPath, reclaimPath);
+            const renamed = JSON.parse(fsSync.readFileSync(reclaimPath, "utf8"));
+            if (renamed.transactionId !== owner.transactionId || renamed.pid !== owner.pid || renamed.createdAt !== owner.createdAt) {
+              if (!fsSync.existsSync(lockPath)) fsSync.renameSync(reclaimPath, lockPath);
+              continue;
+            }
+          } catch (reclaimError) {
+            if (reclaimError.code !== "ENOENT") throw reclaimError;
+          }
+          continue;
+        }
+      } catch {
+      }
+      await new Promise((resolve8) => setTimeout(resolve8, 20));
+    }
+  }
+  throw new PluginInstallError("PLUGIN_INSTALL_BUSY", "Another plugin package transaction owns the install lock; retry after it finishes.");
+}
+function treeRecords(root, excludeMarker = true) {
+  if (!fsSync.existsSync(root)) return [];
+  const rootStat = fsSync.lstatSync(root);
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) throw new PluginInstallError("PLUGIN_SNAPSHOT_FAILED", "Plugin data snapshot root must be a real directory.");
+  const records = [];
+  const walk = (directory, relative2 = "") => {
+    for (const entry of fsSync.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (excludeMarker && !relative2 && entry.name === ".snapshot-complete.json") continue;
+      const childRelative = path14.join(relative2, entry.name);
+      const child = path14.join(directory, entry.name);
+      const stat = fsSync.lstatSync(child);
+      if (entry.isSymbolicLink()) throw new PluginInstallError("PLUGIN_SNAPSHOT_FAILED", "Plugin data snapshot refuses symbolic links.");
+      if (entry.isDirectory()) {
+        records.push({ path: childRelative, mode: stat.mode & 511, type: "directory" });
+        walk(child, childRelative);
+      } else if (entry.isFile()) records.push({ path: childRelative, mode: stat.mode & 511, type: "file", sha256: createHash2("sha256").update(fsSync.readFileSync(child)).digest("hex") });
+      else throw new PluginInstallError("PLUGIN_SNAPSHOT_FAILED", "Plugin data snapshot contains an unsupported file type.");
+    }
+  };
+  walk(root);
+  return records;
+}
+function treeDigest(root) {
+  return createHash2("sha256").update(JSON.stringify({
+    records: treeRecords(root).map(({ path: recordPath, type, sha256 }) => ({ path: recordPath, type, sha256 }))
+  })).digest("hex");
+}
+function treeModeDigest(root, excludeMarker = false) {
+  const records = treeRecords(root, excludeMarker);
+  return createHash2("sha256").update(JSON.stringify({ rootMode: fsSync.lstatSync(root).mode & 511, records })).digest("hex");
+}
+function boundaryDigest(target) {
+  const records = [];
+  const walk = (current, relative2) => {
+    const stat = fsSync.lstatSync(current);
+    if (stat.isSymbolicLink()) records.push({ path: relative2, type: "symlink", mode: stat.mode & 511, link: fsSync.readlinkSync(current) });
+    else if (stat.isFile()) records.push({ path: relative2, type: "file", mode: stat.mode & 511, sha256: createHash2("sha256").update(fsSync.readFileSync(current)).digest("hex") });
+    else if (stat.isDirectory()) {
+      records.push({ path: relative2, type: "directory", mode: stat.mode & 511 });
+      for (const name of fsSync.readdirSync(current).sort()) walk(path14.join(current, name), relative2 ? path14.join(relative2, name) : name);
+    } else throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin package evidence contains an unsupported boundary type.");
+  };
+  walk(target, "");
+  return createHash2("sha256").update(JSON.stringify(records)).digest("hex");
+}
+function fsyncBoundary(target) {
+  const stat = fsSync.lstatSync(target);
+  if (stat.isFile()) {
+    const fd = fsSync.openSync(target, "r");
+    fsSync.fsyncSync(fd);
+    fsSync.closeSync(fd);
+    return;
+  }
+  if (stat.isSymbolicLink()) return;
+  for (const name of fsSync.readdirSync(target)) fsyncBoundary(path14.join(target, name));
+  try {
+    const fd = fsSync.openSync(target, "r");
+    fsSync.fsyncSync(fd);
+    fsSync.closeSync(fd);
+  } catch {
+  }
+}
+function fsyncDirectory(directory) {
+  try {
+    const fd = fsSync.openSync(directory, "r");
+    fsSync.fsyncSync(fd);
+    fsSync.closeSync(fd);
+  } catch {
+  }
+}
+function secureSnapshotTree(root) {
+  fsSync.chmodSync(root, 448);
+  for (const record of treeRecords(root)) fsSync.chmodSync(path14.join(root, record.path), record.type === "directory" ? 448 : 384);
+}
+function fsyncTree(root) {
+  for (const record of treeRecords(root)) {
+    const target = path14.join(root, record.path);
+    if (record.type === "file") {
+      const fd = fsSync.openSync(target, "r");
+      fsSync.fsyncSync(fd);
+      fsSync.closeSync(fd);
+    }
+  }
+  const directories = [root, ...treeRecords(root).filter((item) => item.type === "directory").map((item) => path14.join(root, item.path))].reverse();
+  for (const directory of directories) {
+    try {
+      const fd = fsSync.openSync(directory, "r");
+      fsSync.fsyncSync(fd);
+      fsSync.closeSync(fd);
+    } catch {
+    }
+  }
+}
+function copySnapshotContents(snapshot, destination) {
+  fsSync.mkdirSync(destination, { recursive: true });
+  for (const entry of fsSync.readdirSync(snapshot, { withFileTypes: true })) {
+    if (entry.name === ".snapshot-complete.json") continue;
+    fsSync.cpSync(path14.join(snapshot, entry.name), path14.join(destination, entry.name), { recursive: true, preserveTimestamps: true });
+  }
+  fsSync.chmodSync(destination, fsSync.lstatSync(snapshot).mode & 511);
+  for (const record of treeRecords(snapshot)) {
+    fsSync.chmodSync(path14.join(destination, record.path), record.mode);
+  }
+}
+function describeTreeMismatch(expectedRoot, actualRoot) {
+  try {
+    const expectedRootMode = fsSync.lstatSync(expectedRoot).mode & 511;
+    const actualRootMode = fsSync.lstatSync(actualRoot).mode & 511;
+    if (expectedRootMode !== actualRootMode) return `root mode expected ${expectedRootMode.toString(8)}, actual ${actualRootMode.toString(8)}`;
+    const expected = treeRecords(expectedRoot);
+    const actual = new Map(treeRecords(actualRoot).map((record) => [record.path, record]));
+    for (const record of expected) {
+      const copy = actual.get(record.path);
+      if (!copy) return `missing relative record ${JSON.stringify(record.path)}`;
+      if (copy.type !== record.type) return `relative record ${JSON.stringify(record.path)} type mismatch`;
+      if (copy.mode !== record.mode) return `relative record ${JSON.stringify(record.path)} mode expected ${record.mode.toString(8)}, actual ${copy.mode.toString(8)}`;
+      if (copy.sha256 !== record.sha256) return `relative record ${JSON.stringify(record.path)} content digest mismatch`;
+      actual.delete(record.path);
+    }
+    const extra = actual.keys().next().value;
+    if (extra !== void 0) return `unexpected relative record ${JSON.stringify(extra)}`;
+  } catch {
+    return "tree comparison unavailable";
+  }
+  return "aggregate digest mismatch without a record-level difference";
+}
+function validateJournal(instanceRoot, journal) {
+  assertInstanceBoundaries(instanceRoot);
+  if (!journal || typeof journal !== "object" || !journal.data || typeof journal.data !== "object" || !journal.registry || typeof journal.registry !== "object" || !Array.isArray(journal.items) || typeof journal.pluginName !== "string" || typeof journal.transactionId !== "string" || typeof journal.phase !== "string") {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal structure is invalid.");
+  }
+  const exactKeys = (value, allowed) => Object.keys(value).every((key) => allowed.includes(key)) && allowed.filter((key) => !["contentBase64", "commitEvidence", "existed", "snapshotDir", "digest", "modeDigest", "hookStarted", "originalDigest"].includes(key)).every((key) => key in value);
+  if (!exactKeys(journal, ["version", "transactionId", "pluginName", "phase", "stageDir", "rollbackDir", "items", "data", "registry"]) || !exactKeys(journal.data, ["directory", "existed", "snapshotDir", "digest", "modeDigest", "hookStarted"]) || !exactKeys(journal.registry, ["path", "existed", "contentBase64", "mode", "commitEvidence"]) || journal.items.some((item) => !item || typeof item !== "object" || !exactKeys(item, ["name", "hadLive", "state", "originalDigest"]))) {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal contains unknown or missing fields.");
+  }
+  const pluginsDir = path14.join(instanceRoot, "plugins");
+  const validPhases = /* @__PURE__ */ new Set([
+    "initialized",
+    "staged",
+    "snapshot-pending",
+    "hook-pending",
+    "hook-running",
+    "hook-complete",
+    "packages-activated",
+    "registry-committing",
+    "registry-committed",
+    "committed",
+    ...PACKAGE_ITEMS.flatMap((name) => [`backup:${name}`, `activate:${name}`])
+  ]);
+  let parsedName;
+  try {
+    parsedName = parseNpmPackageSpec(journal.pluginName);
+  } catch {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal package name is invalid.");
+  }
+  const expectedData = path14.join(pluginsDir, "data", ...journal.pluginName.split("/"));
+  const itemNames = Array.isArray(journal.items) ? journal.items.map((item) => item?.name) : [];
+  const exactItems = itemNames.length === PACKAGE_ITEMS.length && new Set(itemNames).size === PACKAGE_ITEMS.length && PACKAGE_ITEMS.every((name) => itemNames.includes(name));
+  if (journal.version !== 3 || !TRANSACTION_ID.test(journal.transactionId) || parsedName.packageName !== journal.pluginName || parsedName.spec !== journal.pluginName || !validPhases.has(journal.phase) || journal.registry.path !== path14.join(instanceRoot, "plugins.json") || journal.stageDir !== path14.join(pluginsDir, `.stage-${journal.transactionId}`) || journal.rollbackDir !== path14.join(pluginsDir, `.rollback-${journal.transactionId}`) || journal.data.directory !== expectedData || !exactItems) {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal ownership validation failed.");
+  }
+  if (journal.items.some((item) => typeof item.hadLive !== "boolean" || !["untouched", "live-backed-up-complete", "new-activated"].includes(item.state))) {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal item state is invalid.");
+  }
+  if (journal.items.some((item) => item.hadLive ? !/^[0-9a-f]{64}$/.test(item.originalDigest ?? "") : item.originalDigest !== void 0)) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction original package evidence is invalid.");
+  if (typeof journal.registry.existed !== "boolean" || !Number.isInteger(journal.registry.mode) || journal.registry.mode < 0 || journal.registry.mode > 511 || journal.registry.existed && typeof journal.registry.contentBase64 !== "string" || !journal.registry.existed && journal.registry.contentBase64 !== void 0 || journal.registry.contentBase64 && Buffer.byteLength(journal.registry.contentBase64, "base64") > 4 * 1024 * 1024) {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal registry snapshot is invalid.");
+  }
+  if (journal.registry.contentBase64 !== void 0 && (!/^[A-Za-z0-9+/]*={0,2}$/.test(journal.registry.contentBase64) || Buffer.from(journal.registry.contentBase64, "base64").toString("base64") !== journal.registry.contentBase64)) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin registry snapshot encoding is invalid.");
+  const committedPhase = journal.phase === "registry-committed" || journal.phase === "committed";
+  const evidence = journal.registry.commitEvidence;
+  if (committedPhase !== Boolean(evidence)) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin registry commit evidence is missing or present before its committed phase.");
+  if (evidence) {
+    if (!exactKeys(evidence, ["contentBase64", "digest", "mode"]) || !/^[A-Za-z0-9+/]*={0,2}$/.test(evidence.contentBase64) || Buffer.from(evidence.contentBase64, "base64").toString("base64") !== evidence.contentBase64 || Buffer.byteLength(evidence.contentBase64, "base64") > 4 * 1024 * 1024 || !/^[0-9a-f]{64}$/.test(evidence.digest) || createHash2("sha256").update(Buffer.from(evidence.contentBase64, "base64")).digest("hex") !== evidence.digest || !Number.isInteger(evidence.mode) || evidence.mode < 0 || evidence.mode > 511) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin registry commit evidence is invalid.");
+    if (!fsSync.existsSync(journal.registry.path) || !fsSync.readFileSync(journal.registry.path).equals(Buffer.from(evidence.contentBase64, "base64")) || (fsSync.statSync(journal.registry.path).mode & 511) !== evidence.mode) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Persisted plugin registry does not match committed evidence; cleanup is quarantined.");
+  }
+  const expectedSnapshot = path14.join(pluginsDir, `.data-snapshot-${journal.transactionId}.complete`);
+  if (journal.data.snapshotDir && journal.data.snapshotDir !== expectedSnapshot) {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin data snapshot provenance validation failed.");
+  }
+  if (journal.data.existed !== void 0 && typeof journal.data.existed !== "boolean") throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin data snapshot state is invalid.");
+  if (journal.data.existed === true && (journal.data.snapshotDir !== expectedSnapshot || !/^[0-9a-f]{64}$/.test(journal.data.digest ?? "") || !/^[0-9a-f]{64}$/.test(journal.data.modeDigest ?? ""))) {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin data snapshot completion state is invalid.");
+  }
+  if (journal.data.existed === false && (journal.data.snapshotDir !== void 0 || journal.data.digest !== void 0 || journal.data.modeDigest !== void 0)) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin data absence state is invalid.");
+  for (const [target, label] of [
+    [pluginsDir, "Plugin package root"],
+    [path14.join(pluginsDir, "data"), "Plugin data root"],
+    [expectedData, "Plugin-owned data path"],
+    [journal.stageDir, "Plugin stage path"],
+    [journal.rollbackDir, "Plugin rollback path"],
+    [path14.join(pluginsDir, `.data-snapshot-${journal.transactionId}.pending`), "Plugin pending snapshot"],
+    [path14.join(pluginsDir, `.data-snapshot-${journal.transactionId}.complete`), "Plugin complete snapshot"],
+    [journal.registry.path, "Plugin registry path"]
+  ]) assertContainedPath(instanceRoot, target, label);
+  for (const name of PACKAGE_ITEMS) {
+    assertContainedPath(instanceRoot, path14.join(pluginsDir, name), `Live package boundary ${name}`);
+    assertContainedPath(instanceRoot, path14.join(journal.stageDir, name), `Staged package boundary ${name}`);
+    assertContainedPath(instanceRoot, path14.join(journal.rollbackDir, name), `Backup package boundary ${name}`);
+  }
+  validateJournalStateMachine(journal);
+}
+function validateJournalStateMachine(journal) {
+  const byName = new Map(journal.items.map((item) => [item.name, item]));
+  const states = PACKAGE_ITEMS.map((name) => byName.get(name));
+  const allUntouched = states.every((item) => item.state === "untouched");
+  const allActivated = states.every((item) => item.state === "new-activated");
+  const prePackage = /* @__PURE__ */ new Set(["initialized", "staged", "snapshot-pending", "hook-pending", "hook-running", "hook-complete"]);
+  let packageStateValid = true;
+  if (prePackage.has(journal.phase)) packageStateValid = allUntouched;
+  else if (journal.phase.startsWith("backup:") || journal.phase.startsWith("activate:")) {
+    const [kind, name] = journal.phase.split(":");
+    const index = PACKAGE_ITEMS.indexOf(name);
+    packageStateValid = index >= 0 && states.slice(0, index).every((item) => item.state === "new-activated") && states.slice(index + 1).every((item) => item.state === "untouched");
+    const current = states[index];
+    if (packageStateValid && kind === "backup") {
+      packageStateValid = current.state === "untouched" || current.hadLive && current.state === "live-backed-up-complete";
+    } else if (packageStateValid) {
+      packageStateValid = current.state === "new-activated" || (current.hadLive ? current.state === "live-backed-up-complete" : current.state === "untouched");
+    }
+  } else if (["packages-activated", "registry-committing", "registry-committed", "committed"].includes(journal.phase)) packageStateValid = allActivated;
+  if (!packageStateValid) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction phase and package item states are inconsistent.");
+  const noSnapshotYet = journal.data.existed === void 0 && journal.data.snapshotDir === void 0 && journal.data.digest === void 0 && journal.data.modeDigest === void 0;
+  const snapshotComplete = typeof journal.data.existed === "boolean" && (journal.data.existed === false || typeof journal.data.snapshotDir === "string" && typeof journal.data.digest === "string" && typeof journal.data.modeDigest === "string");
+  const beforeSnapshot = ["initialized", "staged", "snapshot-pending"].includes(journal.phase);
+  const beforeHook = journal.phase === "hook-pending";
+  const afterHookStart = !beforeSnapshot && !beforeHook;
+  const dataStateValid = beforeSnapshot && noSnapshotYet && journal.data.hookStarted === void 0 || beforeHook && snapshotComplete && journal.data.hookStarted !== true || afterHookStart && snapshotComplete && journal.data.hookStarted === true;
+  if (!dataStateValid) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction phase and data snapshot state are inconsistent.");
+}
+function validateCompleteSnapshot(journal) {
+  if (journal.data.existed !== true) return void 0;
+  const snapshot = journal.data.snapshotDir;
+  if (!snapshot || !journal.data.digest || !journal.data.modeDigest || !fsSync.existsSync(snapshot)) return void 0;
+  let marker;
+  try {
+    marker = JSON.parse(fsSync.readFileSync(path14.join(snapshot, ".snapshot-complete.json"), "utf8"));
+  } catch {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin data snapshot completion marker is unavailable; original data was not deleted.");
+  }
+  if (marker.transactionId !== journal.transactionId || marker.digest !== journal.data.digest || marker.modeDigest !== journal.data.modeDigest || treeDigest(snapshot) !== journal.data.digest || treeModeDigest(snapshot, true) !== journal.data.modeDigest) {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin data snapshot integrity validation failed; original data was not deleted.");
+  }
+  return snapshot;
+}
+function restoreJournal(instanceRoot, journal, boundary) {
+  validateJournal(instanceRoot, journal);
+  const completeSnapshot = validateCompleteSnapshot(journal);
+  const pluginsDir = path14.join(instanceRoot, "plugins");
+  for (const item of journal.items) {
+    const live = path14.join(pluginsDir, item.name);
+    const backup = path14.join(journal.rollbackDir, item.name);
+    const staged = path14.join(journal.stageDir, item.name);
+    const activated = item.state === "new-activated" || (journal.phase === `activate:${item.name}` || journal.phase === "packages-activated" || journal.phase === "registry-committing") && fsSync.existsSync(live) && !fsSync.existsSync(staged) && (fsSync.existsSync(backup) || !item.hadLive);
+    if (item.hadLive) {
+      const expected = item.originalDigest;
+      if (!fsSync.existsSync(live) || boundaryDigest(live) !== expected) {
+        if (!fsSync.existsSync(backup) || boundaryDigest(backup) !== expected) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `Original package evidence is unavailable for ${item.name}; live state was not removed.`);
+        const restoreTemp = path14.join(pluginsDir, `.restore-${journal.transactionId}-${item.name}`);
+        fsSync.rmSync(restoreTemp, { recursive: true, force: true });
+        fsSync.cpSync(backup, restoreTemp, { recursive: true, preserveTimestamps: true, dereference: false });
+        if (boundaryDigest(restoreTemp) !== expected) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `Prepared package restore did not verify for ${item.name}.`);
+        fsyncBoundary(restoreTemp);
+        boundary?.(`package:${item.name}:prepared`);
+        fsSync.rmSync(live, { recursive: true, force: true });
+        boundary?.(`package:${item.name}:live-removed`);
+        fsSync.renameSync(restoreTemp, live);
+        try {
+          const fd = fsSync.openSync(pluginsDir, "r");
+          fsSync.fsyncSync(fd);
+          fsSync.closeSync(fd);
+        } catch {
+        }
+        boundary?.(`package:${item.name}:restored`);
+      }
+      if (!fsSync.existsSync(live) || boundaryDigest(live) !== expected) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `Restored package verification failed for ${item.name}.`);
+      boundary?.(`package:${item.name}:verified`);
+    } else if (activated && fsSync.existsSync(live)) {
+      fsSync.rmSync(live, { recursive: true, force: true });
+      fsyncDirectory(pluginsDir);
+      boundary?.(`package:${item.name}:absent`);
+    }
+  }
+  if (journal.data.existed === true) {
+    const dataVerified = fsSync.existsSync(journal.data.directory) && treeDigest(journal.data.directory) === journal.data.digest && treeModeDigest(journal.data.directory) === journal.data.modeDigest;
+    if (!dataVerified) {
+      if (!completeSnapshot) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Complete plugin data evidence is unavailable; live data was not removed.");
+      const restoreTemp = path14.join(pluginsDir, `.data-restore-${journal.transactionId}.pending`);
+      fsSync.rmSync(restoreTemp, { recursive: true, force: true });
+      copySnapshotContents(completeSnapshot, restoreTemp);
+      if (treeDigest(restoreTemp) !== journal.data.digest || treeModeDigest(restoreTemp) !== journal.data.modeDigest) {
+        throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `Prepared plugin data rollback verification failed: ${describeTreeMismatch(completeSnapshot, restoreTemp)}.`);
+      }
+      fsyncTree(restoreTemp);
+      boundary?.("data:prepared");
+      fsSync.rmSync(journal.data.directory, { recursive: true, force: true });
+      boundary?.("data:live-removed");
+      fsSync.renameSync(restoreTemp, journal.data.directory);
+      try {
+        const fd = fsSync.openSync(path14.dirname(journal.data.directory), "r");
+        fsSync.fsyncSync(fd);
+        fsSync.closeSync(fd);
+      } catch {
+      }
+      boundary?.("data:restored");
+    }
+    if (!fsSync.existsSync(journal.data.directory) || treeDigest(journal.data.directory) !== journal.data.digest || treeModeDigest(journal.data.directory) !== journal.data.modeDigest) {
+      const detail = completeSnapshot ? describeTreeMismatch(completeSnapshot, journal.data.directory) : "durable snapshot unavailable";
+      throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", `Plugin data rollback verification failed: ${detail}.`);
+    }
+    boundary?.("data:verified");
+  } else if (journal.data.existed === false && journal.data.hookStarted === true) {
+    fsSync.rmSync(journal.data.directory, { recursive: true, force: true });
+    fsyncDirectory(path14.dirname(journal.data.directory));
+    boundary?.("data:absent");
+  }
+  if (journal.registry.existed && journal.registry.contentBase64 !== void 0) {
+    const expected = Buffer.from(journal.registry.contentBase64, "base64");
+    const alreadyVerified = fsSync.existsSync(journal.registry.path) && fsSync.readFileSync(journal.registry.path).equals(expected) && (fsSync.statSync(journal.registry.path).mode & 511) === journal.registry.mode;
+    if (!alreadyVerified) {
+      const tmp = `${journal.registry.path}.${journal.transactionId}.recovery`;
+      fsSync.rmSync(tmp, { force: true });
+      try {
+        fsSync.writeFileSync(tmp, expected, { flag: "wx", mode: journal.registry.mode });
+        const fd = fsSync.openSync(tmp, "r");
+        fsSync.fsyncSync(fd);
+        fsSync.closeSync(fd);
+        fsSync.renameSync(tmp, journal.registry.path);
+        fsSync.chmodSync(journal.registry.path, journal.registry.mode);
+        try {
+          const dir = fsSync.openSync(path14.dirname(journal.registry.path), "r");
+          fsSync.fsyncSync(dir);
+          fsSync.closeSync(dir);
+        } catch {
+        }
+      } finally {
+        fsSync.rmSync(tmp, { force: true });
+      }
+      boundary?.("registry:restored");
+    }
+    if (!fsSync.readFileSync(journal.registry.path).equals(expected) || (fsSync.statSync(journal.registry.path).mode & 511) !== journal.registry.mode) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin registry rollback verification failed.");
+  } else if (journal.phase === "registry-committing") {
+    fsSync.rmSync(journal.registry.path, { force: true });
+    fsyncDirectory(path14.dirname(journal.registry.path));
+  } else if (fsSync.existsSync(journal.registry.path)) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Unexpected registry appeared before its mutation boundary; it was not removed.");
+  boundary?.("all:verified");
+}
+function cleanJournalArtifacts(instanceRoot, journal, removePath = (target) => fsSync.rmSync(target, { recursive: true, force: true })) {
+  validateJournal(instanceRoot, journal);
+  const pluginsDir = path14.join(instanceRoot, "plugins");
+  const pendingSnapshot = path14.join(pluginsDir, `.data-snapshot-${journal.transactionId}.pending`);
+  const completeSnapshot = path14.join(pluginsDir, `.data-snapshot-${journal.transactionId}.complete`);
+  const restorePaths = PACKAGE_ITEMS.map((name) => path14.join(pluginsDir, `.restore-${journal.transactionId}-${name}`));
+  const dataRestore = path14.join(pluginsDir, `.data-restore-${journal.transactionId}.pending`);
+  for (const owned of [journal.stageDir, journal.rollbackDir, journal.data.snapshotDir, pendingSnapshot, completeSnapshot, ...restorePaths, dataRestore]) if (owned) removePath(owned);
+  removePath(`${journal.registry.path}.${journal.transactionId}.recovery`);
+  removePath(path14.join(instanceRoot, JOURNAL_FILE));
+  fsyncDirectory(pluginsDir);
+  fsyncDirectory(instanceRoot);
+}
+function recoverLocked(instanceRoot) {
+  assertInstanceBoundaries(instanceRoot);
+  const journalPath = path14.join(instanceRoot, JOURNAL_FILE);
+  if (!fsSync.existsSync(journalPath)) return;
+  let journal;
+  try {
+    if (fsSync.lstatSync(journalPath).isSymbolicLink() || fsSync.statSync(journalPath).size > MAX_JOURNAL_BYTES) throw new Error("invalid journal file");
+    journal = JSON.parse(fsSync.readFileSync(journalPath, "utf8"));
+  } catch {
+    throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal is unreadable; community plugins remain quarantined.");
+  }
+  validateJournal(instanceRoot, journal);
+  if (journal.phase !== "registry-committed" && journal.phase !== "committed") restoreJournal(instanceRoot, journal);
+  cleanJournalArtifacts(instanceRoot, journal);
+}
+async function recoverPluginInstallTransaction(instanceRoot, options = {}) {
+  const lock = await acquirePluginInstallLock(instanceRoot, options);
+  try {
+    recoverLocked(instanceRoot);
+  } finally {
+    lock.release();
+  }
+}
+function pluginMutationLockHeld(instanceRoot) {
+  return mutationContext.getStore()?.instanceRoot === instanceRoot;
+}
+async function withHeldPluginMutationLock(instanceRoot, lock, callback) {
+  return mutationContext.run({ instanceRoot, transactionId: lock.transactionId }, callback);
+}
+async function withPluginMutationLock(instanceRoot, callback) {
+  if (pluginMutationLockHeld(instanceRoot)) return callback();
+  const lock = await acquirePluginInstallLock(instanceRoot);
+  try {
+    recoverLocked(instanceRoot);
+    return await withHeldPluginMutationLock(instanceRoot, lock, callback);
+  } finally {
+    lock.release();
+  }
+}
+async function pathExists(file) {
+  try {
+    await fs15.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stageNpmPlugin(packageSpec, pluginsDir, childEnv, options = {}) {
+  const { packageName } = parseNpmPackageSpec(packageSpec);
+  await fs15.mkdir(pluginsDir, { recursive: true });
+  const liveManifest = path14.join(pluginsDir, "package.json");
+  const liveModules = path14.join(pluginsDir, "node_modules");
+  if (await pathExists(liveModules) && !await pathExists(liveManifest)) {
+    throw new PluginInstallError("PLUGIN_INSTALL_STATE_INVALID", "Plugin directory has node_modules without package.json; no changes were made.");
+  }
+  const transactionId = options.transactionId ?? randomUUID2();
+  const stageDir = path14.join(pluginsDir, `.stage-${transactionId}`);
+  const rollbackDir = path14.join(pluginsDir, `.rollback-${transactionId}`);
+  await fs15.mkdir(stageDir, { recursive: true });
+  try {
+    for (const name of ["package.json", "package-lock.json"]) {
+      const source = path14.join(pluginsDir, name);
+      if (await pathExists(source)) await fs15.copyFile(source, path14.join(stageDir, name));
+    }
+    if (!await pathExists(path14.join(stageDir, "package.json"))) {
+      await fs15.writeFile(path14.join(stageDir, "package.json"), '{"private":true}\n', { mode: 384 });
+    }
+    try {
+      if (options.runNpm) await options.runNpm(stageDir, packageSpec);
+      else await execFileAsync("npm", ["install", packageSpec, "--prefix", stageDir, "--save", "--ignore-scripts"], {
+        timeout: 6e4,
+        env: childEnv
+      });
+    } catch {
+      throw new PluginInstallError("PLUGIN_STAGE_FAILED", "npm could not stage the plugin package; live plugins were not changed.");
+    }
+    const packagePath = path14.join(stageDir, "node_modules", ...packageName.split("/"), "package.json");
+    let manifest;
+    try {
+      manifest = JSON.parse(await fs15.readFile(packagePath, "utf8"));
+    } catch {
+      throw new PluginInstallError("PLUGIN_CONTRACT_INVALID", "Staged plugin package metadata is unavailable or invalid.");
+    }
+    let module;
+    try {
+      module = await importFromDir(packageName, stageDir);
+    } catch {
+      throw new PluginInstallError("PLUGIN_CONTRACT_INVALID", "Staged plugin entry point could not be loaded.");
+    }
+    const plugin = validateOpenACPPluginModule(module, manifest, packageName);
+    let activated = false;
+    let finished = false;
+    const rollback = async () => {
+      if (finished) return;
+      for (const name of ["node_modules", "package.json", "package-lock.json"]) {
+        const live = path14.join(pluginsDir, name);
+        const backup = path14.join(rollbackDir, name);
+        if (await pathExists(live)) await fs15.rm(live, { recursive: true, force: true });
+        if (await pathExists(backup)) await fs15.rename(backup, live);
+      }
+      finished = true;
+      await fs15.rm(rollbackDir, { recursive: true, force: true });
+      await fs15.rm(stageDir, { recursive: true, force: true });
+    };
+    return {
+      packageName,
+      manifest,
+      plugin,
+      stageDir,
+      rollbackDir,
+      activationItems: async () => Promise.all(PACKAGE_ITEMS.map(async (name) => ({ name, hadLive: await pathExists(path14.join(pluginsDir, name)), state: "untouched" }))),
+      discard: async () => {
+        if (activated) await rollback();
+        else await fs15.rm(stageDir, { recursive: true, force: true });
+      },
+      activate: async (hooks) => {
+        if (activated) throw new PluginInstallError("PLUGIN_ACTIVATION_FAILED", "Staged plugin was already activated.");
+        await fs15.mkdir(rollbackDir, { recursive: true });
+        try {
+          const roots = [pluginsDir, stageDir, rollbackDir];
+          for (const root of roots) assertDirectoryBoundary(root, "Plugin activation boundary");
+          const devices = roots.map((root) => fsSync.statSync(root).dev);
+          if (new Set(devices).size !== 1) throw new PluginInstallError("PLUGIN_ACTIVATION_FAILED", "Plugin activation boundaries must share one filesystem.");
+          for (const name of PACKAGE_ITEMS) {
+            const live = path14.join(pluginsDir, name);
+            const stagedItem = path14.join(stageDir, name);
+            const backup = path14.join(rollbackDir, name);
+            if (fsSync.existsSync(backup)) throw new PluginInstallError("PLUGIN_ACTIVATION_FAILED", "Plugin rollback boundary must be empty before activation.");
+            for (const boundary of [live, stagedItem]) {
+              if (!fsSync.existsSync(boundary)) continue;
+              const stat = fsSync.lstatSync(boundary);
+              if (stat.isSymbolicLink() || stat.dev !== devices[0]) throw new PluginInstallError("PLUGIN_ACTIVATION_FAILED", "Plugin activation boundary is a symlink or crosses filesystems.");
+              if (fsSync.realpathSync(path14.dirname(boundary)) !== path14.resolve(path14.dirname(boundary))) throw new PluginInstallError("PLUGIN_ACTIVATION_FAILED", "Plugin activation boundary has a symbolic-link ancestor.");
+            }
+          }
+          await hooks?.beforeActivation();
+          for (const name of ["node_modules", "package.json", "package-lock.json"]) {
+            const live = path14.join(pluginsDir, name);
+            const staged = path14.join(stageDir, name);
+            const backup = path14.join(rollbackDir, name);
+            await hooks?.beforeBackup(name);
+            if (await pathExists(live)) {
+              if (options.renamePath) options.renamePath(live, backup);
+              else await fs15.rename(live, backup);
+            }
+            await hooks?.afterBackup(name);
+            await hooks?.beforeActivate(name);
+            if (await pathExists(staged)) {
+              if (options.renamePath) options.renamePath(staged, live);
+              else await fs15.rename(staged, live);
+            }
+            await hooks?.afterActivate(name);
+          }
+          activated = true;
+          await hooks?.afterPackagesActivated();
+        } catch (error) {
+          if (error instanceof PluginInstallCrashSimulation || hooks) throw error;
+          await rollback();
+          throw new PluginInstallError("PLUGIN_ACTIVATION_FAILED", "Plugin activation failed; previous packages were restored.");
+        }
+        return {
+          rollback,
+          commit: async () => {
+            if (finished) return;
+            finished = true;
+            await Promise.allSettled([
+              fs15.rm(rollbackDir, { recursive: true, force: true }),
+              fs15.rm(stageDir, { recursive: true, force: true })
+            ]);
+          }
+        };
+      }
+    };
+  } catch (error) {
+    await fs15.rm(stageDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+async function installNpmPlugin(packageName, pluginsDir, childEnv) {
+  if (!VALID_NPM_NAME.test(packageName)) {
+    throw new Error(`Invalid package name: "${packageName}". Must be a valid npm package name.`);
+  }
+  const dir = pluginsDir;
+  try {
+    return await importFromDir(packageName, dir);
+  } catch {
+  }
+  void childEnv;
+  throw new PluginInstallError(
+    "PLUGIN_INSTALL_STATE_INVALID",
+    `Runtime package installation is not safe while OpenACP may be loaded. Run "openacp plugin install ${packageName}" and restart OpenACP.`
+  );
+}
+var execFileAsync, VALID_NPM_NAME, PluginInstallError, PluginInstallCrashSimulation, JOURNAL_FILE, LOCK_FILE, PACKAGE_ITEMS, MAX_JOURNAL_BYTES, TRANSACTION_ID, mutationContext, PluginInstallJournalController;
+var init_plugin_installer = __esm({
+  "src/core/plugin/plugin-installer.ts"() {
+    "use strict";
+    execFileAsync = promisify(execFile);
+    VALID_NPM_NAME = /^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(@[\w.^~>=<|-]+)?$/i;
+    PluginInstallError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "PluginInstallError";
+      }
+      code;
+    };
+    PluginInstallCrashSimulation = class extends Error {
+      constructor(phase) {
+        super(`Simulated process crash at ${phase}`);
+        this.phase = phase;
+        this.name = "PluginInstallCrashSimulation";
+      }
+      phase;
+    };
+    JOURNAL_FILE = "plugin-install.journal.json";
+    LOCK_FILE = "plugin-install.lock";
+    PACKAGE_ITEMS = ["node_modules", "package.json", "package-lock.json"];
+    MAX_JOURNAL_BYTES = 8 * 1024 * 1024;
+    TRANSACTION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    mutationContext = new AsyncLocalStorage();
+    PluginInstallJournalController = class {
+      constructor(instanceRoot, lock, hooks = {}) {
+        this.instanceRoot = instanceRoot;
+        this.lock = lock;
+        this.hooks = hooks;
+        this.transactionId = lock.transactionId;
+        this.journalPath = path14.join(instanceRoot, JOURNAL_FILE);
+      }
+      instanceRoot;
+      lock;
+      hooks;
+      journal;
+      journalPath;
+      transactionId;
+      recoverExisting() {
+        recoverLocked(this.instanceRoot);
+      }
+      initialize(pluginName, dataDirectory, registryPath) {
+        if (this.journal) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal is already initialized.");
+        const pluginsDir = path14.join(this.instanceRoot, "plugins");
+        assertInstanceBoundaries(this.instanceRoot);
+        const expectedData = path14.join(pluginsDir, "data", ...pluginName.split("/"));
+        if (dataDirectory !== expectedData || registryPath !== path14.join(this.instanceRoot, "plugins.json")) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction intent paths are invalid.");
+        const existed = fsSync.existsSync(registryPath);
+        this.journal = {
+          version: 3,
+          transactionId: this.transactionId,
+          pluginName,
+          phase: "initialized",
+          stageDir: path14.join(pluginsDir, `.stage-${this.transactionId}`),
+          rollbackDir: path14.join(pluginsDir, `.rollback-${this.transactionId}`),
+          items: PACKAGE_ITEMS.map((name) => {
+            const live = path14.join(pluginsDir, name);
+            const hadLive = fsSync.existsSync(live);
+            return { name, hadLive, state: "untouched", originalDigest: hadLive ? boundaryDigest(live) : void 0 };
+          }),
+          data: { directory: dataDirectory },
+          registry: { path: registryPath, existed, contentBase64: existed ? fsSync.readFileSync(registryPath).toString("base64") : void 0, mode: existed ? fsSync.statSync(registryPath).mode & 511 : 384 }
+        };
+        validateJournal(this.instanceRoot, this.journal);
+        this.persist();
+        this.hooks.crashAt?.("initialized");
+      }
+      snapshotData(directory) {
+        if (!this.journal || this.journal.data.directory !== directory) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction was not prepared for this data directory.");
+        validateJournal(this.instanceRoot, this.journal);
+        if (!fsSync.existsSync(directory)) {
+          const result2 = { directory, existed: false };
+          this.journal.data = result2;
+          this.transition("hook-pending");
+          return result2;
+        }
+        const pluginsDir = path14.join(this.instanceRoot, "plugins");
+        const pending = path14.join(pluginsDir, `.data-snapshot-${this.transactionId}.pending`);
+        const complete = path14.join(pluginsDir, `.data-snapshot-${this.transactionId}.complete`);
+        let result;
+        try {
+          fsSync.rmSync(pending, { recursive: true, force: true });
+          fsSync.rmSync(complete, { recursive: true, force: true });
+          (this.hooks.copyTree ?? ((source, destination) => fsSync.cpSync(source, destination, { recursive: true, preserveTimestamps: true })))(directory, pending);
+          const digest = treeDigest(directory);
+          if (treeDigest(pending) !== digest) throw new PluginInstallError("PLUGIN_SNAPSHOT_FAILED", "Plugin data snapshot verification failed.");
+          secureSnapshotTree(pending);
+          const modeDigest = treeModeDigest(pending, true);
+          atomicJson(path14.join(pending, ".snapshot-complete.json"), { version: 1, transactionId: this.transactionId, digest, modeDigest });
+          fsyncTree(pending);
+          const deviceForPath = this.hooks.deviceForPath ?? ((target) => fsSync.statSync(target).dev);
+          if (deviceForPath(pluginsDir) !== deviceForPath(pending)) throw new PluginInstallError("PLUGIN_SNAPSHOT_FAILED", "Plugin transaction paths must share one filesystem.");
+          fsSync.renameSync(pending, complete);
+          try {
+            const fd = fsSync.openSync(pluginsDir, "r");
+            fsSync.fsyncSync(fd);
+            fsSync.closeSync(fd);
+          } catch {
+          }
+          this.hooks.crashAfterSnapshotRename?.();
+          result = { directory, existed: true, snapshotDir: complete, digest, modeDigest };
+        } catch (error) {
+          if (error instanceof PluginInstallCrashSimulation) throw error;
+          fsSync.rmSync(pending, { recursive: true, force: true });
+          fsSync.rmSync(complete, { recursive: true, force: true });
+          if (error instanceof PluginInstallError) throw error;
+          throw new PluginInstallError("PLUGIN_SNAPSHOT_FAILED", "Plugin data snapshot could not be completed; original data was not changed.");
+        }
+        this.journal.data = result;
+        try {
+          this.transition("hook-pending");
+        } catch (error) {
+          if (error instanceof PluginInstallCrashSimulation) throw error;
+          fsSync.rmSync(complete, { recursive: true, force: true });
+          throw error;
+        }
+        return result;
+      }
+      async prepare(pluginName, staged, dataDirectory, registryPath) {
+        const pluginsDir = path14.join(this.instanceRoot, "plugins");
+        const deviceForPath = this.hooks.deviceForPath ?? ((target) => fsSync.statSync(target).dev);
+        if (deviceForPath(pluginsDir) !== deviceForPath(staged.stageDir)) throw new PluginInstallError("PLUGIN_STAGE_FAILED", "Plugin transaction paths must share one filesystem.");
+        if (!this.journal) this.initialize(pluginName, dataDirectory, registryPath);
+        const journal = this.journal;
+        if (journal.pluginName !== pluginName || journal.stageDir !== staged.stageDir || journal.rollbackDir !== staged.rollbackDir) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Staged plugin does not match durable transaction intent.");
+        this.transition("staged");
+        this.transition("snapshot-pending");
+        return {
+          beforeActivation: async () => {
+          },
+          beforeBackup: async (name) => this.transition(`backup:${name}`),
+          afterBackup: async (name) => {
+            const item = this.journal.items.find((entry) => entry.name === name);
+            if (item.hadLive) item.state = "live-backed-up-complete";
+            this.persist();
+          },
+          beforeActivate: async (name) => this.transition(`activate:${name}`),
+          afterActivate: async (name) => {
+            const item = this.journal.items.find((entry) => entry.name === name);
+            item.state = "new-activated";
+            this.persist();
+          },
+          afterPackagesActivated: async () => this.transition("packages-activated")
+        };
+      }
+      transition(phase) {
+        if (!this.journal) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Plugin transaction journal was not prepared.");
+        const previous = this.journal.phase;
+        const previousHookStarted = this.journal.data.hookStarted;
+        this.journal.phase = phase;
+        if (phase === "hook-running") this.journal.data.hookStarted = true;
+        try {
+          this.hooks.failPersistAt?.(phase);
+          this.persist();
+        } catch (error) {
+          this.journal.phase = previous;
+          this.journal.data.hookStarted = previousHookStarted;
+          throw error;
+        }
+        this.hooks.crashAt?.(phase);
+      }
+      markRegistryCommitted(expectedContent, expectedMode) {
+        if (!this.journal || this.journal.phase !== "registry-committing") throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Registry commit marker requires the registry-committing phase.");
+        const actual = fsSync.readFileSync(this.journal.registry.path);
+        const actualMode = fsSync.statSync(this.journal.registry.path).mode & 511;
+        if (!actual.equals(expectedContent) || actualMode !== expectedMode) throw new PluginInstallError("PLUGIN_RECOVERY_FAILED", "Persisted registry does not match the intended committed state.");
+        const previousPhase = this.journal.phase;
+        this.journal.registry.commitEvidence = {
+          contentBase64: expectedContent.toString("base64"),
+          digest: createHash2("sha256").update(expectedContent).digest("hex"),
+          mode: expectedMode
+        };
+        this.journal.phase = "registry-committed";
+        try {
+          this.hooks.failPersistAt?.("registry-committed");
+          this.persist();
+        } catch (error) {
+          this.journal.phase = previousPhase;
+          delete this.journal.registry.commitEvidence;
+          throw error;
+        }
+        this.hooks.crashAt?.("registry-committed");
+      }
+      rollback() {
+        if (!this.journal) return;
+        if (this.journal.phase === "registry-committed" || this.journal.phase === "committed") {
+          cleanJournalArtifacts(this.instanceRoot, this.journal, this.hooks.removePath);
+          this.journal = void 0;
+          return;
+        }
+        restoreJournal(this.instanceRoot, this.journal, this.hooks.rollbackBoundary);
+        cleanJournalArtifacts(this.instanceRoot, this.journal, this.hooks.removePath);
+        this.journal = void 0;
+      }
+      commit() {
+        try {
+          this.transition("committed");
+        } catch (error) {
+          if (error instanceof PluginInstallCrashSimulation) throw error;
+          return false;
+        }
+        try {
+          cleanJournalArtifacts(this.instanceRoot, this.journal, this.hooks.removePath);
+          this.journal = void 0;
+          return true;
+        } catch (error) {
+          if (error instanceof PluginInstallCrashSimulation) throw error;
+          return false;
+        }
+      }
+      get isCommitted() {
+        return this.journal?.phase === "registry-committed" || this.journal?.phase === "committed";
+      }
+      release() {
+        this.lock.release();
+      }
+      persist() {
+        validateJournal(this.instanceRoot, this.journal);
+        atomicJson(this.journalPath, this.journal);
+      }
+    };
+  }
+});
+
 // src/plugins/speech/providers/groq.ts
 function mimeToExt(mimeType) {
   const map = {
@@ -1700,16 +2690,18 @@ var init_groq = __esm({
     "use strict";
     GROQ_API_URL = "https://api.groq.com/openai/v1/audio/transcriptions";
     GroqSTT = class {
-      constructor(apiKey, defaultModel = "whisper-large-v3-turbo", scopedFetch = globalThis.fetch, getScopedFetch) {
+      constructor(apiKey, defaultModel = "whisper-large-v3-turbo", scopedFetch = globalThis.fetch, getScopedFetch, endpoint = GROQ_API_URL) {
         this.apiKey = apiKey;
         this.defaultModel = defaultModel;
         this.scopedFetch = scopedFetch;
         this.getScopedFetch = getScopedFetch;
+        this.endpoint = endpoint;
       }
       apiKey;
       defaultModel;
       scopedFetch;
       getScopedFetch;
+      endpoint;
       name = "groq";
       /**
        * Transcribes audio using the Groq Whisper API.
@@ -1726,7 +2718,7 @@ var init_groq = __esm({
         if (options?.language) {
           form.append("language", options.language);
         }
-        const resp = await (this.getScopedFetch?.() ?? this.scopedFetch)(GROQ_API_URL, {
+        const resp = await (this.getScopedFetch?.() ?? this.scopedFetch)(this.endpoint, {
           method: "POST",
           headers: { Authorization: `Bearer ${this.apiKey}` },
           body: form
@@ -1756,26 +2748,26 @@ var init_groq = __esm({
 });
 
 // src/plugins/speech/providers/local-whisper.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
-import { mkdtemp, rm, writeFile } from "fs/promises";
+import { mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir } from "os";
-import path14 from "path";
+import path16 from "path";
 import { fileURLToPath } from "url";
-import { promisify } from "util";
+import { promisify as promisify2 } from "util";
 function resolveLocalWhisperScriptPath() {
-  const moduleDir = path14.dirname(fileURLToPath(import.meta.url));
+  const moduleDir = path16.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path14.resolve(moduleDir, "../scripts/transcribe_audio.sh"),
-    path14.resolve(moduleDir, "speech/transcribe_audio.sh")
+    path16.resolve(moduleDir, "../scripts/transcribe_audio.sh"),
+    path16.resolve(moduleDir, "speech/transcribe_audio.sh")
   ];
   return candidates.find(existsSync6) ?? candidates[0];
 }
-var execFileAsync, LOCAL_WHISPER_PROVIDER, LOCAL_WHISPER_DEFAULTS;
+var execFileAsync2, LOCAL_WHISPER_PROVIDER, LOCAL_WHISPER_DEFAULTS;
 var init_local_whisper = __esm({
   "src/plugins/speech/providers/local-whisper.ts"() {
     "use strict";
-    execFileAsync = promisify(execFile);
+    execFileAsync2 = promisify2(execFile2);
     LOCAL_WHISPER_PROVIDER = "local-whisper";
     LOCAL_WHISPER_DEFAULTS = {
       language: "ru",
@@ -1805,7 +2797,7 @@ function readLocalWhisperSettings(raw) {
 function buildSpeechServiceConfig(raw) {
   const groqApiKey = readOptionalString(raw.groqApiKey);
   const requestedProvider = readOptionalString(raw.sttProvider);
-  const provider = requestedProvider === LOCAL_WHISPER_PROVIDER ? LOCAL_WHISPER_PROVIDER : groqApiKey ? "groq" : null;
+  const provider = requestedProvider === LOCAL_WHISPER_PROVIDER ? LOCAL_WHISPER_PROVIDER : requestedProvider === "groq" && groqApiKey ? "groq" : raw.sttProvider === void 0 && groqApiKey ? "groq" : null;
   const providers = {};
   if (groqApiKey) providers.groq = { apiKey: groqApiKey };
   if (provider === LOCAL_WHISPER_PROVIDER) {
@@ -1856,23 +2848,23 @@ var init_proxy_types = __esm({
 });
 
 // src/core/network/proxy-store.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs17 from "fs";
+import path17 from "path";
 import net from "net";
 function atomicWrite(file, value, mode) {
-  fs15.mkdirSync(path15.dirname(file), { recursive: true, mode: 448 });
+  fs17.mkdirSync(path17.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-  fs15.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+  fs17.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
 `, { mode, flag: "wx" });
-  fs15.chmodSync(tmp, mode);
-  const fd = fs15.openSync(tmp, "r");
-  fs15.fsyncSync(fd);
-  fs15.closeSync(fd);
-  fs15.renameSync(tmp, file);
+  fs17.chmodSync(tmp, mode);
+  const fd = fs17.openSync(tmp, "r");
+  fs17.fsyncSync(fd);
+  fs17.closeSync(fd);
+  fs17.renameSync(tmp, file);
   try {
-    const dir = fs15.openSync(path15.dirname(file), "r");
-    fs15.fsyncSync(dir);
-    fs15.closeSync(dir);
+    const dir = fs17.openSync(path17.dirname(file), "r");
+    fs17.fsyncSync(dir);
+    fs17.closeSync(dir);
   } catch {
   }
 }
@@ -1964,7 +2956,7 @@ var init_proxy_store = __esm({
     };
     ProxyStoreCorruptError = class extends ProxyStoreError {
       constructor(file, reason, quarantine, lkgAvailable = false) {
-        super("PROXY_STORE_CORRUPT", `Proxy policy store is invalid (${path15.basename(file)}): ${reason}`, { file, quarantine, lkgAvailable });
+        super("PROXY_STORE_CORRUPT", `Proxy policy store is invalid (${path17.basename(file)}): ${reason}`, { file, quarantine, lkgAvailable });
         this.name = "ProxyStoreCorruptError";
       }
     };
@@ -1981,11 +2973,11 @@ var init_proxy_store = __esm({
       lkgPath;
       lockPath;
       constructor(instanceRoot) {
-        this.configPath = path15.join(instanceRoot, "proxy.json");
-        this.secretsPath = path15.join(instanceRoot, "proxy-secrets.json");
-        this.journalPath = path15.join(instanceRoot, "proxy-transaction.json");
-        this.lkgPath = path15.join(instanceRoot, "proxy-lkg.json");
-        this.lockPath = path15.join(instanceRoot, "proxy.lock");
+        this.configPath = path17.join(instanceRoot, "proxy.json");
+        this.secretsPath = path17.join(instanceRoot, "proxy-secrets.json");
+        this.journalPath = path17.join(instanceRoot, "proxy-transaction.json");
+        this.lkgPath = path17.join(instanceRoot, "proxy-lkg.json");
+        this.lockPath = path17.join(instanceRoot, "proxy.lock");
         const lock = this.acquireLock();
         try {
           this.cleanupOrphans(instanceRoot);
@@ -1996,18 +2988,18 @@ var init_proxy_store = __esm({
       }
       cleanupOrphans(root) {
         try {
-          const names = fs15.readdirSync(root);
-          for (const name of names) if (/^proxy.*\.tmp$/.test(name)) fs15.rmSync(path15.join(root, name), { force: true });
+          const names = fs17.readdirSync(root);
+          for (const name of names) if (/^proxy.*\.tmp$/.test(name)) fs17.rmSync(path17.join(root, name), { force: true });
           const quarantines = names.filter((n) => n.includes(".corrupt.")).sort().reverse();
-          for (const name of quarantines.slice(3)) fs15.rmSync(path15.join(root, name), { force: true });
+          for (const name of quarantines.slice(3)) fs17.rmSync(path17.join(root, name), { force: true });
         } catch {
         }
       }
       quarantine(file) {
         try {
           const target = `${file}.corrupt.${Date.now()}`;
-          fs15.copyFileSync(file, target, fs15.constants.COPYFILE_EXCL);
-          fs15.chmodSync(target, 384);
+          fs17.copyFileSync(file, target, fs17.constants.COPYFILE_EXCL);
+          fs17.chmodSync(target, 384);
           return target;
         } catch {
           return void 0;
@@ -2015,28 +3007,28 @@ var init_proxy_store = __esm({
       }
       readConfigFile(file = this.configPath) {
         try {
-          return validateConfig(JSON.parse(fs15.readFileSync(file, "utf8")));
+          return validateConfig(JSON.parse(fs17.readFileSync(file, "utf8")));
         } catch (error) {
           if (error.code === "ENOENT" && file === this.configPath) return structuredClone(DEFAULT_CONFIG2);
           const q = file === this.configPath ? this.quarantine(file) : void 0;
-          throw new ProxyStoreCorruptError(file, error.message, q, fs15.existsSync(this.lkgPath));
+          throw new ProxyStoreCorruptError(file, error.message, q, fs17.existsSync(this.lkgPath));
         }
       }
       readSecretsFile() {
         try {
-          const stat = fs15.statSync(this.secretsPath);
+          const stat = fs17.statSync(this.secretsPath);
           if ((stat.mode & 63) !== 0) throw new Error("secret file mode must be 0600");
-          return validateSecrets(JSON.parse(fs15.readFileSync(this.secretsPath, "utf8")));
+          return validateSecrets(JSON.parse(fs17.readFileSync(this.secretsPath, "utf8")));
         } catch (error) {
           if (error.code === "ENOENT") return {};
           const q = this.quarantine(this.secretsPath);
-          throw new ProxyStoreCorruptError(this.secretsPath, error.message, q, fs15.existsSync(this.lkgPath));
+          throw new ProxyStoreCorruptError(this.secretsPath, error.message, q, fs17.existsSync(this.lkgPath));
         }
       }
       recoverJournal() {
-        if (!fs15.existsSync(this.journalPath)) return;
+        if (!fs17.existsSync(this.journalPath)) return;
         try {
-          const tx = JSON.parse(fs15.readFileSync(this.journalPath, "utf8"));
+          const tx = JSON.parse(fs17.readFileSync(this.journalPath, "utf8"));
           if (tx.version !== 1) throw new Error("unsupported transaction version");
           const config = validateConfig(tx.config);
           const secrets = validateSecrets(tx.secrets);
@@ -2044,9 +3036,9 @@ var init_proxy_store = __esm({
           atomicWrite(this.configPath, config, 384);
           atomicWrite(this.secretsPath, secrets, 384);
           atomicWrite(this.lkgPath, tx, 384);
-          fs15.unlinkSync(this.journalPath);
+          fs17.unlinkSync(this.journalPath);
         } catch (error) {
-          throw new ProxyStoreCorruptError(this.journalPath, error.message, this.quarantine(this.journalPath), fs15.existsSync(this.lkgPath));
+          throw new ProxyStoreCorruptError(this.journalPath, error.message, this.quarantine(this.journalPath), fs17.existsSync(this.lkgPath));
         }
       }
       load() {
@@ -2055,7 +3047,7 @@ var init_proxy_store = __esm({
           validateCredentialConsistency(config, this.readSecretsFile());
         } catch (error) {
           if (error instanceof ProxyStoreCorruptError) throw error;
-          throw new ProxyStoreCorruptError(this.secretsPath, error.message, this.quarantine(this.secretsPath), fs15.existsSync(this.lkgPath));
+          throw new ProxyStoreCorruptError(this.secretsPath, error.message, this.quarantine(this.secretsPath), fs17.existsSync(this.lkgPath));
         }
         return config;
       }
@@ -2065,7 +3057,7 @@ var init_proxy_store = __esm({
         try {
           validateCredentialConsistency(config, secrets);
         } catch (error) {
-          throw new ProxyStoreCorruptError(this.secretsPath, error.message, this.quarantine(this.secretsPath), fs15.existsSync(this.lkgPath));
+          throw new ProxyStoreCorruptError(this.secretsPath, error.message, this.quarantine(this.secretsPath), fs17.existsSync(this.lkgPath));
         }
         return secrets;
       }
@@ -2086,7 +3078,7 @@ var init_proxy_store = __esm({
           atomicWrite(this.configPath, next, 384);
           atomicWrite(this.secretsPath, cleanSecrets, 384);
           atomicWrite(this.lkgPath, tx, 384);
-          fs15.unlinkSync(this.journalPath);
+          fs17.unlinkSync(this.journalPath);
           return next;
         } finally {
           this.releaseLock(lock);
@@ -2094,21 +3086,21 @@ var init_proxy_store = __esm({
       }
       releaseLock(fd) {
         try {
-          fs15.closeSync(fd);
+          fs17.closeSync(fd);
         } catch {
         }
         try {
-          fs15.unlinkSync(this.lockPath);
+          fs17.unlinkSync(this.lockPath);
         } catch {
         }
       }
       acquireLock() {
-        fs15.mkdirSync(path15.dirname(this.lockPath), { recursive: true, mode: 448 });
+        fs17.mkdirSync(path17.dirname(this.lockPath), { recursive: true, mode: 448 });
         for (let attempt = 0; attempt < 200; attempt++) {
           try {
-            const fd = fs15.openSync(this.lockPath, "wx", 384);
-            fs15.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: Date.now() }));
-            fs15.fsyncSync(fd);
+            const fd = fs17.openSync(this.lockPath, "wx", 384);
+            fs17.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: Date.now() }));
+            fs17.fsyncSync(fd);
             return fd;
           } catch (error) {
             if (error.code !== "EEXIST") throw error;
@@ -2120,7 +3112,7 @@ var init_proxy_store = __esm({
       }
       removeStaleLock() {
         try {
-          const lock = JSON.parse(fs15.readFileSync(this.lockPath, "utf8"));
+          const lock = JSON.parse(fs17.readFileSync(this.lockPath, "utf8"));
           const old = !Number.isFinite(lock.createdAt) || Date.now() - Number(lock.createdAt) > 3e4;
           let dead = false;
           if (Number.isInteger(lock.pid)) {
@@ -2131,13 +3123,13 @@ var init_proxy_store = __esm({
             }
           }
           if (dead || old && !Number.isInteger(lock.pid)) {
-            fs15.unlinkSync(this.lockPath);
+            fs17.unlinkSync(this.lockPath);
             return true;
           }
         } catch {
           try {
-            if (Date.now() - fs15.statSync(this.lockPath).mtimeMs > 3e4) {
-              fs15.unlinkSync(this.lockPath);
+            if (Date.now() - fs17.statSync(this.lockPath).mtimeMs > 3e4) {
+              fs17.unlinkSync(this.lockPath);
               return true;
             }
           } catch {
@@ -2147,7 +3139,7 @@ var init_proxy_store = __esm({
       }
       loadLastKnownGood() {
         try {
-          return validateConfig(JSON.parse(fs15.readFileSync(this.lkgPath, "utf8")).config);
+          return validateConfig(JSON.parse(fs17.readFileSync(this.lkgPath, "utf8")).config);
         } catch {
           return void 0;
         }
@@ -2159,7 +3151,7 @@ var init_proxy_store = __esm({
 // src/core/network/proxy-service.ts
 import { ProxyAgent } from "proxy-agent";
 import nodeFetch from "node-fetch";
-import fs16 from "fs";
+import fs18 from "fs";
 import net2 from "net";
 import { Readable } from "stream";
 import debug from "debug";
@@ -2331,6 +3323,7 @@ var init_proxy_service = __esm({
         "services.npmUpdate",
         "services.agentRegistry",
         "services.pluginInstaller",
+        "services.speech",
         "services.speechDownloads",
         "plugins.default"
       ]);
@@ -2534,11 +3527,11 @@ var init_proxy_service = __esm({
         return this.saveProfile(this.parseEnvFile(id, envFile, name));
       }
       parseEnvFile(id, envFile, name) {
-        const stat = fs16.statSync(envFile);
+        const stat = fs18.statSync(envFile);
         if (!stat.isFile()) throw new Error("Proxy env path is not a file");
         if ((stat.mode & 63) !== 0) throw new Error("Proxy env file must have mode 0600");
         const values = {};
-        for (const rawLine of fs16.readFileSync(envFile, "utf8").split(/\r?\n/)) {
+        for (const rawLine of fs18.readFileSync(envFile, "utf8").split(/\r?\n/)) {
           const line = rawLine.trim();
           if (!line || line.startsWith("#")) continue;
           const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line);
@@ -3040,7 +4033,7 @@ var init_proxy_service = __esm({
 });
 
 // src/core/doctor/checks/config.ts
-import * as fs17 from "fs";
+import * as fs19 from "fs";
 var configCheck;
 var init_config2 = __esm({
   "src/core/doctor/checks/config.ts"() {
@@ -3052,14 +4045,14 @@ var init_config2 = __esm({
       order: 1,
       async run(ctx) {
         const results = [];
-        if (!fs17.existsSync(ctx.configPath)) {
+        if (!fs19.existsSync(ctx.configPath)) {
           results.push({ status: "fail", message: "Config file not found" });
           return results;
         }
         results.push({ status: "pass", message: "Config file exists" });
         let raw;
         try {
-          raw = JSON.parse(fs17.readFileSync(ctx.configPath, "utf-8"));
+          raw = JSON.parse(fs19.readFileSync(ctx.configPath, "utf-8"));
         } catch (err) {
           results.push({
             status: "fail",
@@ -3078,7 +4071,7 @@ var init_config2 = __esm({
             fixRisk: "safe",
             fix: async () => {
               applyMigrations(raw);
-              fs17.writeFileSync(ctx.configPath, JSON.stringify(raw, null, 2));
+              fs19.writeFileSync(ctx.configPath, JSON.stringify(raw, null, 2));
               return { success: true, message: "applied migrations" };
             }
           });
@@ -3102,8 +4095,8 @@ var init_config2 = __esm({
 
 // src/core/doctor/checks/agents.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 function commandExists2(cmd) {
   try {
     execFileSync3("which", [cmd], { stdio: "pipe" });
@@ -3112,9 +4105,9 @@ function commandExists2(cmd) {
   }
   let dir = process.cwd();
   while (true) {
-    const binPath = path17.join(dir, "node_modules", ".bin", cmd);
-    if (fs18.existsSync(binPath)) return true;
-    const parent = path17.dirname(dir);
+    const binPath = path19.join(dir, "node_modules", ".bin", cmd);
+    if (fs20.existsSync(binPath)) return true;
+    const parent = path19.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3136,9 +4129,9 @@ var init_agents = __esm({
         const defaultAgent = ctx.config.defaultAgent;
         let agents = {};
         try {
-          const agentsPath = path17.join(ctx.dataDir, "agents.json");
-          if (fs18.existsSync(agentsPath)) {
-            const data = JSON.parse(fs18.readFileSync(agentsPath, "utf-8"));
+          const agentsPath = path19.join(ctx.dataDir, "agents.json");
+          if (fs20.existsSync(agentsPath)) {
+            const data = JSON.parse(fs20.readFileSync(agentsPath, "utf-8"));
             agents = data.installed ?? {};
           }
         } catch {
@@ -3189,8 +4182,61 @@ var settings_manager_exports = {};
 __export(settings_manager_exports, {
   SettingsManager: () => SettingsManager
 });
-import fs19 from "fs";
-import path18 from "path";
+import fs21 from "fs";
+import path20 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+function secureSettingsDirectory(directory) {
+  fs21.mkdirSync(directory, { recursive: true, mode: 448 });
+  fs21.chmodSync(directory, 448);
+}
+function secureSettingsTree(basePath, settingsPath, create) {
+  const target = path20.dirname(settingsPath);
+  const relative2 = path20.relative(basePath, target);
+  if (relative2.startsWith("..") || path20.isAbsolute(relative2)) throw new Error("Settings path escapes its base directory");
+  secureSettingsDirectory(basePath);
+  let current = basePath;
+  for (const segment of relative2 ? relative2.split(path20.sep) : []) {
+    current = path20.join(current, segment);
+    if (create || fs21.existsSync(current)) secureSettingsDirectory(current);
+  }
+}
+function repairSettingsPermissions(settingsPath, basePath) {
+  if (!fs21.existsSync(settingsPath)) return;
+  secureSettingsTree(basePath, settingsPath, false);
+  fs21.chmodSync(settingsPath, 384);
+}
+function atomicSettingsWrite(settingsPath, basePath, data) {
+  const directory = path20.dirname(settingsPath);
+  secureSettingsTree(basePath, settingsPath, true);
+  const temporary = `${settingsPath}.${process.pid}.${randomUUID4()}.tmp`;
+  try {
+    fs21.writeFileSync(temporary, `${JSON.stringify(data, null, 2)}
+`, { mode: 384, flag: "wx" });
+    fs21.chmodSync(temporary, 384);
+    const fd = fs21.openSync(temporary, "r");
+    try {
+      fs21.fsyncSync(fd);
+    } finally {
+      fs21.closeSync(fd);
+    }
+    fs21.renameSync(temporary, settingsPath);
+    fs21.chmodSync(settingsPath, 384);
+    try {
+      const directoryFd = fs21.openSync(directory, "r");
+      try {
+        fs21.fsyncSync(directoryFd);
+      } finally {
+        fs21.closeSync(directoryFd);
+      }
+    } catch {
+    }
+  } finally {
+    try {
+      if (fs21.existsSync(temporary)) fs21.unlinkSync(temporary);
+    } catch {
+    }
+  }
+}
 var SettingsManager, SettingsAPIImpl;
 var init_settings_manager = __esm({
   "src/core/plugin/settings-manager.ts"() {
@@ -3198,6 +4244,7 @@ var init_settings_manager = __esm({
     SettingsManager = class {
       constructor(basePath) {
         this.basePath = basePath;
+        secureSettingsDirectory(basePath);
       }
       basePath;
       /** Returns the base path for all plugin settings directories. */
@@ -3207,13 +4254,16 @@ var init_settings_manager = __esm({
       /** Create a SettingsAPI instance scoped to a specific plugin. */
       createAPI(pluginName) {
         const settingsPath = this.getSettingsPath(pluginName);
-        return new SettingsAPIImpl(settingsPath);
+        return new SettingsAPIImpl(settingsPath, this.basePath);
       }
       /** Load a plugin's settings from disk. Returns empty object if file doesn't exist. */
       async loadSettings(pluginName) {
         const settingsPath = this.getSettingsPath(pluginName);
+        secureSettingsDirectory(this.basePath);
+        if (!fs21.existsSync(settingsPath)) return {};
+        repairSettingsPermissions(settingsPath, this.basePath);
         try {
-          const content = fs19.readFileSync(settingsPath, "utf-8");
+          const content = fs21.readFileSync(settingsPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return {};
@@ -3233,7 +4283,7 @@ var init_settings_manager = __esm({
       }
       /** Resolve the absolute path to a plugin's settings.json file. */
       getSettingsPath(pluginName) {
-        return path18.join(this.basePath, pluginName, "settings.json");
+        return path20.join(this.basePath, pluginName, "settings.json");
       }
       async getPluginSettings(pluginName) {
         return this.loadSettings(pluginName);
@@ -3246,15 +4296,19 @@ var init_settings_manager = __esm({
       }
     };
     SettingsAPIImpl = class {
-      constructor(settingsPath) {
+      constructor(settingsPath, basePath) {
         this.settingsPath = settingsPath;
+        this.basePath = basePath;
       }
       settingsPath;
+      basePath;
       cache = null;
       readFile() {
         if (this.cache !== null) return this.cache;
+        secureSettingsDirectory(this.basePath);
+        if (fs21.existsSync(this.settingsPath)) repairSettingsPermissions(this.settingsPath, this.basePath);
         try {
-          const content = fs19.readFileSync(this.settingsPath, "utf-8");
+          const content = fs21.readFileSync(this.settingsPath, "utf-8");
           this.cache = JSON.parse(content);
           return this.cache;
         } catch {
@@ -3263,9 +4317,7 @@ var init_settings_manager = __esm({
         }
       }
       writeFile(data) {
-        const dir = path18.dirname(this.settingsPath);
-        fs19.mkdirSync(dir, { recursive: true });
-        fs19.writeFileSync(this.settingsPath, JSON.stringify(data, null, 2));
+        atomicSettingsWrite(this.settingsPath, this.basePath, data);
         this.cache = data;
       }
       async get(key) {
@@ -3307,20 +4359,20 @@ __export(command_ownership_store_exports, {
   telegramCommandHostId: () => telegramCommandHostId,
   telegramCommandInstanceKey: () => telegramCommandInstanceKey
 });
-import fs20 from "fs";
-import path19 from "path";
+import fs22 from "fs";
+import path21 from "path";
 import os5 from "os";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function telegramCommandHostId() {
   let source = `${os5.hostname()}|${typeof process.getuid === "function" ? process.getuid() : "unknown"}`;
   try {
-    source = fs20.readFileSync("/etc/machine-id", "utf8").trim() || source;
+    source = fs22.readFileSync("/etc/machine-id", "utf8").trim() || source;
   } catch {
   }
-  return createHash2("sha256").update(source).digest("hex");
+  return createHash4("sha256").update(source).digest("hex");
 }
 function telegramCommandInstanceKey(instanceRoot) {
-  return createHash2("sha256").update(path19.resolve(instanceRoot)).digest("hex");
+  return createHash4("sha256").update(path21.resolve(instanceRoot)).digest("hex");
 }
 function emptyLedger() {
   return { version: STORE_VERSION, bots: {} };
@@ -3368,21 +4420,21 @@ var init_command_ownership_store = __esm({
       file;
       lockFile;
       constructor(instanceRoot) {
-        this.file = path19.join(instanceRoot, "telegram-command-ownership.json");
+        this.file = path21.join(instanceRoot, "telegram-command-ownership.json");
         this.lockFile = `${this.file}.lock`;
       }
       async withLock(operation) {
-        fs20.mkdirSync(path19.dirname(this.file), { recursive: true, mode: 448 });
+        fs22.mkdirSync(path21.dirname(this.file), { recursive: true, mode: 448 });
         const deadline = Date.now() + 1e4;
         let fd;
         while (fd === void 0) {
           try {
-            fd = fs20.openSync(this.lockFile, "wx", 384);
-            fs20.writeFileSync(fd, String(process.pid));
+            fd = fs22.openSync(this.lockFile, "wx", 384);
+            fs22.writeFileSync(fd, String(process.pid));
           } catch (error) {
             if (error.code !== "EEXIST") throw error;
             try {
-              const owner = Number(fs20.readFileSync(this.lockFile, "utf8"));
+              const owner = Number(fs22.readFileSync(this.lockFile, "utf8"));
               let alive = Number.isSafeInteger(owner) && owner > 0;
               if (alive) {
                 try {
@@ -3391,34 +4443,34 @@ var init_command_ownership_store = __esm({
                   alive = false;
                 }
               }
-              if (!alive) fs20.unlinkSync(this.lockFile);
+              if (!alive) fs22.unlinkSync(this.lockFile);
             } catch {
             }
             if (Date.now() >= deadline) throw new Error("Timed out waiting for Telegram command ownership lock");
-            await new Promise((resolve7) => setTimeout(resolve7, 50));
+            await new Promise((resolve8) => setTimeout(resolve8, 50));
           }
         }
         try {
           return await operation(this.load());
         } finally {
           try {
-            fs20.closeSync(fd);
+            fs22.closeSync(fd);
           } catch {
           }
           try {
-            fs20.unlinkSync(this.lockFile);
+            fs22.unlinkSync(this.lockFile);
           } catch {
           }
         }
       }
       load() {
-        if (!fs20.existsSync(this.file)) return { ledger: emptyLedger(), conservative: false };
+        if (!fs22.existsSync(this.file)) return { ledger: emptyLedger(), conservative: false };
         try {
-          return { ledger: validateLedger(JSON.parse(fs20.readFileSync(this.file, "utf8"))), conservative: false };
+          return { ledger: validateLedger(JSON.parse(fs22.readFileSync(this.file, "utf8"))), conservative: false };
         } catch {
           const quarantine = `${this.file}.corrupt.${Date.now()}`;
           try {
-            fs20.renameSync(this.file, quarantine);
+            fs22.renameSync(this.file, quarantine);
           } catch {
           }
           return { ledger: emptyLedger(), conservative: true };
@@ -3499,19 +4551,19 @@ var init_command_ownership_store = __esm({
       }
       save(ledger) {
         const clean = validateLedger(ledger);
-        fs20.mkdirSync(path19.dirname(this.file), { recursive: true, mode: 448 });
+        fs22.mkdirSync(path21.dirname(this.file), { recursive: true, mode: 448 });
         const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
-        fs20.writeFileSync(tmp, `${JSON.stringify(clean, null, 2)}
+        fs22.writeFileSync(tmp, `${JSON.stringify(clean, null, 2)}
 `, { mode: 384, flag: "wx" });
-        fs20.chmodSync(tmp, 384);
-        const fd = fs20.openSync(tmp, "r");
-        fs20.fsyncSync(fd);
-        fs20.closeSync(fd);
-        fs20.renameSync(tmp, this.file);
+        fs22.chmodSync(tmp, 384);
+        const fd = fs22.openSync(tmp, "r");
+        fs22.fsyncSync(fd);
+        fs22.closeSync(fd);
+        fs22.renameSync(tmp, this.file);
         try {
-          const dir = fs20.openSync(path19.dirname(this.file), "r");
-          fs20.fsyncSync(dir);
-          fs20.closeSync(dir);
+          const dir = fs22.openSync(path21.dirname(this.file), "r");
+          fs22.fsyncSync(dir);
+          fs22.closeSync(dir);
         } catch {
         }
       }
@@ -3528,8 +4580,8 @@ __export(instance_context_exports, {
   resolveInstanceRoot: () => resolveInstanceRoot,
   resolveRunningInstance: () => resolveRunningInstance
 });
-import path20 from "path";
-import fs21 from "fs";
+import path22 from "path";
+import fs23 from "fs";
 import os6 from "os";
 function createInstanceContext(opts) {
   const { id, root } = opts;
@@ -3538,22 +4590,22 @@ function createInstanceContext(opts) {
     id,
     root,
     paths: {
-      config: path20.join(root, "config.json"),
-      sessions: path20.join(root, "sessions.json"),
-      agents: path20.join(root, "agents.json"),
-      registryCache: path20.join(globalRoot, "cache", "registry-cache.json"),
-      plugins: path20.join(root, "plugins"),
-      pluginsData: path20.join(root, "plugins", "data"),
-      pluginRegistry: path20.join(root, "plugins.json"),
-      logs: path20.join(root, "logs"),
-      pid: path20.join(root, "openacp.pid"),
-      running: path20.join(root, "running"),
-      apiPort: path20.join(root, "api.port"),
-      apiSecret: path20.join(root, "api-secret"),
-      bin: path20.join(globalRoot, "bin"),
-      cache: path20.join(root, "cache"),
-      tunnels: path20.join(root, "tunnels.json"),
-      agentsDir: path20.join(globalRoot, "agents")
+      config: path22.join(root, "config.json"),
+      sessions: path22.join(root, "sessions.json"),
+      agents: path22.join(root, "agents.json"),
+      registryCache: path22.join(globalRoot, "cache", "registry-cache.json"),
+      plugins: path22.join(root, "plugins"),
+      pluginsData: path22.join(root, "plugins", "data"),
+      pluginRegistry: path22.join(root, "plugins.json"),
+      logs: path22.join(root, "logs"),
+      pid: path22.join(root, "openacp.pid"),
+      running: path22.join(root, "running"),
+      apiPort: path22.join(root, "api.port"),
+      apiSecret: path22.join(root, "api-secret"),
+      bin: path22.join(globalRoot, "bin"),
+      cache: path22.join(root, "cache"),
+      tunnels: path22.join(root, "tunnels.json"),
+      agentsDir: path22.join(globalRoot, "agents")
     }
   };
 }
@@ -3562,50 +4614,50 @@ function generateSlug(name) {
   return slug || "openacp";
 }
 function expandHome3(p) {
-  if (p.startsWith("~")) return path20.join(os6.homedir(), p.slice(1));
+  if (p.startsWith("~")) return path22.join(os6.homedir(), p.slice(1));
   return p;
 }
 function resolveInstanceRoot(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const home = os6.homedir();
   const globalRoot = getGlobalRoot();
-  if (opts.dir) return path20.join(expandHome3(opts.dir), ".openacp");
-  if (opts.local) return path20.join(cwd, ".openacp");
-  const cwdRoot = path20.join(cwd, ".openacp");
-  if (fs21.existsSync(path20.join(cwdRoot, "config.json"))) return cwdRoot;
-  let dir = path20.resolve(cwd);
+  if (opts.dir) return path22.join(expandHome3(opts.dir), ".openacp");
+  if (opts.local) return path22.join(cwd, ".openacp");
+  const cwdRoot = path22.join(cwd, ".openacp");
+  if (fs23.existsSync(path22.join(cwdRoot, "config.json"))) return cwdRoot;
+  let dir = path22.resolve(cwd);
   while (true) {
-    const parent = path20.dirname(dir);
+    const parent = path22.dirname(dir);
     if (parent === dir) break;
     dir = parent;
-    const candidate = path20.join(dir, ".openacp");
+    const candidate = path22.join(dir, ".openacp");
     if (candidate === globalRoot) {
       if (dir === home) break;
       continue;
     }
-    if (fs21.existsSync(path20.join(candidate, "config.json"))) return candidate;
+    if (fs23.existsSync(path22.join(candidate, "config.json"))) return candidate;
     if (dir === home) break;
   }
-  if (path20.resolve(cwd) === path20.resolve(home)) {
-    const defaultWs = path20.join(home, "openacp-workspace", ".openacp");
-    if (fs21.existsSync(path20.join(defaultWs, "config.json"))) return defaultWs;
+  if (path22.resolve(cwd) === path22.resolve(home)) {
+    const defaultWs = path22.join(home, "openacp-workspace", ".openacp");
+    if (fs23.existsSync(path22.join(defaultWs, "config.json"))) return defaultWs;
   }
   if (process.env.OPENACP_INSTANCE_ROOT) return process.env.OPENACP_INSTANCE_ROOT;
   return null;
 }
 function getGlobalRoot() {
-  return path20.join(os6.homedir(), ".openacp");
+  return path22.join(os6.homedir(), ".openacp");
 }
 async function resolveRunningInstance(cwd) {
   const globalRoot = getGlobalRoot();
   const home = os6.homedir();
-  let dir = path20.resolve(cwd);
+  let dir = path22.resolve(cwd);
   while (true) {
-    const candidate = path20.join(dir, ".openacp");
-    if (candidate !== globalRoot && fs21.existsSync(candidate)) {
+    const candidate = path22.join(dir, ".openacp");
+    if (candidate !== globalRoot && fs23.existsSync(candidate)) {
       if (await isInstanceRunning(candidate)) return candidate;
     }
-    const parent = path20.dirname(dir);
+    const parent = path22.dirname(dir);
     if (parent === dir) break;
     if (dir === home) break;
     dir = parent;
@@ -3613,9 +4665,9 @@ async function resolveRunningInstance(cwd) {
   return null;
 }
 async function isInstanceRunning(instanceRoot) {
-  const portFile = path20.join(instanceRoot, "api.port");
+  const portFile = path22.join(instanceRoot, "api.port");
   try {
-    const content = fs21.readFileSync(portFile, "utf-8").trim();
+    const content = fs23.readFileSync(portFile, "utf-8").trim();
     const port = parseInt(content, 10);
     if (isNaN(port)) return false;
     const controller = new AbortController();
@@ -3636,7 +4688,7 @@ var init_instance_context = __esm({
 });
 
 // src/core/doctor/checks/telegram.ts
-import * as path21 from "path";
+import * as path23 from "path";
 var BOT_TOKEN_REGEX, telegramCheck;
 var init_telegram = __esm({
   "src/core/doctor/checks/telegram.ts"() {
@@ -3654,7 +4706,7 @@ var init_telegram = __esm({
           return results;
         }
         const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
-        const sm = new SettingsManager2(path21.join(ctx.pluginsDir, "data"));
+        const sm = new SettingsManager2(path23.join(ctx.pluginsDir, "data"));
         const ps = await sm.loadSettings("@openacp/telegram");
         const botToken = ps.botToken;
         const chatId = ps.chatId;
@@ -3814,7 +4866,7 @@ var init_telegram = __esm({
 });
 
 // src/core/doctor/checks/storage.ts
-import * as fs22 from "fs";
+import * as fs24 from "fs";
 var storageCheck;
 var init_storage = __esm({
   "src/core/doctor/checks/storage.ts"() {
@@ -3824,28 +4876,28 @@ var init_storage = __esm({
       order: 4,
       async run(ctx) {
         const results = [];
-        if (!fs22.existsSync(ctx.dataDir)) {
+        if (!fs24.existsSync(ctx.dataDir)) {
           results.push({
             status: "fail",
             message: "Data directory ~/.openacp does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs22.mkdirSync(ctx.dataDir, { recursive: true });
+              fs24.mkdirSync(ctx.dataDir, { recursive: true });
               return { success: true, message: "created directory" };
             }
           });
         } else {
           try {
-            fs22.accessSync(ctx.dataDir, fs22.constants.W_OK);
+            fs24.accessSync(ctx.dataDir, fs24.constants.W_OK);
             results.push({ status: "pass", message: "Data directory exists and writable" });
           } catch {
             results.push({ status: "fail", message: "Data directory not writable" });
           }
         }
-        if (fs22.existsSync(ctx.sessionsPath)) {
+        if (fs24.existsSync(ctx.sessionsPath)) {
           try {
-            const content = fs22.readFileSync(ctx.sessionsPath, "utf-8");
+            const content = fs24.readFileSync(ctx.sessionsPath, "utf-8");
             const data = JSON.parse(content);
             if (typeof data === "object" && data !== null && "sessions" in data) {
               results.push({ status: "pass", message: "Sessions file valid" });
@@ -3856,7 +4908,7 @@ var init_storage = __esm({
                 fixable: true,
                 fixRisk: "risky",
                 fix: async () => {
-                  fs22.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+                  fs24.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
                   return { success: true, message: "reset sessions file" };
                 }
               });
@@ -3868,7 +4920,7 @@ var init_storage = __esm({
               fixable: true,
               fixRisk: "risky",
               fix: async () => {
-                fs22.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
+                fs24.writeFileSync(ctx.sessionsPath, JSON.stringify({ version: 1, sessions: {} }, null, 2));
                 return { success: true, message: "reset sessions file" };
               }
             });
@@ -3876,20 +4928,20 @@ var init_storage = __esm({
         } else {
           results.push({ status: "pass", message: "Sessions file not present yet (created on first session)" });
         }
-        if (!fs22.existsSync(ctx.logsDir)) {
+        if (!fs24.existsSync(ctx.logsDir)) {
           results.push({
             status: "warn",
             message: "Log directory does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs22.mkdirSync(ctx.logsDir, { recursive: true });
+              fs24.mkdirSync(ctx.logsDir, { recursive: true });
               return { success: true, message: "created log directory" };
             }
           });
         } else {
           try {
-            fs22.accessSync(ctx.logsDir, fs22.constants.W_OK);
+            fs24.accessSync(ctx.logsDir, fs24.constants.W_OK);
             results.push({ status: "pass", message: "Log directory exists and writable" });
           } catch {
             results.push({ status: "fail", message: "Log directory not writable" });
@@ -3902,8 +4954,8 @@ var init_storage = __esm({
 });
 
 // src/core/doctor/checks/workspace.ts
-import * as fs23 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path24 from "path";
 var workspaceCheck;
 var init_workspace = __esm({
   "src/core/doctor/checks/workspace.ts"() {
@@ -3913,21 +4965,21 @@ var init_workspace = __esm({
       order: 5,
       async run(ctx) {
         const results = [];
-        const workspace = path22.dirname(ctx.dataDir);
-        if (!fs23.existsSync(workspace)) {
+        const workspace = path24.dirname(ctx.dataDir);
+        if (!fs25.existsSync(workspace)) {
           results.push({
             status: "warn",
             message: `Workspace directory does not exist: ${workspace}`,
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs23.mkdirSync(workspace, { recursive: true });
+              fs25.mkdirSync(workspace, { recursive: true });
               return { success: true, message: "created directory" };
             }
           });
         } else {
           try {
-            fs23.accessSync(workspace, fs23.constants.W_OK);
+            fs25.accessSync(workspace, fs25.constants.W_OK);
             results.push({ status: "pass", message: `Workspace directory exists: ${workspace}` });
           } catch {
             results.push({ status: "fail", message: `Workspace directory not writable: ${workspace}` });
@@ -3940,8 +4992,8 @@ var init_workspace = __esm({
 });
 
 // src/core/doctor/checks/plugins.ts
-import * as fs24 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path25 from "path";
 var pluginsCheck;
 var init_plugins = __esm({
   "src/core/doctor/checks/plugins.ts"() {
@@ -3951,16 +5003,16 @@ var init_plugins = __esm({
       order: 6,
       async run(ctx) {
         const results = [];
-        if (!fs24.existsSync(ctx.pluginsDir)) {
+        if (!fs26.existsSync(ctx.pluginsDir)) {
           results.push({
             status: "warn",
             message: "Plugins directory does not exist",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs24.mkdirSync(ctx.pluginsDir, { recursive: true });
-              fs24.writeFileSync(
-                path23.join(ctx.pluginsDir, "package.json"),
+              fs26.mkdirSync(ctx.pluginsDir, { recursive: true });
+              fs26.writeFileSync(
+                path25.join(ctx.pluginsDir, "package.json"),
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
               return { success: true, message: "initialized plugins directory" };
@@ -3969,15 +5021,15 @@ var init_plugins = __esm({
           return results;
         }
         results.push({ status: "pass", message: "Plugins directory exists" });
-        const pkgPath = path23.join(ctx.pluginsDir, "package.json");
-        if (!fs24.existsSync(pkgPath)) {
+        const pkgPath = path25.join(ctx.pluginsDir, "package.json");
+        if (!fs26.existsSync(pkgPath)) {
           results.push({
             status: "warn",
             message: "Plugins package.json missing",
             fixable: true,
             fixRisk: "safe",
             fix: async () => {
-              fs24.writeFileSync(
+              fs26.writeFileSync(
                 pkgPath,
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
@@ -3987,7 +5039,7 @@ var init_plugins = __esm({
           return results;
         }
         try {
-          const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf-8"));
+          const pkg = JSON.parse(fs26.readFileSync(pkgPath, "utf-8"));
           const deps = pkg.dependencies || {};
           const count = Object.keys(deps).length;
           results.push({ status: "pass", message: `Plugins package.json valid (${count} plugins)` });
@@ -3998,7 +5050,7 @@ var init_plugins = __esm({
             fixable: true,
             fixRisk: "risky",
             fix: async () => {
-              fs24.writeFileSync(
+              fs26.writeFileSync(
                 pkgPath,
                 JSON.stringify({ name: "openacp-plugins", private: true, dependencies: {} }, null, 2)
               );
@@ -4013,7 +5065,7 @@ var init_plugins = __esm({
 });
 
 // src/core/doctor/checks/daemon.ts
-import * as fs25 from "fs";
+import * as fs27 from "fs";
 import * as net3 from "net";
 function isProcessAlive(pid) {
   try {
@@ -4024,12 +5076,12 @@ function isProcessAlive(pid) {
   }
 }
 function checkPortInUse(port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const server = net3.createServer();
-    server.once("error", () => resolve7(true));
+    server.once("error", () => resolve8(true));
     server.once("listening", () => {
       server.close();
-      resolve7(false);
+      resolve8(false);
     });
     server.listen(port, "127.0.0.1");
   });
@@ -4043,8 +5095,8 @@ var init_daemon = __esm({
       order: 7,
       async run(ctx) {
         const results = [];
-        if (fs25.existsSync(ctx.pidPath)) {
-          const content = fs25.readFileSync(ctx.pidPath, "utf-8").trim();
+        if (fs27.existsSync(ctx.pidPath)) {
+          const content = fs27.readFileSync(ctx.pidPath, "utf-8").trim();
           const pid = parseInt(content, 10);
           if (isNaN(pid)) {
             results.push({
@@ -4053,7 +5105,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs25.unlinkSync(ctx.pidPath);
+                fs27.unlinkSync(ctx.pidPath);
                 return { success: true, message: "removed invalid PID file" };
               }
             });
@@ -4064,7 +5116,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs25.unlinkSync(ctx.pidPath);
+                fs27.unlinkSync(ctx.pidPath);
                 return { success: true, message: "removed stale PID file" };
               }
             });
@@ -4072,8 +5124,8 @@ var init_daemon = __esm({
             results.push({ status: "pass", message: `Daemon running (PID ${pid})` });
           }
         }
-        if (fs25.existsSync(ctx.portFilePath)) {
-          const content = fs25.readFileSync(ctx.portFilePath, "utf-8").trim();
+        if (fs27.existsSync(ctx.portFilePath)) {
+          const content = fs27.readFileSync(ctx.portFilePath, "utf-8").trim();
           const port = parseInt(content, 10);
           if (isNaN(port)) {
             results.push({
@@ -4082,7 +5134,7 @@ var init_daemon = __esm({
               fixable: true,
               fixRisk: "safe",
               fix: async () => {
-                fs25.unlinkSync(ctx.portFilePath);
+                fs27.unlinkSync(ctx.portFilePath);
                 return { success: true, message: "removed invalid port file" };
               }
             });
@@ -4094,8 +5146,8 @@ var init_daemon = __esm({
           const apiPort = 21420;
           const inUse = await checkPortInUse(apiPort);
           if (inUse) {
-            if (fs25.existsSync(ctx.pidPath)) {
-              const pid = parseInt(fs25.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
+            if (fs27.existsSync(ctx.pidPath)) {
+              const pid = parseInt(fs27.readFileSync(ctx.pidPath, "utf-8").trim(), 10);
               if (!isNaN(pid) && isProcessAlive(pid)) {
                 results.push({ status: "pass", message: `API port ${apiPort} in use by OpenACP daemon` });
               } else {
@@ -4115,17 +5167,17 @@ var init_daemon = __esm({
 });
 
 // src/core/utils/install-binary.ts
-import fs26 from "fs";
-import path24 from "path";
+import fs28 from "fs";
+import path26 from "path";
 import https from "https";
 import os7 from "os";
 import { execFileSync as execFileSync4 } from "child_process";
 function downloadFile(url, dest, maxRedirects = 10) {
-  return new Promise((resolve7, reject) => {
-    const file = fs26.createWriteStream(dest);
+  return new Promise((resolve8, reject) => {
+    const file = fs28.createWriteStream(dest);
     const cleanup = () => {
       try {
-        if (fs26.existsSync(dest)) fs26.unlinkSync(dest);
+        if (fs28.existsSync(dest)) fs28.unlinkSync(dest);
       } catch {
       }
     };
@@ -4140,7 +5192,7 @@ function downloadFile(url, dest, maxRedirects = 10) {
         }
         file.close(() => {
           cleanup();
-          downloadFile(response.headers.location, dest, maxRedirects - 1).then(resolve7).catch(reject);
+          downloadFile(response.headers.location, dest, maxRedirects - 1).then(resolve8).catch(reject);
         });
         return;
       }
@@ -4164,7 +5216,7 @@ function downloadFile(url, dest, maxRedirects = 10) {
         }
       });
       response.pipe(file);
-      file.on("finish", () => file.close(() => resolve7(dest)));
+      file.on("finish", () => file.close(() => resolve8(dest)));
       file.on("error", (err) => {
         file.close(() => {
           cleanup();
@@ -4191,36 +5243,36 @@ function getDownloadUrl(spec) {
 async function ensureBinary(spec, binDir) {
   const resolvedBinDir = binDir ?? DEFAULT_BIN_DIR;
   const binName = IS_WINDOWS ? `${spec.name}.exe` : spec.name;
-  const binPath = path24.join(resolvedBinDir, binName);
+  const binPath = path26.join(resolvedBinDir, binName);
   if (commandExists(spec.name)) {
     log19.debug({ name: spec.name }, "Found in PATH");
     return spec.name;
   }
-  if (fs26.existsSync(binPath)) {
-    if (!IS_WINDOWS) fs26.chmodSync(binPath, "755");
+  if (fs28.existsSync(binPath)) {
+    if (!IS_WINDOWS) fs28.chmodSync(binPath, "755");
     log19.debug({ name: spec.name, path: binPath }, "Found in ~/.openacp/bin");
     return binPath;
   }
   log19.info({ name: spec.name }, "Not found, downloading from GitHub...");
-  fs26.mkdirSync(resolvedBinDir, { recursive: true });
+  fs28.mkdirSync(resolvedBinDir, { recursive: true });
   const url = getDownloadUrl(spec);
   const isArchive = spec.isArchive?.(url) ?? false;
-  const downloadDest = isArchive ? path24.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
+  const downloadDest = isArchive ? path26.join(resolvedBinDir, `${spec.name}.tgz`) : binPath;
   await downloadFile(url, downloadDest);
   if (isArchive) {
     const listing = execFileSync4("tar", ["-tf", downloadDest], { stdio: "pipe" }).toString().trim().split("\n").filter(Boolean);
     validateTarContents(listing, resolvedBinDir);
     execFileSync4("tar", ["-xzf", downloadDest, "-C", resolvedBinDir], { stdio: "pipe" });
     try {
-      fs26.unlinkSync(downloadDest);
+      fs28.unlinkSync(downloadDest);
     } catch {
     }
   }
-  if (!fs26.existsSync(binPath)) {
+  if (!fs28.existsSync(binPath)) {
     throw new Error(`${spec.name}: binary not found at ${binPath} after download/extraction. The archive structure may have changed.`);
   }
   if (!IS_WINDOWS) {
-    fs26.chmodSync(binPath, "755");
+    fs28.chmodSync(binPath, "755");
   }
   log19.info({ name: spec.name, path: binPath }, "Installed successfully");
   return binPath;
@@ -4233,7 +5285,7 @@ var init_install_binary = __esm({
     init_agent_dependencies();
     init_agent_installer();
     log19 = createChildLogger({ module: "binary-installer" });
-    DEFAULT_BIN_DIR = path24.join(os7.homedir(), ".openacp", "bin");
+    DEFAULT_BIN_DIR = path26.join(os7.homedir(), ".openacp", "bin");
     IS_WINDOWS = os7.platform() === "win32";
   }
 });
@@ -4274,8 +5326,8 @@ var init_install_cloudflared = __esm({
 });
 
 // src/core/doctor/checks/tunnel.ts
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs29 from "fs";
+import * as path27 from "path";
 import * as os8 from "os";
 import { execFileSync as execFileSync5 } from "child_process";
 var tunnelCheck;
@@ -4292,7 +5344,7 @@ var init_tunnel = __esm({
           return results;
         }
         const { SettingsManager: SettingsManager2 } = await Promise.resolve().then(() => (init_settings_manager(), settings_manager_exports));
-        const sm = new SettingsManager2(path25.join(ctx.pluginsDir, "data"));
+        const sm = new SettingsManager2(path27.join(ctx.pluginsDir, "data"));
         const tunnelSettings = await sm.loadSettings("@openacp/tunnel");
         const tunnelEnabled = tunnelSettings.enabled ?? false;
         const provider = tunnelSettings.provider ?? "cloudflare";
@@ -4304,9 +5356,9 @@ var init_tunnel = __esm({
         results.push({ status: "pass", message: `Tunnel provider: ${provider}` });
         if (provider === "cloudflare") {
           const binName = os8.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-          const binPath = path25.join(ctx.dataDir, "bin", binName);
+          const binPath = path27.join(ctx.dataDir, "bin", binName);
           let found = false;
-          if (fs27.existsSync(binPath)) {
+          if (fs29.existsSync(binPath)) {
             found = true;
           } else {
             try {
@@ -4380,8 +5432,8 @@ var init_proxy = __esm({
 });
 
 // src/core/doctor/index.ts
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs30 from "fs";
+import * as path28 from "path";
 var ALL_CHECKS, CHECK_TIMEOUT_MS, DoctorEngine;
 var init_doctor = __esm({
   "src/core/doctor/index.ts"() {
@@ -4474,27 +5526,27 @@ var init_doctor = __esm({
       /** Constructs the shared context used by all checks — loads config if available. */
       async buildContext() {
         const dataDir = this.dataDir;
-        const configPath = process.env.OPENACP_CONFIG_PATH || path26.join(dataDir, "config.json");
+        const configPath = process.env.OPENACP_CONFIG_PATH || path28.join(dataDir, "config.json");
         let config = null;
         let rawConfig = null;
         try {
-          const content = fs28.readFileSync(configPath, "utf-8");
+          const content = fs30.readFileSync(configPath, "utf-8");
           rawConfig = JSON.parse(content);
           const cm = new ConfigManager(configPath);
           await cm.load();
           config = cm.get();
         } catch {
         }
-        const logsDir = config ? expandHome2(config.logging.logDir) : path26.join(dataDir, "logs");
+        const logsDir = config ? expandHome2(config.logging.logDir) : path28.join(dataDir, "logs");
         return {
           config,
           rawConfig,
           configPath,
           dataDir,
-          sessionsPath: path26.join(dataDir, "sessions.json"),
-          pidPath: path26.join(dataDir, "openacp.pid"),
-          portFilePath: path26.join(dataDir, "api.port"),
-          pluginsDir: path26.join(dataDir, "plugins"),
+          sessionsPath: path28.join(dataDir, "sessions.json"),
+          pidPath: path28.join(dataDir, "openacp.pid"),
+          portFilePath: path28.join(dataDir, "api.port"),
+          pluginsDir: path28.join(dataDir, "plugins"),
           logsDir,
           fetchForScope: (scope) => this.proxyService.createFetch(scope)
         };
@@ -4504,12 +5556,12 @@ var init_doctor = __esm({
 });
 
 // src/core/instance/instance-registry.ts
-import fs30 from "fs";
-import path28 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+import fs32 from "fs";
+import path30 from "path";
+import { randomUUID as randomUUID5 } from "crypto";
 function readIdFromConfig(instanceRoot) {
   try {
-    const raw = JSON.parse(fs30.readFileSync(path28.join(instanceRoot, "config.json"), "utf-8"));
+    const raw = JSON.parse(fs32.readFileSync(path30.join(instanceRoot, "config.json"), "utf-8"));
     return typeof raw.id === "string" && raw.id ? raw.id : null;
   } catch {
     return null;
@@ -4528,7 +5580,7 @@ var init_instance_registry = __esm({
       /** Load the registry from disk. If the file is missing or corrupt, starts fresh. */
       load() {
         try {
-          const raw = fs30.readFileSync(this.registryPath, "utf-8");
+          const raw = fs32.readFileSync(this.registryPath, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed.version === 1 && parsed.instances) {
             this.data = parsed;
@@ -4555,9 +5607,9 @@ var init_instance_registry = __esm({
       }
       /** Persist the registry to disk, creating parent directories if needed. */
       save() {
-        const dir = path28.dirname(this.registryPath);
-        fs30.mkdirSync(dir, { recursive: true });
-        fs30.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
+        const dir = path30.dirname(this.registryPath);
+        fs32.mkdirSync(dir, { recursive: true });
+        fs32.writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
       }
       /** Add or update an instance entry in the registry. Does not persist — call save() after. */
       register(id, root) {
@@ -4605,7 +5657,7 @@ var init_instance_registry = __esm({
           this.register(configId, instanceRoot);
           return { id: configId, registryUpdated: true };
         }
-        const id = configId ?? entry?.id ?? randomUUID2();
+        const id = configId ?? entry?.id ?? randomUUID5();
         if (!this.getByRoot(instanceRoot)) {
           this.register(id, instanceRoot);
           return { id, registryUpdated: true };
@@ -4616,67 +5668,6 @@ var init_instance_registry = __esm({
   }
 });
 
-// src/core/plugin/plugin-installer.ts
-var plugin_installer_exports = {};
-__export(plugin_installer_exports, {
-  importFromDir: () => importFromDir,
-  installNpmPlugin: () => installNpmPlugin
-});
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-import * as fs32 from "fs/promises";
-import * as path30 from "path";
-import { pathToFileURL } from "url";
-async function importFromDir(packageName, dir) {
-  const pkgDir = path30.join(dir, "node_modules", ...packageName.split("/"));
-  const pkgJsonPath = path30.join(pkgDir, "package.json");
-  let pkgJson;
-  try {
-    pkgJson = JSON.parse(await fs32.readFile(pkgJsonPath, "utf-8"));
-  } catch (err) {
-    throw new Error(`Cannot read package.json for "${packageName}" at ${pkgJsonPath}: ${err.message}`);
-  }
-  let entry;
-  const exportsMain = pkgJson.exports?.["."];
-  if (typeof exportsMain === "string") {
-    entry = exportsMain;
-  } else if (exportsMain?.import) {
-    entry = exportsMain.import;
-  } else {
-    entry = pkgJson.main ?? "index.js";
-  }
-  const entryPath = path30.join(pkgDir, entry);
-  try {
-    await fs32.access(entryPath);
-  } catch {
-    throw new Error(`Entry point "${entry}" not found for "${packageName}" at ${entryPath}`);
-  }
-  return import(pathToFileURL(entryPath).href);
-}
-async function installNpmPlugin(packageName, pluginsDir, childEnv) {
-  if (!VALID_NPM_NAME.test(packageName)) {
-    throw new Error(`Invalid package name: "${packageName}". Must be a valid npm package name.`);
-  }
-  const dir = pluginsDir;
-  try {
-    return await importFromDir(packageName, dir);
-  } catch {
-  }
-  await execFileAsync2("npm", ["install", packageName, "--prefix", dir, "--save", "--ignore-scripts"], {
-    timeout: 6e4,
-    env: childEnv
-  });
-  return await importFromDir(packageName, dir);
-}
-var execFileAsync2, VALID_NPM_NAME;
-var init_plugin_installer = __esm({
-  "src/core/plugin/plugin-installer.ts"() {
-    "use strict";
-    execFileAsync2 = promisify2(execFile2);
-    VALID_NPM_NAME = /^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(@[\w.^~>=<|-]+)?$/i;
-  }
-});
-
 // src/core/plugin/terminal-io.ts
 import * as clack from "@clack/prompts";
 function isCancel(value) {
@@ -4740,10 +5731,10 @@ var install_context_exports = {};
 __export(install_context_exports, {
   createInstallContext: () => createInstallContext
 });
-import path31 from "path";
+import path32 from "path";
 function createInstallContext(opts) {
   const { pluginName, settingsManager, basePath, instanceRoot } = opts;
-  const dataDir = path31.join(basePath, pluginName, "data");
+  const dataDir = path32.join(basePath, pluginName, "data");
   return {
     pluginName,
     terminal: createTerminalIO(),
@@ -4771,14 +5762,14 @@ __export(api_client_exports, {
   waitForApiReady: () => waitForApiReady,
   waitForPortFile: () => waitForPortFile
 });
-import * as fs33 from "fs";
-import * as path32 from "path";
+import * as fs34 from "fs";
+import * as path33 from "path";
 import { setTimeout as sleep } from "timers/promises";
 function defaultPortFile(root) {
-  return path32.join(root, "api.port");
+  return path33.join(root, "api.port");
 }
 function defaultSecretFile(root) {
-  return path32.join(root, "api-secret");
+  return path33.join(root, "api-secret");
 }
 async function waitForPortFile(portFilePath, timeoutMs = 5e3, intervalMs = 100) {
   const deadline = Date.now() + timeoutMs;
@@ -4812,7 +5803,7 @@ async function waitForApiReady(instanceRoot, expectedInstanceId, timeoutMs = 1e4
 function readApiPort(portFilePath, instanceRoot) {
   const filePath = portFilePath ?? defaultPortFile(instanceRoot);
   try {
-    const content = fs33.readFileSync(filePath, "utf-8").trim();
+    const content = fs34.readFileSync(filePath, "utf-8").trim();
     const port = parseInt(content, 10);
     return isNaN(port) ? null : port;
   } catch {
@@ -4822,7 +5813,7 @@ function readApiPort(portFilePath, instanceRoot) {
 function readApiSecret(secretFilePath, instanceRoot) {
   const filePath = secretFilePath ?? defaultSecretFile(instanceRoot);
   try {
-    const content = fs33.readFileSync(filePath, "utf-8").trim();
+    const content = fs34.readFileSync(filePath, "utf-8").trim();
     return content || null;
   } catch {
     return null;
@@ -4831,7 +5822,7 @@ function readApiSecret(secretFilePath, instanceRoot) {
 function removeStalePortFile(portFilePath, instanceRoot) {
   const filePath = portFilePath ?? defaultPortFile(instanceRoot);
   try {
-    fs33.unlinkSync(filePath);
+    fs34.unlinkSync(filePath);
   } catch {
   }
 }
@@ -4968,8 +5959,8 @@ var init_notification = __esm({
 });
 
 // src/plugins/file-service/file-service.ts
-import fs35 from "fs";
-import path35 from "path";
+import fs36 from "fs";
+import path36 from "path";
 import { OggOpusDecoder } from "ogg-opus-decoder";
 import wav from "node-wav";
 function classifyMime(mimeType) {
@@ -5026,14 +6017,14 @@ var init_file_service = __esm({
         const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
         let removed = 0;
         try {
-          const entries = await fs35.promises.readdir(this.baseDir, { withFileTypes: true });
+          const entries = await fs36.promises.readdir(this.baseDir, { withFileTypes: true });
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
-            const dirPath = path35.join(this.baseDir, entry.name);
+            const dirPath = path36.join(this.baseDir, entry.name);
             try {
-              const stat = await fs35.promises.stat(dirPath);
+              const stat = await fs36.promises.stat(dirPath);
               if (stat.mtimeMs < cutoff) {
-                await fs35.promises.rm(dirPath, { recursive: true, force: true });
+                await fs36.promises.rm(dirPath, { recursive: true, force: true });
                 removed++;
               }
             } catch {
@@ -5052,11 +6043,11 @@ var init_file_service = __esm({
        * so the user-facing name is not lost.
        */
       async saveFile(sessionId, fileName, data, mimeType) {
-        const sessionDir = path35.join(this.baseDir, sessionId);
-        await fs35.promises.mkdir(sessionDir, { recursive: true });
+        const sessionDir = path36.join(this.baseDir, sessionId);
+        await fs36.promises.mkdir(sessionDir, { recursive: true });
         const safeName = `${Date.now()}-${fileName.replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-        const filePath = path35.join(sessionDir, safeName);
-        await fs35.promises.writeFile(filePath, data);
+        const filePath = path36.join(sessionDir, safeName);
+        await fs36.promises.writeFile(filePath, data);
         return {
           type: classifyMime(mimeType),
           filePath,
@@ -5071,14 +6062,14 @@ var init_file_service = __esm({
        */
       async resolveFile(filePath) {
         try {
-          const stat = await fs35.promises.stat(filePath);
+          const stat = await fs36.promises.stat(filePath);
           if (!stat.isFile()) return null;
-          const ext = path35.extname(filePath).toLowerCase();
+          const ext = path36.extname(filePath).toLowerCase();
           const mimeType = EXT_TO_MIME[ext] || "application/octet-stream";
           return {
             type: classifyMime(mimeType),
             filePath,
-            fileName: path35.basename(filePath),
+            fileName: path36.basename(filePath),
             mimeType,
             size: stat.size
           };
@@ -5721,8 +6712,8 @@ data: ${JSON.stringify(data)}
 });
 
 // src/plugins/api-server/static-server.ts
-import * as fs36 from "fs";
-import * as path36 from "path";
+import * as fs37 from "fs";
+import * as path37 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var MIME_TYPES, StaticServer;
 var init_static_server = __esm({
@@ -5746,16 +6737,16 @@ var init_static_server = __esm({
         this.uiDir = uiDir;
         if (!this.uiDir) {
           const __filename = fileURLToPath2(import.meta.url);
-          const candidate = path36.resolve(path36.dirname(__filename), "../../ui/dist");
-          if (fs36.existsSync(path36.join(candidate, "index.html"))) {
+          const candidate = path37.resolve(path37.dirname(__filename), "../../ui/dist");
+          if (fs37.existsSync(path37.join(candidate, "index.html"))) {
             this.uiDir = candidate;
           }
           if (!this.uiDir) {
-            const publishCandidate = path36.resolve(
-              path36.dirname(__filename),
+            const publishCandidate = path37.resolve(
+              path37.dirname(__filename),
               "../ui"
             );
-            if (fs36.existsSync(path36.join(publishCandidate, "index.html"))) {
+            if (fs37.existsSync(path37.join(publishCandidate, "index.html"))) {
               this.uiDir = publishCandidate;
             }
           }
@@ -5773,23 +6764,23 @@ var init_static_server = __esm({
       serve(req, res) {
         if (!this.uiDir) return false;
         const urlPath = (req.url || "/").split("?")[0];
-        const safePath = path36.normalize(urlPath);
-        const filePath = path36.join(this.uiDir, safePath);
-        if (!filePath.startsWith(this.uiDir + path36.sep) && filePath !== this.uiDir)
+        const safePath = path37.normalize(urlPath);
+        const filePath = path37.join(this.uiDir, safePath);
+        if (!filePath.startsWith(this.uiDir + path37.sep) && filePath !== this.uiDir)
           return false;
         let realFilePath;
         try {
-          realFilePath = fs36.realpathSync(filePath);
+          realFilePath = fs37.realpathSync(filePath);
         } catch {
           realFilePath = null;
         }
         if (realFilePath !== null) {
-          const realUiDir = fs36.realpathSync(this.uiDir);
-          if (!realFilePath.startsWith(realUiDir + path36.sep) && realFilePath !== realUiDir)
+          const realUiDir = fs37.realpathSync(this.uiDir);
+          if (!realFilePath.startsWith(realUiDir + path37.sep) && realFilePath !== realUiDir)
             return false;
         }
-        if (realFilePath !== null && fs36.existsSync(realFilePath) && fs36.statSync(realFilePath).isFile()) {
-          const ext = path36.extname(filePath);
+        if (realFilePath !== null && fs37.existsSync(realFilePath) && fs37.statSync(realFilePath).isFile()) {
+          const ext = path37.extname(filePath);
           const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
           const isHashed = /\.[a-zA-Z0-9]{8,}\.(js|css)$/.test(filePath);
           const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "no-cache";
@@ -5797,16 +6788,16 @@ var init_static_server = __esm({
             "Content-Type": contentType,
             "Cache-Control": cacheControl
           });
-          fs36.createReadStream(realFilePath).pipe(res);
+          fs37.createReadStream(realFilePath).pipe(res);
           return true;
         }
-        const indexPath = path36.join(this.uiDir, "index.html");
-        if (fs36.existsSync(indexPath)) {
+        const indexPath = path37.join(this.uiDir, "index.html");
+        if (fs37.existsSync(indexPath)) {
           res.writeHead(200, {
             "Content-Type": "text/html; charset=utf-8",
             "Cache-Control": "no-cache"
           });
-          fs36.createReadStream(indexPath).pipe(res);
+          fs37.createReadStream(indexPath).pipe(res);
           return true;
         }
         return false;
@@ -5828,6 +6819,8 @@ var init_speech_service = __esm({
       sttProviders = /* @__PURE__ */ new Map();
       ttsProviders = /* @__PURE__ */ new Map();
       providerFactory;
+      factoryOwnedSTT = /* @__PURE__ */ new Set();
+      factoryOwnedTTS = /* @__PURE__ */ new Set();
       /** Set a factory function that can recreate providers from config (for hot-reload) */
       setProviderFactory(factory) {
         this.providerFactory = factory;
@@ -5835,10 +6828,12 @@ var init_speech_service = __esm({
       /** Register an STT provider by name. Overwrites any existing provider with the same name. */
       registerSTTProvider(name, provider) {
         this.sttProviders.set(name, provider);
+        this.factoryOwnedSTT.delete(name);
       }
       /** Register a TTS provider by name. Called by external TTS plugins (e.g. msedge-tts-plugin). */
       registerTTSProvider(name, provider) {
         this.ttsProviders.set(name, provider);
+        this.factoryOwnedTTS.delete(name);
       }
       /** Remove a TTS provider — called by external plugins on teardown. */
       unregisterTTSProvider(name) {
@@ -5903,16 +6898,22 @@ var init_speech_service = __esm({
        * (e.g. from `@openacp/msedge-tts-plugin`) are preserved rather than discarded.
        */
       refreshProviders(newConfig) {
-        this.config = newConfig;
-        if (this.providerFactory) {
-          const { stt, tts } = this.providerFactory(newConfig);
-          for (const [name, provider] of stt) {
-            this.sttProviders.set(name, provider);
-          }
-          for (const [name, provider] of tts) {
-            this.ttsProviders.set(name, provider);
-          }
+        if (!this.providerFactory) {
+          this.config = newConfig;
+          return;
         }
+        const built = this.providerFactory(newConfig);
+        const nextSTT = new Map(this.sttProviders);
+        const nextTTS = new Map(this.ttsProviders);
+        for (const name of this.factoryOwnedSTT) nextSTT.delete(name);
+        for (const name of this.factoryOwnedTTS) nextTTS.delete(name);
+        for (const [name, provider] of built.stt) nextSTT.set(name, provider);
+        for (const [name, provider] of built.tts) nextTTS.set(name, provider);
+        this.config = newConfig;
+        this.sttProviders = nextSTT;
+        this.ttsProviders = nextTTS;
+        this.factoryOwnedSTT = new Set(built.stt.keys());
+        this.factoryOwnedTTS = new Set(built.tts.keys());
       }
     };
   }
@@ -5929,8 +6930,8 @@ var init_exports = __esm({
 });
 
 // src/plugins/context/context-cache.ts
-import * as fs37 from "fs";
-import * as path37 from "path";
+import * as fs38 from "fs";
+import * as path38 from "path";
 import * as crypto2 from "crypto";
 var DEFAULT_TTL_MS, ContextCache;
 var init_context_cache = __esm({
@@ -5941,7 +6942,7 @@ var init_context_cache = __esm({
       constructor(cacheDir, ttlMs = DEFAULT_TTL_MS) {
         this.cacheDir = cacheDir;
         this.ttlMs = ttlMs;
-        fs37.mkdirSync(cacheDir, { recursive: true });
+        fs38.mkdirSync(cacheDir, { recursive: true });
       }
       cacheDir;
       ttlMs;
@@ -5949,23 +6950,23 @@ var init_context_cache = __esm({
         return crypto2.createHash("sha256").update(`${repoPath}:${queryKey}`).digest("hex").slice(0, 16);
       }
       filePath(repoPath, queryKey) {
-        return path37.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
+        return path38.join(this.cacheDir, `${this.keyHash(repoPath, queryKey)}.json`);
       }
       get(repoPath, queryKey) {
         const fp = this.filePath(repoPath, queryKey);
         try {
-          const stat = fs37.statSync(fp);
+          const stat = fs38.statSync(fp);
           if (Date.now() - stat.mtimeMs > this.ttlMs) {
-            fs37.unlinkSync(fp);
+            fs38.unlinkSync(fp);
             return null;
           }
-          return JSON.parse(fs37.readFileSync(fp, "utf-8"));
+          return JSON.parse(fs38.readFileSync(fp, "utf-8"));
         } catch {
           return null;
         }
       }
       set(repoPath, queryKey, result) {
-        fs37.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
+        fs38.writeFileSync(this.filePath(repoPath, queryKey), JSON.stringify(result));
       }
     };
   }
@@ -6939,8 +7940,8 @@ function formatToolSummary(name, rawInput, displaySummary) {
   }
   if (lowerName === "grep") {
     const pattern = args.pattern ?? "";
-    const path38 = args.path ?? "";
-    return pattern ? `\u{1F50D} Grep "${pattern}"${path38 ? ` in ${path38}` : ""}` : `\u{1F527} ${name}`;
+    const path39 = args.path ?? "";
+    return pattern ? `\u{1F50D} Grep "${pattern}"${path39 ? ` in ${path39}` : ""}` : `\u{1F527} ${name}`;
   }
   if (lowerName === "glob") {
     const pattern = args.pattern ?? "";
@@ -6976,8 +7977,8 @@ function formatToolTitle(name, rawInput, displayTitle) {
   }
   if (lowerName === "grep") {
     const pattern = args.pattern ?? "";
-    const path38 = args.path ?? "";
-    return pattern ? `"${pattern}"${path38 ? ` in ${path38}` : ""}` : name;
+    const path39 = args.path ?? "";
+    return pattern ? `"${pattern}"${path39 ? ` in ${path39}` : ""}` : name;
   }
   if (lowerName === "glob") {
     return String(args.pattern ?? name);
@@ -7398,10 +8399,10 @@ var init_send_queue = __esm({
         const type = opts?.type ?? "other";
         const key = opts?.key;
         const category = opts?.category;
-        let resolve7;
+        let resolve8;
         let reject;
         const promise = new Promise((res, rej) => {
-          resolve7 = res;
+          resolve8 = res;
           reject = rej;
         });
         promise.catch(() => {
@@ -7412,12 +8413,12 @@ var init_send_queue = __esm({
           );
           if (idx !== -1) {
             this.items[idx].resolve(void 0);
-            this.items[idx] = { fn, type, key, category, resolve: resolve7, reject, promise };
+            this.items[idx] = { fn, type, key, category, resolve: resolve8, reject, promise };
             this.scheduleProcess();
             return promise;
           }
         }
-        this.items.push({ fn, type, key, category, resolve: resolve7, reject, promise });
+        this.items.push({ fn, type, key, category, resolve: resolve8, reject, promise });
         this.scheduleProcess();
         return promise;
       }
@@ -8153,10 +9154,10 @@ function shortenTitle(title, kind, workingDirectory) {
     const relativized = normalizedPathPart.split(", ").map((segment) => segment.startsWith(prefix) ? segment.slice(prefix.length) : segment).join(", ");
     if (relativized !== normalizedPathPart) return relativized + rangePart;
   }
-  if (FILE_KINDS.has(kind)) return basename(pathPart) + rangePart;
+  if (FILE_KINDS.has(kind)) return basename2(pathPart) + rangePart;
   return title;
 }
-function basename(pathLike) {
+function basename2(pathLike) {
   return pathLike.replace(/\\/g, "/").split("/").pop() || pathLike;
 }
 function renderSpecSection(spec) {
@@ -8193,7 +9194,7 @@ function renderSpecSection(spec) {
   }
   if (spec.viewerLinks?.file || spec.viewerLinks?.diff || spec.outputViewerLink) {
     const linkParts = [];
-    const linkName = basename(displayTitle || kindLabel || spec.kind);
+    const linkName = basename2(displayTitle || kindLabel || spec.kind);
     if (spec.viewerLinks?.file)
       linkParts.push(`<a href="${escapeHtml(spec.viewerLinks.file)}">View ${escapeHtml(linkName)}</a>`);
     if (spec.viewerLinks?.diff)
@@ -8292,7 +9293,7 @@ __export(version_exports, {
   runUpdate: () => runUpdate
 });
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname12, join as join16, resolve as resolve6 } from "path";
+import { dirname as dirname13, join as join16, resolve as resolve7 } from "path";
 import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
 function getUpdateNetwork(instanceRoot) {
   if (!instanceRoot) return {};
@@ -8306,11 +9307,11 @@ function getUpdateNetwork(instanceRoot) {
   };
 }
 function findPackageJson() {
-  let dir = dirname12(fileURLToPath3(import.meta.url));
+  let dir = dirname13(fileURLToPath3(import.meta.url));
   for (let i = 0; i < 5; i++) {
     const candidate = join16(dir, "package.json");
     if (existsSync17(candidate)) return candidate;
-    const parent = resolve6(dir, "..");
+    const parent = resolve7(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -8349,7 +9350,7 @@ function compareVersions(current, latest) {
 }
 async function runUpdate(environment) {
   const { spawn: spawn4 } = await import("child_process");
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const child = spawn4("npm", ["install", "-g", `${NPM_PACKAGE}@latest`], {
       stdio: "inherit",
       shell: false,
@@ -8357,14 +9358,14 @@ async function runUpdate(environment) {
     });
     const onSignal = () => {
       child.kill("SIGTERM");
-      resolve7(false);
+      resolve8(false);
     };
     process.on("SIGINT", onSignal);
     process.on("SIGTERM", onSignal);
     child.on("close", (code) => {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
-      resolve7(code === 0);
+      resolve8(code === 0);
     });
   });
 }
@@ -9196,7 +10197,7 @@ __export(integrate_exports, {
   uninstallIntegration: () => uninstallIntegration
 });
 import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync11, unlinkSync as unlinkSync7, chmodSync, rmdirSync } from "fs";
-import { join as join17, dirname as dirname13 } from "path";
+import { join as join17, dirname as dirname14 } from "path";
 import { homedir as homedir4 } from "os";
 function isHooksIntegrationSpec(spec) {
   return spec.strategy === "hooks";
@@ -9374,7 +10375,7 @@ function mergeSettingsJson(settingsPath, hookEvent, hookScriptPath) {
       hooks: [{ type: "command", command: hookScriptPath }]
     });
   }
-  mkdirSync11(dirname13(fullPath), { recursive: true });
+  mkdirSync11(dirname14(fullPath), { recursive: true });
   writeFileSync11(fullPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
@@ -9393,7 +10394,7 @@ function mergeHooksJson(settingsPath, hookEvent, hookScriptPath) {
   if (!alreadyInstalled) {
     eventHooks.push({ command: hookScriptPath });
   }
-  mkdirSync11(dirname13(fullPath), { recursive: true });
+  mkdirSync11(dirname14(fullPath), { recursive: true });
   writeFileSync11(fullPath, JSON.stringify(config, null, 2) + "\n");
 }
 function removeFromSettingsJson(settingsPath, hookEvent) {
@@ -9619,7 +10620,7 @@ function buildTunnelItem(spec) {
       const logs = [];
       try {
         const skillPath = getTunnelPath();
-        mkdirSync11(dirname13(skillPath), { recursive: true });
+        mkdirSync11(dirname14(skillPath), { recursive: true });
         writeFileSync11(skillPath, generateTunnelCommand());
         logs.push(`Created ${skillPath}`);
         return { success: true, logs };
@@ -9635,7 +10636,7 @@ function buildTunnelItem(spec) {
         if (existsSync18(skillPath)) {
           unlinkSync7(skillPath);
           try {
-            rmdirSync(dirname13(skillPath));
+            rmdirSync(dirname14(skillPath));
           } catch {
           }
           logs.push(`Removed ${skillPath}`);
@@ -10168,6 +11169,7 @@ async function buildSettingsKeyboard(core) {
     }
   }
   kb.text("\u{1F310} Proxy Management", settingsCommandCallback("/proxy")).row();
+  kb.text("\u{1F399} Speech-to-Text", settingsCommandCallback("/speech")).row();
   kb.text("\u25C0\uFE0F Back to Menu", "s:back");
   return kb;
 }
@@ -10255,33 +11257,6 @@ Select a value:`, {
     const fieldDef = getSafeFields().find((f) => f.path === fieldPath);
     if (!fieldDef) return;
     try {
-      if (fieldPath === "speech.stt.provider") {
-        const sm = core.settingsManager;
-        let hasApiKey = false;
-        if (sm) {
-          const speechSettings = await sm.loadSettings("@openacp/speech");
-          hasApiKey = !!speechSettings.groqApiKey;
-        } else {
-          hasApiKey = false;
-        }
-        if (!hasApiKey) {
-          const assistant = getAssistantSession();
-          if (assistant) {
-            try {
-              await ctx.answerCallbackQuery({ text: `\u{1F511} API key needed \u2014 check Assistant topic` });
-            } catch {
-            }
-            const prompt = `User wants to enable ${newValue} as Speech-to-Text provider, but no API key is configured yet. Guide them to get a ${newValue} API key and set it up. After they provide the key, run both commands: \`openacp config set speech.stt.providers.${newValue}.apiKey <key>\` and \`openacp config set speech.stt.provider ${newValue}\``;
-            await assistant.enqueuePrompt(prompt);
-            return;
-          }
-          try {
-            await ctx.answerCallbackQuery({ text: `\u26A0\uFE0F Set API key first: openacp config set speech.stt.providers.${newValue}.apiKey <key>` });
-          } catch {
-          }
-          return;
-        }
-      }
       await setFieldValueAsync(fieldDef, newValue, core.configManager);
       try {
         await ctx.answerCallbackQuery({ text: `\u2705 ${fieldPath} = ${newValue}` });
@@ -11978,7 +12953,7 @@ var init_types = __esm({
 });
 
 // src/core/commands/proxy.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function clearProxyDraftsForChannel(channelId) {
   const prefix = `${channelId}:`;
   for (const [id, draft] of drafts) if (draft.owner.startsWith(prefix)) drafts.delete(id);
@@ -11997,7 +12972,7 @@ var init_proxy2 = __esm({
 });
 
 // src/plugins/telegram/command-sync.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 function validDescription(description) {
   if (typeof description !== "string") return false;
   const trimmed = description.trim();
@@ -12066,7 +13041,7 @@ function localeLabel(locale) {
 async function synchronizeTelegramCommands(api, chatId, desired, options) {
   if (!/^\d{1,20}$/.test(options.botId)) throw new Error("Telegram bot identity is invalid");
   assertTelegramCommandBoundary(desired);
-  const chatKey = createHash4("sha256").update(String(chatId)).digest("hex").slice(0, 16);
+  const chatKey = createHash6("sha256").update(String(chatId)).digest("hex").slice(0, 16);
   const scopes = [
     { name: "default", scope: { type: "default" }, ledgerName: "default" },
     { name: "chat", scope: { type: "chat", chat_id: chatId }, ledgerName: `chat:${chatKey}` },
@@ -13063,11 +14038,11 @@ ${p}` : p;
                   { error: safeError2, attempt, maxAttempts, delayMs, operation: "telegram-command-sync" },
                   "Telegram command menu sync failed, retrying"
                 );
-                await new Promise((resolve7) => {
-                  const timer = setTimeout(resolve7, delayMs);
+                await new Promise((resolve8) => {
+                  const timer = setTimeout(resolve8, delayMs);
                   signal?.addEventListener("abort", () => {
                     clearTimeout(timer);
-                    resolve7();
+                    resolve8();
                   }, { once: true });
                 });
               }
@@ -14361,15 +15336,15 @@ var ChannelAdapter = class {
 function nodeToWebWritable(nodeStream) {
   return new WritableStream({
     write(chunk) {
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve8, reject) => {
         const ok2 = nodeStream.write(chunk);
         if (ok2) {
-          resolve7();
+          resolve8();
           return;
         }
         const onDrain = () => {
           nodeStream.removeListener("error", onError);
-          resolve7();
+          resolve8();
         };
         const onError = (err) => {
           nodeStream.removeListener("drain", onDrain);
@@ -14861,12 +15836,12 @@ var TerminalManager = class {
         signal: state.exitStatus.signal
       };
     }
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       state.process.on("exit", (code, signal) => {
-        resolve7({ exitCode: code, signal });
+        resolve8({ exitCode: code, signal });
       });
       if (state.exitStatus !== null) {
-        resolve7({
+        resolve8({
           exitCode: state.exitStatus.exitCode,
           signal: state.exitStatus.signal
         });
@@ -15148,7 +16123,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
         env: environment ?? filterEnv(process.env, agentDef.env)
       }
     );
-    await new Promise((resolve7, reject) => {
+    await new Promise((resolve8, reject) => {
       instance.child.on("error", (err) => {
         reject(
           new Error(
@@ -15156,7 +16131,7 @@ var AgentInstance = class _AgentInstance extends TypedEmitter {
           )
         );
       });
-      instance.child.on("spawn", () => resolve7());
+      instance.child.on("spawn", () => resolve8());
     });
     instance.stderrCapture = new StderrCapture(50);
     instance.child.stderr.on("data", (chunk) => {
@@ -15783,15 +16758,15 @@ ${skipNote}`;
     this._destroying = true;
     this.terminalManager.destroyAll();
     if (this.child.exitCode !== null) return;
-    await new Promise((resolve7) => {
+    await new Promise((resolve8) => {
       this.child.on("exit", () => {
         clearTimeout(forceKillTimer);
-        resolve7();
+        resolve8();
       });
       this.child.kill("SIGTERM");
       const forceKillTimer = setTimeout(() => {
         if (this.child.exitCode === null) this.child.kill("SIGKILL");
-        resolve7();
+        resolve8();
       }, 1e4);
       if (typeof forceKillTimer === "object" && forceKillTimer !== null && "unref" in forceKillTimer) {
         forceKillTimer.unref();
@@ -15802,7 +16777,7 @@ ${skipNote}`;
 var AGENT_INIT_TIMEOUT_MS = 3e4;
 function withAgentTimeout(promise, agentName, op, timeoutMs) {
   const timeout = timeoutMs ?? AGENT_INIT_TIMEOUT_MS;
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const timer = setTimeout(() => {
       reject(new Error(
         `Agent "${agentName}" did not respond to ${op} within ${timeout / 1e3}s. The agent process may have hung during initialization.`
@@ -15811,7 +16786,7 @@ function withAgentTimeout(promise, agentName, op, timeoutMs) {
     promise.then(
       (val) => {
         clearTimeout(timer);
-        resolve7(val);
+        resolve8(val);
       },
       (err) => {
         clearTimeout(timer);
@@ -16075,8 +17050,8 @@ var PromptQueue = class {
     if (this.processing) {
       const position = this.queue.length + 1;
       this.onActuallyQueued?.(turnId, position, routing);
-      return new Promise((resolve7) => {
-        this.queue.push({ text: text3, userPrompt, attachments, routing, turnId, meta, resolve: resolve7 });
+      return new Promise((resolve8) => {
+        this.queue.push({ text: text3, userPrompt, attachments, routing, turnId, meta, resolve: resolve8 });
       });
     }
     await this.process(text3, userPrompt, attachments, routing, turnId, meta);
@@ -16206,8 +17181,8 @@ var PermissionGate = class {
     this.request = request;
     this.settled = false;
     this.clearTimeout();
-    return new Promise((resolve7, reject) => {
-      this.resolveFn = resolve7;
+    return new Promise((resolve8, reject) => {
+      this.resolveFn = resolve8;
       this.rejectFn = reject;
       this.timeoutTimer = setTimeout(() => {
         this.reject("Permission request timed out (no response received)");
@@ -18123,12 +19098,12 @@ var SessionBridge = class {
         break;
       case "image_content": {
         if (this.deps.fileService) {
-          const fs38 = this.deps.fileService;
+          const fs39 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs38.extensionFromMime(mimeType);
-          fs38.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs39.extensionFromMime(mimeType);
+          fs39.saveFile(sid, `agent-image${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -18140,12 +19115,12 @@ var SessionBridge = class {
       }
       case "audio_content": {
         if (this.deps.fileService) {
-          const fs38 = this.deps.fileService;
+          const fs39 = this.deps.fileService;
           const sid = this.session.id;
           const { data, mimeType } = event;
           const buffer = Buffer.from(data, "base64");
-          const ext = fs38.extensionFromMime(mimeType);
-          fs38.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
+          const ext = fs39.extensionFromMime(mimeType);
+          fs39.saveFile(sid, `agent-audio${ext}`, buffer, mimeType).then((att) => {
             this.sendMessage(sid, {
               type: "attachment",
               text: "",
@@ -18757,7 +19732,7 @@ var SessionFactory = class {
 };
 
 // src/core/core.ts
-import path16 from "path";
+import path18 from "path";
 import { nanoid as nanoid3 } from "nanoid";
 
 // src/core/sessions/session-store.ts
@@ -20192,16 +21167,51 @@ function createPluginContext(opts) {
 
 // src/core/plugin/lifecycle-manager.ts
 init_events();
+init_plugin_installer();
+import fs16 from "fs";
+import path15 from "path";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 var SETUP_TIMEOUT_MS = 3e4;
 var TEARDOWN_TIMEOUT_MS = 1e4;
+function migrationGuardPath(instanceRoot, pluginName) {
+  return path15.join(instanceRoot, "plugin-migration-quarantine", `${createHash3("sha256").update(pluginName).digest("hex")}.json`);
+}
+function writeMigrationGuard(instanceRoot, pluginName, fromVersion, toVersion) {
+  const guardPath = migrationGuardPath(instanceRoot, pluginName);
+  const directory = path15.dirname(guardPath);
+  fs16.mkdirSync(directory, { recursive: true, mode: 448 });
+  fs16.chmodSync(directory, 448);
+  const temporary = `${guardPath}.${process.pid}.${randomUUID3()}.tmp`;
+  try {
+    fs16.writeFileSync(temporary, `${JSON.stringify({ version: 1, pluginName, fromVersion, toVersion, createdAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+`, { flag: "wx", mode: 384 });
+    const fd = fs16.openSync(temporary, "r");
+    fs16.fsyncSync(fd);
+    fs16.closeSync(fd);
+    fs16.renameSync(temporary, guardPath);
+    fs16.chmodSync(guardPath, 384);
+    try {
+      const dir = fs16.openSync(directory, "r");
+      fs16.fsyncSync(dir);
+      fs16.closeSync(dir);
+    } catch {
+    }
+  } finally {
+    try {
+      if (fs16.existsSync(temporary)) fs16.unlinkSync(temporary);
+    } catch {
+    }
+  }
+  return guardPath;
+}
 function withTimeout(promise, ms, label) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const timer = setTimeout(() => reject(new Error(`Timeout: ${label} exceeded ${ms}ms`)), ms);
     if (typeof timer === "object" && timer !== null && "unref" in timer) {
       ;
       timer.unref();
     }
-    promise.then(resolve7, reject).finally(() => clearTimeout(timer));
+    promise.then(resolve8, reject).finally(() => clearTimeout(timer));
   });
 }
 function resolvePluginConfig(pluginName, configManager) {
@@ -20246,6 +21256,8 @@ var LifecycleManager = class {
   settingsManager;
   pluginRegistry;
   _instanceRoot;
+  installRecoveryChecked = false;
+  communityRecoveryError;
   contexts = /* @__PURE__ */ new Map();
   loadOrder = [];
   _loaded = /* @__PURE__ */ new Set();
@@ -20312,6 +21324,17 @@ var LifecycleManager = class {
    * Already-loaded plugins are included in dependency resolution but not re-booted.
    */
   async boot(plugins) {
+    if (!this.installRecoveryChecked && this._instanceRoot && this.pluginRegistry) {
+      this.installRecoveryChecked = true;
+      try {
+        await recoverPluginInstallTransaction(this._instanceRoot);
+        await this.pluginRegistry.load();
+      } catch (error) {
+        const code = error instanceof PluginInstallError ? error.code : "PLUGIN_RECOVERY_FAILED";
+        this.communityRecoveryError = `${code}: Community plugin transaction recovery did not complete; community plugins are quarantined until recovery succeeds.`;
+        this.log?.error(this.communityRecoveryError);
+      }
+    }
     const newNames = new Set(plugins.map((p) => p.name));
     const allForResolution = [...this.loadOrder.filter((p) => !newNames.has(p.name)), ...plugins];
     let sorted;
@@ -20345,13 +21368,27 @@ var LifecycleManager = class {
         }
       }
       const registryEntry = this.pluginRegistry?.get(plugin.name);
+      if (registryEntry && registryEntry.source !== "builtin" && this.communityRecoveryError) {
+        this._failed.add(plugin.name);
+        this.eventBus?.emit(BusEvent.PLUGIN_FAILED, { name: plugin.name, code: "PLUGIN_RECOVERY_FAILED", error: this.communityRecoveryError });
+        continue;
+      }
+      if (this._instanceRoot && fs16.existsSync(migrationGuardPath(this._instanceRoot, plugin.name))) {
+        const status = `PLUGIN_MIGRATION_ROLLBACK_FAILED: ${plugin.name} has a durable migration quarantine marker. Repair or restore its settings and registry entry, then remove the marker before re-enabling it.`;
+        this._failed.add(plugin.name);
+        this.getPluginLogger(plugin.name).error(status);
+        this.eventBus?.emit(BusEvent.PLUGIN_FAILED, { name: plugin.name, code: "PLUGIN_MIGRATION_ROLLBACK_FAILED", error: status });
+        continue;
+      }
       if (registryEntry && registryEntry.enabled === false) {
         this.eventBus?.emit(BusEvent.PLUGIN_DISABLED, { name: plugin.name });
         continue;
       }
       if (registryEntry && plugin.migrate && registryEntry.version !== plugin.version && this.settingsManager) {
+        const oldSettings = structuredClone(await this.settingsManager.loadSettings(plugin.name));
+        const oldRegistryEntry = structuredClone(registryEntry);
+        const migrationGuard = this._instanceRoot ? writeMigrationGuard(this._instanceRoot, plugin.name, registryEntry.version, plugin.version) : void 0;
         try {
-          const oldSettings = await this.settingsManager.loadSettings(plugin.name);
           const pluginLog = this.getPluginLogger(plugin.name);
           const migrateCtx = {
             pluginName: plugin.name,
@@ -20363,13 +21400,38 @@ var LifecycleManager = class {
             SETUP_TIMEOUT_MS,
             `${plugin.name}.migrate()`
           );
-          if (newSettings && typeof newSettings === "object") {
-            await migrateCtx.settings.setAll(newSettings);
+          const migratedSettings = newSettings && typeof newSettings === "object" ? newSettings : await migrateCtx.settings.getAll();
+          if (plugin.settingsSchema) {
+            const validation = this.settingsManager.validateSettings(plugin.name, migratedSettings, plugin.settingsSchema);
+            if (!validation.valid) throw new Error(`migrated settings invalid: ${validation.errors?.join("; ")}`);
           }
+          await migrateCtx.settings.setAll(migratedSettings);
           this.pluginRegistry.updateVersion(plugin.name, plugin.version);
           await this.pluginRegistry.save();
-        } catch (err) {
-          this.getPluginLogger(plugin.name).warn(`Migration failed, continuing with old settings: ${err}`);
+          if (migrationGuard) fs16.rmSync(migrationGuard, { force: true });
+        } catch {
+          let settingsRestored = true;
+          try {
+            await this.settingsManager.createAPI(plugin.name).setAll(oldSettings);
+          } catch {
+            settingsRestored = false;
+          }
+          this.pluginRegistry.restore(plugin.name, oldRegistryEntry);
+          let registryRestored = true;
+          try {
+            await this.pluginRegistry.save();
+          } catch {
+            registryRestored = false;
+          }
+          if (settingsRestored && registryRestored && migrationGuard) fs16.rmSync(migrationGuard, { force: true });
+          this._failed.add(plugin.name);
+          const rollbackComplete = settingsRestored && registryRestored;
+          const code = rollbackComplete ? "PLUGIN_MIGRATION_FAILED" : "PLUGIN_MIGRATION_ROLLBACK_FAILED";
+          const recovery = rollbackComplete ? "the exact previous registry entry and settings were restored" : "rollback persistence was incomplete and the durable migration quarantine remains in place";
+          const status = `${code}: ${plugin.name} migration ${oldRegistryEntry.version} \u2192 ${plugin.version} failed; ${recovery}. Fix the migration/settings before retrying.`;
+          this.getPluginLogger(plugin.name).error(status);
+          this.eventBus?.emit(BusEvent.PLUGIN_FAILED, { name: plugin.name, code, error: status });
+          continue;
         }
       }
       let pluginConfig;
@@ -21049,7 +22111,7 @@ var OpenACPCore = class {
       }
     );
     registerCoreMenuItems(this.menuRegistry);
-    this.assistantRegistry.setInstanceRoot(path16.dirname(ctx.root));
+    this.assistantRegistry.setInstanceRoot(path18.dirname(ctx.root));
     this.assistantRegistry.register(createSessionsSection(this));
     this.assistantRegistry.register(createAgentsSection(this));
     this.assistantRegistry.register(createConfigSection(this));
@@ -21869,33 +22931,33 @@ init_doctor();
 init_config_registry();
 
 // src/core/config/config-editor.ts
-import * as path33 from "path";
+import * as path34 from "path";
 import * as clack2 from "@clack/prompts";
 
 // src/cli/autostart.ts
 init_log();
 import { execFileSync as execFileSync6 } from "child_process";
-import * as fs29 from "fs";
-import * as path27 from "path";
+import * as fs31 from "fs";
+import * as path29 from "path";
 import * as os9 from "os";
 var log20 = createChildLogger({ module: "autostart" });
-var LEGACY_LAUNCHD_PLIST_PATH = path27.join(os9.homedir(), "Library", "LaunchAgents", "com.openacp.daemon.plist");
-var LEGACY_SYSTEMD_SERVICE_PATH = path27.join(os9.homedir(), ".config", "systemd", "user", "openacp.service");
+var LEGACY_LAUNCHD_PLIST_PATH = path29.join(os9.homedir(), "Library", "LaunchAgents", "com.openacp.daemon.plist");
+var LEGACY_SYSTEMD_SERVICE_PATH = path29.join(os9.homedir(), ".config", "systemd", "user", "openacp.service");
 function getLaunchdLabel(instanceId) {
   return `com.openacp.daemon.${instanceId}`;
 }
 function getLaunchdPlistPath(instanceId) {
-  return path27.join(os9.homedir(), "Library", "LaunchAgents", `${getLaunchdLabel(instanceId)}.plist`);
+  return path29.join(os9.homedir(), "Library", "LaunchAgents", `${getLaunchdLabel(instanceId)}.plist`);
 }
 function getSystemdServiceName(instanceId) {
   return `openacp-${instanceId}`;
 }
 function getSystemdServicePath(instanceId) {
-  return path27.join(os9.homedir(), ".config", "systemd", "user", `${getSystemdServiceName(instanceId)}.service`);
+  return path29.join(os9.homedir(), ".config", "systemd", "user", `${getSystemdServiceName(instanceId)}.service`);
 }
 function getAutoStartState(instanceId) {
   if (process.platform === "linux") {
-    const installed = fs29.existsSync(getSystemdServicePath(instanceId));
+    const installed = fs31.existsSync(getSystemdServicePath(instanceId));
     if (!installed) return { installed: false, manager: null, active: false };
     try {
       const output = execFileSync6("systemctl", [
@@ -21917,7 +22979,7 @@ function getAutoStartState(instanceId) {
     }
   }
   if (process.platform === "darwin") {
-    const installed = fs29.existsSync(getLaunchdPlistPath(instanceId));
+    const installed = fs31.existsSync(getLaunchdPlistPath(instanceId));
     if (!installed) return { installed: false, manager: null, active: false };
     try {
       const uid = process.getuid();
@@ -21947,7 +23009,7 @@ function escapeSystemdValue(str) {
 }
 function generateLaunchdPlist(nodePath, cliPath, logDir2, instanceRoot, instanceId) {
   const label = getLaunchdLabel(instanceId);
-  const logFile = path27.join(logDir2, "openacp.log");
+  const logFile = path29.join(logDir2, "openacp.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -21999,25 +23061,25 @@ WantedBy=default.target
 `;
 }
 function migrateLegacy() {
-  if (process.platform === "darwin" && fs29.existsSync(LEGACY_LAUNCHD_PLIST_PATH)) {
+  if (process.platform === "darwin" && fs31.existsSync(LEGACY_LAUNCHD_PLIST_PATH)) {
     try {
       const uid = process.getuid();
       execFileSync6("launchctl", ["bootout", `gui/${uid}`, "com.openacp.daemon"], { stdio: "pipe" });
     } catch {
     }
     try {
-      fs29.unlinkSync(LEGACY_LAUNCHD_PLIST_PATH);
+      fs31.unlinkSync(LEGACY_LAUNCHD_PLIST_PATH);
     } catch {
     }
     log20.info("Removed legacy single-instance LaunchAgent");
   }
-  if (process.platform === "linux" && fs29.existsSync(LEGACY_SYSTEMD_SERVICE_PATH)) {
+  if (process.platform === "linux" && fs31.existsSync(LEGACY_SYSTEMD_SERVICE_PATH)) {
     try {
       execFileSync6("systemctl", ["--user", "disable", "openacp"], { stdio: "pipe" });
     } catch {
     }
     try {
-      fs29.unlinkSync(LEGACY_SYSTEMD_SERVICE_PATH);
+      fs31.unlinkSync(LEGACY_SYSTEMD_SERVICE_PATH);
     } catch {
     }
     try {
@@ -22032,26 +23094,26 @@ function installAutoStart(logDir2, instanceRoot, instanceId) {
     return { success: false, error: "Auto-start not supported on this platform" };
   }
   const nodePath = process.execPath;
-  const cliPath = path27.resolve(process.argv[1]);
-  const resolvedLogDir = logDir2.startsWith("~") ? path27.join(os9.homedir(), logDir2.slice(1)) : logDir2;
+  const cliPath = path29.resolve(process.argv[1]);
+  const resolvedLogDir = logDir2.startsWith("~") ? path29.join(os9.homedir(), logDir2.slice(1)) : logDir2;
   try {
     migrateLegacy();
     if (process.platform === "darwin") {
       const plistPath = getLaunchdPlistPath(instanceId);
       const plist = generateLaunchdPlist(nodePath, cliPath, resolvedLogDir, instanceRoot, instanceId);
-      const dir = path27.dirname(plistPath);
-      fs29.mkdirSync(dir, { recursive: true });
+      const dir = path29.dirname(plistPath);
+      fs31.mkdirSync(dir, { recursive: true });
       const uid = process.getuid();
       const domain = `gui/${uid}`;
-      const previous = fs29.existsSync(plistPath) ? fs29.readFileSync(plistPath, "utf8") : void 0;
+      const previous = fs31.existsSync(plistPath) ? fs31.readFileSync(plistPath, "utf8") : void 0;
       const previousState = getAutoStartState(instanceId);
       const tmp = `${plistPath}.${process.pid}.tmp`;
       let replaced = false;
       let bootedOut = false;
       try {
-        fs29.writeFileSync(tmp, plist, { mode: 384 });
+        fs31.writeFileSync(tmp, plist, { mode: 384 });
         execFileSync6("plutil", ["-lint", tmp], { stdio: "pipe" });
-        fs29.renameSync(tmp, plistPath);
+        fs31.renameSync(tmp, plistPath);
         replaced = true;
         if (previousState.active) {
           execFileSync6("launchctl", ["bootout", domain, plistPath], { stdio: "pipe" });
@@ -22060,7 +23122,7 @@ function installAutoStart(logDir2, instanceRoot, instanceId) {
         execFileSync6("launchctl", ["bootstrap", domain, plistPath], { stdio: "pipe" });
       } catch (error) {
         try {
-          fs29.rmSync(tmp, { force: true });
+          fs31.rmSync(tmp, { force: true });
         } catch {
         }
         if (replaced) {
@@ -22070,11 +23132,11 @@ function installAutoStart(logDir2, instanceRoot, instanceId) {
             rollbackBootedOut = true;
           } catch {
           }
-          if (previous === void 0) fs29.rmSync(plistPath, { force: true });
+          if (previous === void 0) fs31.rmSync(plistPath, { force: true });
           else {
             const rollbackTmp = `${plistPath}.${process.pid}.rollback.tmp`;
-            fs29.writeFileSync(rollbackTmp, previous, { mode: 384 });
-            fs29.renameSync(rollbackTmp, plistPath);
+            fs31.writeFileSync(rollbackTmp, previous, { mode: 384 });
+            fs31.renameSync(rollbackTmp, plistPath);
             if (previousState.active || bootedOut || rollbackBootedOut) execFileSync6("launchctl", ["bootstrap", domain, plistPath], { stdio: "pipe" });
           }
         }
@@ -22087,18 +23149,18 @@ function installAutoStart(logDir2, instanceRoot, instanceId) {
       const servicePath = getSystemdServicePath(instanceId);
       const serviceName = getSystemdServiceName(instanceId);
       const unit = generateSystemdUnit(nodePath, cliPath, instanceRoot, instanceId);
-      const dir = path27.dirname(servicePath);
-      fs29.mkdirSync(dir, { recursive: true });
-      const previous = fs29.existsSync(servicePath) ? fs29.readFileSync(servicePath, "utf8") : void 0;
+      const dir = path29.dirname(servicePath);
+      fs31.mkdirSync(dir, { recursive: true });
+      const previous = fs31.existsSync(servicePath) ? fs31.readFileSync(servicePath, "utf8") : void 0;
       const tmp = `${servicePath}.${process.pid}.tmp`;
-      fs29.writeFileSync(tmp, unit, { mode: 384 });
-      fs29.renameSync(tmp, servicePath);
+      fs31.writeFileSync(tmp, unit, { mode: 384 });
+      fs31.renameSync(tmp, servicePath);
       try {
         execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
         execFileSync6("systemctl", ["--user", "enable", serviceName], { stdio: "pipe" });
       } catch (error) {
-        if (previous === void 0) fs29.unlinkSync(servicePath);
-        else fs29.writeFileSync(servicePath, previous);
+        if (previous === void 0) fs31.unlinkSync(servicePath);
+        else fs31.writeFileSync(servicePath, previous);
         try {
           execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
         } catch {
@@ -22122,13 +23184,13 @@ function uninstallAutoStart(instanceId) {
   try {
     if (process.platform === "darwin") {
       const plistPath = getLaunchdPlistPath(instanceId);
-      if (fs29.existsSync(plistPath)) {
+      if (fs31.existsSync(plistPath)) {
         const uid = process.getuid();
         try {
           execFileSync6("launchctl", ["bootout", `gui/${uid}`, plistPath], { stdio: "pipe" });
         } catch {
         }
-        fs29.unlinkSync(plistPath);
+        fs31.unlinkSync(plistPath);
         log20.info({ instanceId }, "LaunchAgent removed");
       }
       return { success: true };
@@ -22136,12 +23198,12 @@ function uninstallAutoStart(instanceId) {
     if (process.platform === "linux") {
       const servicePath = getSystemdServicePath(instanceId);
       const serviceName = getSystemdServiceName(instanceId);
-      if (fs29.existsSync(servicePath)) {
+      if (fs31.existsSync(servicePath)) {
         try {
           execFileSync6("systemctl", ["--user", "disable", serviceName], { stdio: "pipe" });
         } catch {
         }
-        fs29.unlinkSync(servicePath);
+        fs31.unlinkSync(servicePath);
         execFileSync6("systemctl", ["--user", "daemon-reload"], { stdio: "pipe" });
         log20.info({ instanceId }, "systemd user service removed");
       }
@@ -22156,10 +23218,10 @@ function uninstallAutoStart(instanceId) {
 }
 function isAutoStartInstalled(instanceId) {
   if (process.platform === "darwin") {
-    return fs29.existsSync(getLaunchdPlistPath(instanceId));
+    return fs31.existsSync(getLaunchdPlistPath(instanceId));
   }
   if (process.platform === "linux") {
-    return fs29.existsSync(getSystemdServicePath(instanceId));
+    return fs31.existsSync(getSystemdServicePath(instanceId));
   }
   return false;
 }
@@ -22168,25 +23230,25 @@ function isAutoStartInstalled(instanceId) {
 init_instance_context();
 init_instance_registry();
 init_log();
-import fs31 from "fs";
-import path29 from "path";
+import fs33 from "fs";
+import path31 from "path";
 var log21 = createChildLogger({ module: "resolve-instance-id" });
 function resolveInstanceId(instanceRoot) {
   try {
-    const configPath = path29.join(instanceRoot, "config.json");
-    const raw = JSON.parse(fs31.readFileSync(configPath, "utf-8"));
+    const configPath = path31.join(instanceRoot, "config.json");
+    const raw = JSON.parse(fs33.readFileSync(configPath, "utf-8"));
     if (raw.id && typeof raw.id === "string") return raw.id;
   } catch {
   }
   try {
-    const reg = new InstanceRegistry(path29.join(getGlobalRoot(), "instances.json"));
+    const reg = new InstanceRegistry(path31.join(getGlobalRoot(), "instances.json"));
     reg.load();
     const entry = reg.getByRoot(instanceRoot);
     if (entry?.id) return entry.id;
   } catch (err) {
     log21.debug({ err: err.message, instanceRoot }, "Could not read instance registry, using fallback id");
   }
-  return path29.basename(path29.dirname(instanceRoot)).replace(/[^a-zA-Z0-9-]/g, "-") || "default";
+  return path31.basename(path31.dirname(instanceRoot)).replace(/[^a-zA-Z0-9-]/g, "-") || "default";
 }
 
 // src/core/config/config-editor.ts
@@ -22758,7 +23820,7 @@ async function runConfigEditor(configManager, mode = "file", apiPort, settingsMa
   await configManager.load();
   const config = configManager.get();
   const updates = {};
-  const instanceRoot = path33.dirname(configManager.getConfigPath());
+  const instanceRoot = path34.dirname(configManager.getConfigPath());
   console.log(`
 ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
   console.log(dim(`Config: ${configManager.getConfigPath()}`));
@@ -22815,17 +23877,17 @@ ${c.cyan}${c.bold}OpenACP Config Editor${c.reset}`);
 async function sendConfigViaApi(port, updates) {
   const { apiCall: call } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
   const paths = flattenToPaths(updates);
-  for (const { path: path38, value } of paths) {
+  for (const { path: path39, value } of paths) {
     const res = await call(port, "/api/config", {
       method: "PATCH",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ path: path38, value })
+      body: JSON.stringify({ path: path39, value })
     });
     const data = await res.json();
     if (!res.ok) {
-      console.log(warn(`Failed to update ${path38}: ${data.error}`));
+      console.log(warn(`Failed to update ${path39}: ${data.error}`));
     } else if (data.needsRestart) {
-      console.log(warn(`${path38} updated \u2014 restart required`));
+      console.log(warn(`${path39} updated \u2014 restart required`));
     }
   }
 }
@@ -22845,25 +23907,25 @@ function flattenToPaths(obj, prefix = "") {
 // src/cli/daemon.ts
 init_config();
 import { spawn as spawn3 } from "child_process";
-import * as fs34 from "fs";
-import * as path34 from "path";
+import * as fs35 from "fs";
+import * as path35 from "path";
 function getPidPath(root) {
-  return path34.join(root, "openacp.pid");
+  return path35.join(root, "openacp.pid");
 }
 function getLogDir(root) {
-  return path34.join(root, "logs");
+  return path35.join(root, "logs");
 }
 function getRunningMarker(root) {
-  return path34.join(root, "running");
+  return path35.join(root, "running");
 }
 function writePidFile(pidPath, pid) {
-  const dir = path34.dirname(pidPath);
-  fs34.mkdirSync(dir, { recursive: true });
-  fs34.writeFileSync(pidPath, String(pid));
+  const dir = path35.dirname(pidPath);
+  fs35.mkdirSync(dir, { recursive: true });
+  fs35.writeFileSync(pidPath, String(pid));
 }
 function readPidFile(pidPath) {
   try {
-    const content = fs34.readFileSync(pidPath, "utf-8").trim();
+    const content = fs35.readFileSync(pidPath, "utf-8").trim();
     const pid = parseInt(content, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -22872,7 +23934,7 @@ function readPidFile(pidPath) {
 }
 function removePidFile(pidPath) {
   try {
-    fs34.unlinkSync(pidPath);
+    fs35.unlinkSync(pidPath);
   } catch {
   }
 }
@@ -22905,12 +23967,12 @@ function startDaemon(pidPath, logDir2, instanceRoot) {
     return { error: `Already running (PID ${pid})` };
   }
   const resolvedLogDir = logDir2 ? expandHome2(logDir2) : getLogDir(instanceRoot);
-  fs34.mkdirSync(resolvedLogDir, { recursive: true });
-  const logFile = path34.join(resolvedLogDir, "openacp.log");
-  const cliPath = path34.resolve(process.argv[1]);
+  fs35.mkdirSync(resolvedLogDir, { recursive: true });
+  const logFile = path35.join(resolvedLogDir, "openacp.log");
+  const cliPath = path35.resolve(process.argv[1]);
   const nodePath = process.execPath;
-  const out = fs34.openSync(logFile, "a");
-  const err = fs34.openSync(logFile, "a");
+  const out = fs35.openSync(logFile, "a");
+  const err = fs35.openSync(logFile, "a");
   const child = spawn3(nodePath, [cliPath, "--daemon-child"], {
     detached: true,
     stdio: ["ignore", out, err],
@@ -22919,8 +23981,8 @@ function startDaemon(pidPath, logDir2, instanceRoot) {
       ...instanceRoot ? { OPENACP_INSTANCE_ROOT: instanceRoot } : {}
     }
   });
-  fs34.closeSync(out);
-  fs34.closeSync(err);
+  fs35.closeSync(out);
+  fs35.closeSync(err);
   if (!child.pid) {
     return { error: "Failed to spawn daemon process" };
   }
@@ -22929,7 +23991,7 @@ function startDaemon(pidPath, logDir2, instanceRoot) {
   return { pid: child.pid };
 }
 function sleep2(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 function isProcessAlive2(pid) {
   try {
@@ -22991,12 +24053,12 @@ async function stopDaemon(pidPath, instanceRoot) {
 }
 function markRunning(root) {
   const marker = getRunningMarker(root);
-  fs34.mkdirSync(path34.dirname(marker), { recursive: true });
-  fs34.writeFileSync(marker, "");
+  fs35.mkdirSync(path35.dirname(marker), { recursive: true });
+  fs35.writeFileSync(marker, "");
 }
 function clearRunning(root) {
   try {
-    fs34.unlinkSync(getRunningMarker(root));
+    fs35.unlinkSync(getRunningMarker(root));
   } catch {
   }
 }