@forsion/unit 2.12.2 → 2.13.1

package/main.mjs

@@ -1,13 +1,494 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// desktop/shared/amadeus/pluginFiles.ts
+function isSafePluginExt(extension) {
+  if (typeof extension !== "string") return false;
+  const value = extension.trim().toLowerCase();
+  if (!value.startsWith(".") || value.length < 2 || value.length > 40) return false;
+  if (value === ".md" || value === ".markdown" || value === ".txt") return false;
+  return value.endsWith(".md") ? /^\.[a-z0-9][a-z0-9-]*\.md$/.test(value) : /^\.[a-z0-9][a-z0-9.-]*$/.test(value);
+}
+var init_pluginFiles = __esm({
+  "desktop/shared/amadeus/pluginFiles.ts"() {
+    "use strict";
+  }
+});
+
+// desktop/shared/nativeFeatures.ts
+function nativeFeatureSpaceIds(features) {
+  return [...new Set(features.flatMap((feature) => NATIVE_FEATURE_SPACES[feature]))];
+}
+var NATIVE_FEATURE_IDS, NATIVE_FEATURE_SPACES, isNativeFeatureId;
+var init_nativeFeatures = __esm({
+  "desktop/shared/nativeFeatures.ts"() {
+    "use strict";
+    NATIVE_FEATURE_IDS = ["amadeus", "tangu", "calendar", "automation", "public"];
+    NATIVE_FEATURE_SPACES = {
+      amadeus: ["amadeus"],
+      tangu: ["tangu"],
+      calendar: ["calendar"],
+      automation: ["automation"],
+      public: ["public"]
+    };
+    isNativeFeatureId = (value) => typeof value === "string" && NATIVE_FEATURE_IDS.includes(value);
+  }
+});
+
+// unit/packages.ts
+import { readFile as readFile2, readdir, realpath as realpath2, stat } from "node:fs/promises";
+import { isAbsolute, resolve, sep as sep2 } from "node:path";
+function versionAtLeast(actual, minimum) {
+  const parse = (v) => /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(v) ? v.split(/[.+-]/).slice(0, 3).map(Number) : null;
+  const a = parse(actual), b = parse(minimum);
+  if (!a || !b) throw new Error("Invalid semantic version");
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
+  return true;
+}
+async function packagePath(root, relative2) {
+  if (typeof relative2 !== "string" || !relative2 || isAbsolute(relative2) || relative2.split(/[\\/]/).includes("..")) throw new Error("Plugin file escapes its package");
+  const file2 = await realpath2(resolve(root, relative2));
+  if (!file2.startsWith(root + sep2)) throw new Error("Plugin file escapes its package");
+  if (!(await stat(file2)).isFile()) throw new Error("Plugin entry must be a regular file");
+  return file2;
+}
+async function readPackage(dir, appVersion) {
+  const root = await realpath2(dir);
+  const manifest = JSON.parse(await readFile2(await packagePath(root, "manifest.json"), "utf8"));
+  if (!validId(manifest.id) || manifest.apiVersion !== 1) throw new Error("Invalid plugin identity or unsupported plugin API");
+  versionAtLeast(manifest.version, "0.0.0");
+  if (manifest.minAppVersion && appVersion && !versionAtLeast(appVersion, manifest.minAppVersion)) throw new Error(`Plugin ${manifest.id} requires Unit ${manifest.minAppVersion}`);
+  if (manifest.requires && (!Array.isArray(manifest.requires) || !manifest.requires.every(validId))) throw new Error("Invalid plugin dependencies");
+  const result = { root, manifest, spaces: [], spaceIds: /* @__PURE__ */ new Set() };
+  if (manifest.frontend) {
+    const { features, services = {} } = manifest.frontend;
+    if (!Array.isArray(features) || !features.length || !features.every(isNativeFeatureId) || new Set(features).size !== features.length) throw new Error("Invalid native frontend features");
+    for (const [id, service] of Object.entries(services)) {
+      if (!["amadeus", "tangu"].includes(id) || !features.includes(id) || !service || service.adapter !== "forsion-cloud-v1" || typeof service.apiBase !== "string" || !/^\/(?:[A-Za-z0-9_-]+\/?)+$/.test(service.apiBase) || id === "tangu" && service.execution !== "fleet" || id === "amadeus" && service.collaboration !== void 0 && typeof service.collaboration !== "boolean") {
+        throw new Error("Invalid frontend cloud service");
+      }
+    }
+    for (const id of nativeFeatureSpaceIds(features)) result.spaceIds.add(id);
+  }
+  if (manifest.main) {
+    const code = await readFile2(await packagePath(root, manifest.main), "utf8");
+    result.ui = {
+      id: manifest.id,
+      name: manifest.name,
+      nameEn: manifest.nameEn,
+      version: manifest.version,
+      apiVersion: manifest.apiVersion,
+      minAppVersion: manifest.minAppVersion,
+      description: manifest.description,
+      descriptionEn: manifest.descriptionEn,
+      onboarding: manifest.onboarding,
+      fileExtensions: Array.isArray(manifest.fileExtensions) ? manifest.fileExtensions.filter(isSafePluginExt).map((v) => v.trim().toLowerCase()).slice(0, 8) : [],
+      code
+    };
+  }
+  if (manifest.runtime) {
+    if (manifest.runtime.apiVersion !== 1) throw new Error("Unsupported local runtime API");
+    if (manifest.runtime.dependencies?.mode === "npm-ci") throw new Error("Local runtime dependencies must be bundled");
+    result.runtimeEntry = await packagePath(root, manifest.runtime.main);
+  }
+  if (manifest.backend) {
+    if (manifest.backend.apiVersion !== 1) throw new Error("Unsupported backend plugin API");
+    result.backendEntry = await packagePath(root, manifest.backend.main);
+  }
+  for (const deps of [manifest.backend?.dependencies, manifest.runtime?.dependencies]) {
+    if (deps && !["bundled", "npm-ci"].includes(deps.mode)) throw new Error("Unsupported dependency mode");
+    const libc = process.platform === "linux" ? process.report?.getReport()?.header?.glibcVersionRuntime ? "glibc" : "musl" : void 0;
+    if (deps?.mode === "bundled" && (deps.platform && deps.platform !== process.platform || deps.libc && deps.libc !== libc || deps.arch && deps.arch !== process.arch || deps.nodeAbi && deps.nodeAbi !== process.versions.modules)) {
+      throw new Error("Plugin dependencies were built for a different OS, architecture, Node ABI, or libc");
+    }
+  }
+  if (!result.ui && !result.backendEntry && !result.runtimeEntry && !manifest.frontend) throw new Error("Plugin has no UI or backend entry");
+  const entries = await readdir(resolve(root, "spaces"), { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const json2 = await readFile2(await packagePath(root, `spaces/${entry.name}/space.json`), "utf8");
+    const spec = JSON.parse(json2);
+    if (!validId(spec.id) || result.spaceIds.has(spec.id)) throw new Error("Invalid or duplicate Space id");
+    result.spaceIds.add(spec.id);
+    result.spaces.push({ slug: entry.name, json: json2, plugin: manifest.id });
+  }
+  return result;
+}
+var validId;
+var init_packages = __esm({
+  "unit/packages.ts"() {
+    "use strict";
+    init_pluginFiles();
+    init_nativeFeatures();
+    validId = (id) => typeof id === "string" && /^[a-z][a-z0-9-]*$/.test(id);
+  }
+});
+
+// unit/config.ts
+import { readFile as readFile5, writeFile as writeFile3, rename as rename3, mkdir as mkdir3 } from "node:fs/promises";
+import { dirname, resolve as resolve3 } from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
+async function readConfig(file2) {
+  const path = resolve3(file2), root = dirname(path);
+  const config = JSON.parse(await readFile5(path, "utf8"));
+  if (!Array.isArray(config.plugins)) throw new Error("unit.json plugins must be an array");
+  config.webDist = resolve3(root, config.webDist);
+  config.dataDir = resolve3(root, config.dataDir || "data");
+  if (config.workspace?.path) config.workspace.path = resolve3(root, config.workspace.path);
+  if (config.workerFile) config.workerFile = resolve3(root, config.workerFile);
+  config.plugins = config.plugins.map((p) => typeof p === "string" ? { path: resolve3(root, p) } : { ...p, path: resolve3(root, p.path) });
+  return config;
+}
+async function writeConfig(file2, config) {
+  await mkdir3(dirname(resolve3(file2)), { recursive: true, mode: 448 });
+  const temp = `${file2}.${randomUUID5()}.tmp`;
+  await writeFile3(temp, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  await rename3(temp, file2);
+}
+var installations;
+var init_config = __esm({
+  "unit/config.ts"() {
+    "use strict";
+    installations = (config) => config.plugins;
+  }
+});
+
+// unit/control.ts
+import net from "node:net";
+import { chmod, rm as rm2, mkdir as mkdir4 } from "node:fs/promises";
+import { resolve as resolve4, dirname as dirname2 } from "node:path";
+import { tmpdir } from "node:os";
+import { createHash as createHash4 } from "node:crypto";
+async function sendControl(dataDir, command) {
+  return new Promise((resolveReply, reject) => {
+    const socket = net.connect(controlAddress(dataDir));
+    let body = "";
+    socket.setTimeout(24e4, () => socket.destroy(new Error("Unit control timed out")));
+    socket.once("connect", () => socket.write(JSON.stringify(command) + "\n"));
+    socket.on("data", (data) => {
+      body += data;
+      if (body.length > 1e6) {
+        socket.destroy(new Error("Oversized control response"));
+        return;
+      }
+      if (!body.includes("\n")) return;
+      try {
+        const reply = JSON.parse(body.split("\n")[0]);
+        socket.end();
+        if (reply.ok) resolveReply(reply.result);
+        else reject(new Error(reply.error || "Unit command failed"));
+      } catch (error) {
+        socket.destroy();
+        reject(error);
+      }
+    });
+    socket.once("error", reject);
+    socket.once("end", () => {
+      if (!body.includes("\n")) reject(new Error("Unit control connection closed"));
+    });
+  });
+}
+async function startControl(dataDir, dispatch) {
+  await mkdir4(dataDir, { recursive: true, mode: 448 });
+  try {
+    await sendControl(dataDir, { action: "status" });
+    throw new Error("This Unit is already running");
+  } catch (error) {
+    if (!unitIsOffline(error)) throw error;
+  }
+  const address = controlAddress(dataDir);
+  if (process.platform !== "win32") {
+    await mkdir4(dirname2(address), { recursive: true, mode: 448 });
+    await chmod(dirname2(address), 448);
+  }
+  if (process.platform !== "win32") await rm2(address, { force: true });
+  const clients = /* @__PURE__ */ new Set();
+  const server = net.createServer((socket) => {
+    clients.add(socket);
+    socket.once("close", () => clients.delete(socket));
+    let body = "", dispatched = false;
+    socket.setTimeout(24e4, () => socket.destroy());
+    socket.on("data", (data) => {
+      if (dispatched) return;
+      body += data;
+      if (body.length > 1e6) {
+        socket.destroy();
+        return;
+      }
+      if (!body.includes("\n")) return;
+      dispatched = true;
+      void (async () => {
+        try {
+          socket.end(JSON.stringify({ ok: true, result: await dispatch(JSON.parse(body.split("\n")[0])) }) + "\n");
+        } catch (error) {
+          socket.end(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : "Unit command failed" }) + "\n");
+        }
+      })();
+    });
+    socket.on("error", () => {
+    });
+  });
+  await new Promise((ready, reject) => {
+    server.once("error", reject);
+    server.listen(address, ready);
+  });
+  if (process.platform !== "win32") await chmod(address, 384);
+  return { close: async () => {
+    await new Promise((done) => {
+      server.close(() => done());
+      for (const socket of clients) socket.destroy();
+    });
+    if (process.platform !== "win32") await rm2(address, { force: true });
+  } };
+}
+var controlAddress, unitIsOffline;
+var init_control = __esm({
+  "unit/control.ts"() {
+    "use strict";
+    controlAddress = (dataDir) => process.platform === "win32" ? `\\\\.\\pipe\\forsion-unit-${createHash4("sha256").update(resolve4(dataDir)).digest("hex").slice(0, 24)}` : resolve4(tmpdir(), `forsion-unit-${process.getuid?.() ?? "user"}`, createHash4("sha256").update(resolve4(dataDir)).digest("hex").slice(0, 24) + ".sock");
+    unitIsOffline = (error) => ["ENOENT", "ECONNREFUSED"].includes(error?.code || "");
+  }
+});
+
+// unit/install.ts
+import { cp, mkdir as mkdir5, readdir as readdir3, realpath as realpath4, rm as rm3, lstat, open, readlink, symlink } from "node:fs/promises";
+import { dirname as dirname3, resolve as resolve5, sep as sep4, relative, isAbsolute as isAbsolute3 } from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { spawn } from "node:child_process";
+async function inspectTree(dir, root, seen = /* @__PURE__ */ new Set()) {
+  const actual = await realpath4(dir);
+  if (seen.has(actual)) return;
+  seen.add(actual);
+  for (const entry of await readdir3(dir, { withFileTypes: true })) {
+    const path = resolve5(dir, entry.name);
+    if (entry.name === ".env" || entry.name.startsWith(".env.") && !entry.name.endsWith(".example")) throw new Error("Package contains private environment files");
+    if (entry.isSymbolicLink()) {
+      const target = await realpath4(path);
+      if (!target.startsWith(root + sep4)) throw new Error("Package symlink escapes its directory");
+      if ((await lstat(target)).isDirectory()) await inspectTree(target, root, seen);
+    } else if (entry.isDirectory()) await inspectTree(path, root, seen);
+  }
+}
+async function relocateLinks(dir, source, destination) {
+  for (const entry of await readdir3(dir, { withFileTypes: true })) {
+    const path = resolve5(dir, entry.name);
+    if (entry.isSymbolicLink()) {
+      const link = await readlink(path);
+      if (isAbsolute3(link)) {
+        const relocated = resolve5(destination, relative(source, await realpath4(link)));
+        await rm3(path);
+        await symlink(relative(dirname3(path), relocated), path);
+      }
+    } else if (entry.isDirectory()) await relocateLinks(path, source, destination);
+  }
+}
+async function copyPackage(source, destination, version) {
+  const sourceRoot = await realpath4(source);
+  if (!(await lstat(sourceRoot)).isDirectory()) throw new Error("Expected an unpacked plugin directory");
+  await readPackage(sourceRoot, version);
+  await inspectTree(sourceRoot, sourceRoot);
+  await cp(sourceRoot, destination, { recursive: true, verbatimSymlinks: true });
+  await relocateLinks(destination, sourceRoot, destination);
+  return readPackage(destination, version);
+}
+async function installDependencies(root, backendMain) {
+  const backend = resolve5(root, backendMain.split("/")[0]);
+  await packagePath(root, backendMain.split("/")[0] + "/package-lock.json");
+  await new Promise((done, reject) => {
+    const win = process.platform === "win32";
+    const child = spawn(win ? "cmd.exe" : "npm", win ? ["/c", "npm", "ci", "--omit=dev"] : ["ci", "--omit=dev"], { cwd: backend, stdio: "inherit", env: { ...process.env, PATH: dirname3(process.execPath) + (win ? ";" : ":") + (process.env.PATH || "") } });
+    child.once("error", reject);
+    child.once("exit", (code) => code === 0 ? done() : reject(new Error(`Plugin dependency installation failed (${code})`)));
+  });
+}
+async function installPackage(configPath, source, options = {}) {
+  const file2 = resolve5(configPath), root = dirname3(file2);
+  const lockPath = resolve5(root, ".install.lock");
+  const lock = await open(lockPath, "wx", 384).catch(() => {
+    throw new Error("Another install is in progress");
+  });
+  let stage, committed = false;
+  try {
+    const config = await readConfig(file2), sourceRoot = await realpath4(source);
+    if (!(await lstat(sourceRoot)).isDirectory()) throw new Error("Install expects an unpacked plugin directory");
+    const pack = await readPackage(sourceRoot, config.version);
+    const entries = installations(config);
+    const existing = (await Promise.all(entries.map(async (entry) => ({ entry, pack: await readPackage(entry.path) })))).find((p) => p.pack.manifest.id === pack.manifest.id);
+    if (options.updateId !== void 0) {
+      if (pack.manifest.id !== options.updateId) throw new Error("Update changes plugin identity");
+      if (!existing) throw new Error(`Plugin is not installed: ${options.updateId}`);
+      try {
+        await sendControl(config.dataDir, { action: "status" });
+      } catch (error) {
+        if (unitIsOffline(error)) throw new Error("Unit is not running; start it before updating");
+        throw error;
+      }
+    }
+    await inspectTree(sourceRoot, sourceRoot);
+    stage = resolve5(root, "plugins", pack.manifest.id, `${pack.manifest.version}-${randomUUID6()}`);
+    await mkdir5(dirname3(stage), { recursive: true, mode: 448 });
+    await cp(sourceRoot, stage, { recursive: true, verbatimSymlinks: true });
+    await relocateLinks(stage, sourceRoot, stage);
+    if (options.releaseDigest) {
+      const { packageDigest: packageDigest2 } = await Promise.resolve().then(() => (init_releases(), releases_exports));
+      if (pack.manifest.backend?.dependencies?.mode === "npm-ci" || pack.manifest.runtime?.dependencies?.mode === "npm-ci" || await packageDigest2(stage) !== options.releaseDigest) throw new Error("Staged release changed during installation");
+    }
+    if (pack.manifest.backend?.dependencies?.mode === "npm-ci") await installDependencies(stage, pack.manifest.backend.main);
+    const ready = await readPackage(stage, config.version);
+    if (existing) {
+      try {
+        if (options.applyUpdate) await options.applyUpdate(pack.manifest.id, stage);
+        else await sendControl(config.dataDir, { action: "update", id: pack.manifest.id, path: stage });
+        committed = true;
+        return { id: ready.manifest.id, version: ready.manifest.version, path: stage };
+      } catch (error) {
+        if (!unitIsOffline(error)) {
+          committed = true;
+          throw error;
+        }
+        if (options.updateId !== void 0) throw new Error("Unit is not running; start it before updating");
+      }
+      existing.entry.path = stage;
+    } else {
+      try {
+        await sendControl(config.dataDir, { action: "status" });
+        throw new Error("Stop the Unit before installing a new plugin; updates can run live");
+      } catch (error) {
+        if (!unitIsOffline(error)) throw error;
+      }
+      entries.push({ path: stage, enabled: true });
+    }
+    if (!config.defaultSpace && ready.spaceIds.size) config.defaultSpace = [...ready.spaceIds][0];
+    await writeConfig(file2, config);
+    committed = true;
+    return { id: ready.manifest.id, version: ready.manifest.version, path: stage };
+  } finally {
+    await lock.close();
+    await rm3(lockPath, { force: true });
+    if (!committed && stage) await rm3(stage, { recursive: true, force: true });
+  }
+}
+var init_install = __esm({
+  "unit/install.ts"() {
+    "use strict";
+    init_packages();
+    init_config();
+    init_control();
+  }
+});
+
+// unit/releases.ts
+var releases_exports = {};
+__export(releases_exports, {
+  listReleases: () => listReleases,
+  packageDigest: () => packageDigest,
+  resolveRelease: () => resolveRelease,
+  stageRelease: () => stageRelease,
+  validReleaseId: () => validReleaseId
+});
+import { createHash as createHash5, randomUUID as randomUUID7 } from "node:crypto";
+import { createReadStream as createReadStream2 } from "node:fs";
+import { mkdir as mkdir6, readdir as readdir4, readFile as readFile6, writeFile as writeFile4, rename as rename4, rm as rm4, readlink as readlink2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+async function packageDigest(root) {
+  const hash = createHash5("sha256");
+  async function visit(dir, prefix = "") {
+    const entries = (await readdir4(dir, { withFileTypes: true })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const name = prefix + entry.name, path = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        hash.update(JSON.stringify(["directory", name]));
+        await visit(path, name + "/");
+      } else if (entry.isSymbolicLink()) hash.update(JSON.stringify(["link", name, await readlink2(path)]));
+      else if (entry.isFile()) {
+        const file2 = createHash5("sha256");
+        for await (const chunk of createReadStream2(path)) file2.update(chunk);
+        hash.update(JSON.stringify(["file", name, file2.digest("hex")]));
+      } else throw new Error("Release contains a non-regular file");
+    }
+  }
+  await visit(root);
+  return hash.digest("hex");
+}
+async function listReleases(dataDir) {
+  const root = join2(dataDir, "releases");
+  let names;
+  try {
+    names = await readdir4(root);
+  } catch (e) {
+    if (e.code === "ENOENT") return [];
+    throw e;
+  }
+  const result = [];
+  for (const name of names.filter(validReleaseId).slice(0, 200)) {
+    const item = JSON.parse(await readFile6(join2(root, name, "release.json"), "utf8"));
+    if (item.releaseId !== name) throw new Error("Invalid release record");
+    result.push({ releaseId: name, pluginId: item.pluginId, version: item.version, sha256: item.sha256, createdAt: item.createdAt });
+  }
+  return result.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+async function stageRelease(dataDir, source, version) {
+  const root = join2(dataDir, "releases"), id = randomUUID7(), temporary = join2(root, "." + id);
+  await mkdir6(root, { recursive: true, mode: 448 });
+  if ((await listReleases(dataDir)).length >= 200) throw new Error("Release storage is full; archive unused staged packages locally");
+  await mkdir6(temporary, { mode: 448 });
+  try {
+    const pack = await copyPackage(source, join2(temporary, "package"), version);
+    if (pack.manifest.backend?.dependencies?.mode === "npm-ci" || pack.manifest.runtime?.dependencies?.mode === "npm-ci") {
+      throw new Error("Stage requires a bundled package; install and seal dependencies on the target platform first");
+    }
+    const item = {
+      releaseId: id,
+      pluginId: pack.manifest.id,
+      version: pack.manifest.version,
+      sha256: await packageDigest(pack.root),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeFile4(join2(temporary, "release.json"), JSON.stringify(item), { mode: 384 });
+    await rename4(temporary, join2(root, id));
+    return item;
+  } finally {
+    await rm4(temporary, { recursive: true, force: true });
+  }
+}
+async function resolveRelease(dataDir, id, pluginId, version, verifyContents = true) {
+  if (!validReleaseId(id)) throw new Error("Invalid release ID");
+  const root = join2(dataDir, "releases", id), path = join2(root, "package");
+  const item = JSON.parse(await readFile6(join2(root, "release.json"), "utf8"));
+  const pack = await readPackage(path, version);
+  if (item.releaseId !== id || item.pluginId !== pluginId || pack.manifest.id !== pluginId || item.version !== pack.manifest.version || pack.manifest.backend?.dependencies?.mode === "npm-ci" || pack.manifest.runtime?.dependencies?.mode === "npm-ci" || verifyContents && item.sha256 !== await packageDigest(path)) throw new Error("Staged release identity or content changed");
+  return { item, path };
+}
+var validReleaseId;
+var init_releases = __esm({
+  "unit/releases.ts"() {
+    "use strict";
+    init_install();
+    init_packages();
+    validReleaseId = (id) => typeof id === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(id);
+  }
+});
+
 // unit/main.ts
-import { mkdir as mkdir7, readFile as readFile7, open as open2, rm as rm4 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile9, open as open2, rm as rm5 } from "node:fs/promises";
 import { dirname as dirname4, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 
 // unit/host.ts
-import { readFile as readFile5, mkdir as mkdir3 } from "node:fs/promises";
-import { resolve as resolve3 } from "node:path";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { readFile as readFile8, mkdir as mkdir8 } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { homedir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -146,6 +627,7 @@ var ENGINE_ROUTES = [
   { method: "GET", path: "/agent/agents/:slug/avatar", access: "allow", src: "routes/agents.ts", why: "Agent avatar" },
   { method: "POST", path: "/agent/agents/:slug/avatar", access: "deny-remote", src: "routes/agents.ts", why: "update Agent avatar" },
   { method: "GET", path: "/agent/agents/:slug/harness", access: "allow", src: "routes/agents.ts", why: "read HARNESS" },
+  { method: "POST", path: "/agent/agents/:slug/harness/candidate", access: "deny-remote", src: "routes/agents.ts", why: "adopt / dismiss one harness candidate (writes HARNESS.md as the user; the route itself also refuses remote origin)" },
   { method: "POST", path: "/agent/agents/:slug/harness/rollback", access: "deny-remote", src: "routes/agents.ts", why: "harness rollback (design appendix C)" },
   { method: "GET", path: "/agent/agents/:slug/library", access: "allow", src: "routes/agents.ts", why: "Agent library listing" },
   { method: "DELETE", path: "/agent/agents/:slug/library/file", access: "deny-remote", src: "routes/agents.ts", why: "deletes from the Agent library" },
@@ -237,6 +719,8 @@ var ENGINE_ROUTES = [
   { method: "GET", path: "/agent/plugins/:id/settings", access: "deny-remote", src: "routes/plugins.ts", why: "plugin settings may hold secrets" },
   { method: "PUT", path: "/agent/plugins/:id/settings", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
   { method: "GET", path: "/agent/plugins/:id/source", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
+  { method: "GET", path: "/agent/plugins/external-tools", access: "deny-remote", src: "routes/plugins.ts", why: "plugin tools for the local Desktop MCP only; the handler also refuses remote callers" },
+  { method: "POST", path: "/agent/plugins/external-tools/call", access: "deny-remote", src: "routes/plugins.ts", why: "runs a plugin tool; local Desktop MCP only" },
   { method: "POST", path: "/agent/plugins/install", access: "deny-remote", src: "routes/plugins.ts", why: "installs code (design appendix C)" },
   { method: "POST", path: "/agent/plugins/rescan", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
   { method: "POST", path: "/agent/reply-segments", access: "allow", src: "routes/plugins.ts", why: "chat bubble segmentation helper (read-only)" },
@@ -255,6 +739,9 @@ var ENGINE_ROUTES = [
   { method: "GET", path: "/agent/project-context/icon", access: "allow", src: "routes/projectContext.ts", why: "project icon" },
   { method: "POST", path: "/agent/project-context/icon", access: "deny-remote", src: "routes/projectContext.ts", why: "project icon write" },
   { method: "POST", path: "/agent/project-context/init", access: "deny-remote", src: "routes/projectContext.ts", why: "project instruction write (design appendix C)" },
+  { method: "DELETE", path: "/agent/project-context/memory", access: "deny-remote", src: "routes/projectContext.ts", why: "project memory delete (host-only store; the route itself also refuses remote origin)" },
+  { method: "POST", path: "/agent/project-context/memory/candidate", access: "deny-remote", src: "routes/projectContext.ts", why: "adopt / dismiss one pending project-memory candidate (host-only store; the route itself also refuses remote origin)" },
+  { method: "POST", path: "/agent/project-context/memory/restore", access: "deny-remote", src: "routes/projectContext.ts", why: "put back one sentence removed by a project-memory compaction (host-only store; the route itself also refuses remote origin)" },
   { method: "GET", path: "/agent/project-context/settings", access: "allow", src: "routes/projectContext.ts", why: "read project settings" },
   { method: "PUT", path: "/agent/project-context/settings", access: "deny-remote", src: "routes/projectContext.ts", why: "project settings write (design appendix C)" },
   { method: "POST", path: "/agent/project-context/skills", access: "deny-remote", src: "routes/projectContext.ts", why: "project skill write (design appendix C)" },
@@ -759,7 +1246,7 @@ function startUnitWeb(deps, opts) {
       return null;
     }
   };
-  const json = (res, status, body) => {
+  const json2 = (res, status, body) => {
     const buf = Buffer.from(JSON.stringify(body));
     res.writeHead(status, { "Content-Type": "application/json", "Content-Length": buf.length });
     res.end(buf);
@@ -790,7 +1277,7 @@ function startUnitWeb(deps, opts) {
   const proxyEngine = (req, res, path, via, caller) => {
     const engine = deps.getEngine();
     if (!engine.url) {
-      json(res, 503, { detail: "\u672C\u673A\u5F15\u64CE\u672A\u5C31\u7EEA", code: "ENGINE_NOT_READY" });
+      json2(res, 503, { detail: "\u672C\u673A\u5F15\u64CE\u672A\u5C31\u7EEA", code: "ENGINE_NOT_READY" });
       return;
     }
     const target = new URL(engine.url);
@@ -822,7 +1309,7 @@ function startUnitWeb(deps, opts) {
       res.on("close", () => upRes.destroy());
     });
     up.on("error", (e) => {
-      if (!res.headersSent) json(res, 502, { detail: `\u672C\u673A\u5F15\u64CE\u4E0D\u53EF\u8FBE: ${e.message}` });
+      if (!res.headersSent) json2(res, 502, { detail: `\u672C\u673A\u5F15\u64CE\u4E0D\u53EF\u8FBE: ${e.message}` });
     });
     req.pipe(up);
   };
@@ -837,13 +1324,13 @@ function startUnitWeb(deps, opts) {
     if (!extname(rel)) rel = "/index.html";
     const norm = normalize(rel).replace(/^([/\\])+/, "");
     if (norm.startsWith("..")) {
-      json(res, 400, { detail: "bad path" });
+      json2(res, 400, { detail: "bad path" });
       return;
     }
     try {
       const [rootReal, fileReal] = await Promise.all([realpath(dist2), realpath(`${dist2}/${norm}`)]);
       if (!fileReal.startsWith(rootReal + sep)) {
-        json(res, 404, { detail: "not found" });
+        json2(res, 404, { detail: "not found" });
         return;
       }
       let buf = await readFile(fileReal);
@@ -866,31 +1353,31 @@ function startUnitWeb(deps, opts) {
       res.writeHead(200, h);
       res.end(buf);
     } catch {
-      json(res, 404, { detail: "not found" });
+      json2(res, 404, { detail: "not found" });
     }
   };
   const hostFileRequest = (req, res, url) => {
     const info = authInfo(req);
     if (!info.ok) {
-      json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+      json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
       return null;
     }
     return { p: String(new URL(url, "http://x").searchParams.get("path") || ""), via: info.via };
   };
   const sendHostDownload = async (res, p) => {
     if (!deps.openHostFile) {
-      json(res, 501, { detail: "Host file download is not available on this device", code: "HOST_DOWNLOAD_UNSUPPORTED" });
+      json2(res, 501, { detail: "Host file download is not available on this device", code: "HOST_DOWNLOAD_UNSUPPORTED" });
       return;
     }
     const f = await deps.openHostFile(p);
     if (!f) {
-      json(res, 404, { detail: "not readable" });
+      json2(res, 404, { detail: "not readable" });
       return;
     }
     if (f.size > HOST_DOWNLOAD_MAX_BYTES) {
       await f.fh.close().catch(() => {
       });
-      json(res, 413, { detail: `File is larger than the ${HOST_DOWNLOAD_MAX_BYTES / 1048576} MB remote download limit`, code: "HOST_DOWNLOAD_TOO_LARGE", size: f.size, limit: HOST_DOWNLOAD_MAX_BYTES });
+      json2(res, 413, { detail: `File is larger than the ${HOST_DOWNLOAD_MAX_BYTES / 1048576} MB remote download limit`, code: "HOST_DOWNLOAD_TOO_LARGE", size: f.size, limit: HOST_DOWNLOAD_MAX_BYTES });
       return;
     }
     const name = p.split(/[\\/]/).filter(Boolean).pop() || "download";
@@ -935,7 +1422,7 @@ function startUnitWeb(deps, opts) {
     if (!ownerProjection && lockedNow()) {
       const p = plainPath(req);
       if (!(p === "/engine" || p.startsWith("/engine/")) && p !== "/vault/rpc" && !lockedRequestAllowed(req.method || "GET", p)) {
-        json(res, 423, REMOTE_LOCKED_BODY);
+        json2(res, 423, REMOTE_LOCKED_BODY);
         return;
       }
     }
@@ -956,50 +1443,50 @@ function startUnitWeb(deps, opts) {
     if (deps.projection?.mode === "public") {
       if (await deps.account?.handle(path, req, res)) return;
       if (req.method !== "GET" && req.method !== "HEAD") {
-        json(res, 405, { detail: "Read-only projection" });
+        json2(res, 405, { detail: "Read-only projection" });
         return;
       }
       if (path === "/unit/whoami") {
-        json(res, 200, { ok: true, scope: "shell" });
+        json2(res, 200, { ok: true, scope: "shell" });
         return;
       }
       if (path === "/unit/plugins") {
-        json(res, 200, { appVersion: deps.meta.version, plugins: await deps.readPlugins() });
+        json2(res, 200, { appVersion: deps.meta.version, plugins: await deps.readPlugins() });
         return;
       }
       if (path === "/unit/spaces") {
-        json(res, 200, { spaces: await deps.readSpaces() });
+        json2(res, 200, { spaces: await deps.readSpaces() });
         return;
       }
       if (path === "/unit/config") {
-        json(res, 200, { config: {} });
+        json2(res, 200, { config: {} });
         return;
       }
       if (path === "/unit/providers") {
-        json(res, 200, { providers: [] });
+        json2(res, 200, { providers: [] });
         return;
       }
       if (path === "/unit/meta") {
-        json(res, 200, { ...deps.meta, pair: false, projection: "public", account: deps.account?.metadata(), capabilities: deps.projection?.capabilities?.() });
+        json2(res, 200, { ...deps.meta, pair: false, projection: "public", account: deps.account?.metadata(), capabilities: deps.projection?.capabilities?.() });
         return;
       }
       if (/^\/(?:unit|vault|engine)(?:\/|$)/.test(path)) {
-        json(res, 403, { detail: "Host capability is not published" });
+        json2(res, 403, { detail: "Host capability is not published" });
         return;
       }
     }
     if (path === "/unit/meta" && req.method === "GET") {
-      json(res, 200, { ...deps.meta, pair: !deps.projection, ...deps.projection?.mode === "local" ? { projection: "local", localCapabilities: deps.projection.localCapabilities?.() } : {} });
+      json2(res, 200, { ...deps.meta, pair: !deps.projection, ...deps.projection?.mode === "local" ? { projection: "local", localCapabilities: deps.projection.localCapabilities?.() } : {} });
       return;
     }
     if (deps.projection?.mode === "local" && path.startsWith("/unit/pair/")) {
-      json(res, 403, { detail: "Use the workspace owner access key" });
+      json2(res, 403, { detail: "Use the workspace owner access key" });
       return;
     }
     if (path === "/unit/pair/request" && req.method === "POST") {
       const prevId = pendingByIp.get(ip);
       if (prevId && pending.get(prevId)?.status === "pending") {
-        json(res, 429, { detail: "\u5DF2\u6709\u5F85\u786E\u8BA4\u7684\u914D\u5BF9\u8BF7\u6C42", code: "PAIR_PENDING" });
+        json2(res, 429, { detail: "\u5DF2\u6709\u5F85\u786E\u8BA4\u7684\u914D\u5BF9\u8BF7\u6C42", code: "PAIR_PENDING" });
         return;
       }
       let name = "\u672A\u547D\u540D\u8BBE\u5907";
@@ -1017,7 +1504,7 @@ function startUnitWeb(deps, opts) {
       };
       pending.set(p.id, p);
       pendingByIp.set(ip, p.id);
-      json(res, 200, { requestId: p.id, code: p.code, ttlMs: PAIR_TTL_MS });
+      json2(res, 200, { requestId: p.id, code: p.code, ttlMs: PAIR_TTL_MS });
       void deps.confirmPair({ name: p.name, code: p.code, ip }).then(async (ok) => {
         const live = pending.get(p.id);
         if (!live || live.status !== "pending" || live.expires < Date.now()) return;
@@ -1037,34 +1524,34 @@ function startUnitWeb(deps, opts) {
       const id = String(new URL(url, "http://x").searchParams.get("id") || "");
       const p = pending.get(id);
       if (!p || p.expires < Date.now()) {
-        json(res, 200, { status: "expired" });
+        json2(res, 200, { status: "expired" });
         return;
       }
       if (p.status === "approved" && p.token) {
         const token = p.token;
         pending.delete(id);
         pendingByIp.delete(p.ip);
-        json(res, 200, { status: "approved", token });
+        json2(res, 200, { status: "approved", token });
         return;
       }
-      json(res, 200, { status: p.status });
+      json2(res, 200, { status: p.status });
       return;
     }
     if (path === "/unit/whoami" && req.method === "GET") {
       if (!authed(req)) {
-        json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+        json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
         return;
       }
-      json(res, 200, { ok: true });
+      json2(res, 200, { ok: true });
       return;
     }
     if (path === "/unit/p2p/offer" && req.method === "POST") {
       if (!authed(req)) {
-        json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+        json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
         return;
       }
       if (!deps.p2pAnswer) {
-        json(res, 501, { detail: "\u672C\u7AEF\u4E0D\u652F\u6301 P2P \u76F4\u8FDE", code: "P2P_UNSUPPORTED" });
+        json2(res, 501, { detail: "\u672C\u7AEF\u4E0D\u652F\u6301 P2P \u76F4\u8FDE", code: "P2P_UNSUPPORTED" });
         return;
       }
       let offer = "";
@@ -1073,38 +1560,38 @@ function startUnitWeb(deps, opts) {
       } catch {
       }
       if (!offer) {
-        json(res, 400, { detail: "\u7F3A offer SDP" });
+        json2(res, 400, { detail: "\u7F3A offer SDP" });
         return;
       }
       try {
-        json(res, 200, { sdp: await deps.p2pAnswer(offer) });
+        json2(res, 200, { sdp: await deps.p2pAnswer(offer) });
       } catch (e) {
-        json(res, 500, { detail: `P2P \u5E94\u7B54\u5931\u8D25: ${e?.message || e}` });
+        json2(res, 500, { detail: `P2P \u5E94\u7B54\u5931\u8D25: ${e?.message || e}` });
       }
       return;
     }
     if (path === "/unit/plugins" && req.method === "GET") {
       if (!authed(req)) {
-        json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+        json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
         return;
       }
-      json(res, 200, { appVersion: deps.meta.version, plugins: await deps.readPlugins() });
+      json2(res, 200, { appVersion: deps.meta.version, plugins: await deps.readPlugins() });
       return;
     }
     if (path === "/unit/spaces" && req.method === "GET") {
       if (!authed(req)) {
-        json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+        json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
         return;
       }
-      json(res, 200, { spaces: await deps.readSpaces() });
+      json2(res, 200, { spaces: await deps.readSpaces() });
       return;
     }
     if (path === "/unit/providers" && req.method === "GET") {
       if (!authed(req)) {
-        json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+        json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
         return;
       }
-      json(res, 200, { providers: await deps.readProviders() });
+      json2(res, 200, { providers: await deps.readProviders() });
       return;
     }
     if ((path === "/unit/hostfile" || path === "/unit/hostfile/download") && req.method === "GET") {
@@ -1116,78 +1603,78 @@ function startUnitWeb(deps, opts) {
       }
       const f = await deps.readHostFile(q.p, q.via === "tunnel" ? 4 * 1024 * 1024 : void 0);
       if (!f) {
-        json(res, 404, { detail: "not readable" });
+        json2(res, 404, { detail: "not readable" });
         return;
       }
-      json(res, 200, f);
+      json2(res, 200, f);
       return;
     }
     if ((path === "/unit/hostdir" || path === "/unit/hoststat") && req.method === "GET") {
       if (!authed(req)) {
-        json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+        json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
         return;
       }
       const p = String(new URL(url, "http://x").searchParams.get("path") || "");
       const r = path === "/unit/hostdir" ? await deps.readHostDir(p) : await deps.readHostStat(p);
       if (!r) {
-        json(res, 404, { detail: "not readable" });
+        json2(res, 404, { detail: "not readable" });
         return;
       }
-      json(res, 200, path === "/unit/hostdir" ? { entries: r } : r);
+      json2(res, 200, path === "/unit/hostdir" ? { entries: r } : r);
       return;
     }
     if (path === "/unit/config" && (req.method === "GET" || req.method === "PUT")) {
       if (!authed(req)) {
-        json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+        json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
         return;
       }
       if (req.method === "GET") {
-        json(res, 200, { config: await deps.readConfig() });
+        json2(res, 200, { config: await deps.readConfig() });
         return;
       }
       let patch;
       try {
         patch = JSON.parse(await readBody(req));
       } catch {
-        json(res, 400, { detail: "bad body" });
+        json2(res, 400, { detail: "bad body" });
         return;
       }
-      json(res, 200, { config: await deps.writeConfig(patch && typeof patch === "object" ? patch : {}) });
+      json2(res, 200, { config: await deps.writeConfig(patch && typeof patch === "object" ? patch : {}) });
       return;
     }
     if (path === "/unit/remote-access" && req.method === "GET" || path === "/unit/remote-access/request" && req.method === "POST") {
       const info = authInfo(req);
       if (!info.ok) {
-        json(res, 401, { detail: "Not paired", code: "UNPAIRED" });
+        json2(res, 401, { detail: "Not paired", code: "UNPAIRED" });
         return;
       }
       const rc = resolveCaller(req, info);
       if (!rc.ok) {
-        json(res, 403, BAD_CALLER_BODY);
+        json2(res, 403, BAD_CALLER_BODY);
         return;
       }
       const caller = callerOf(info.via, pairInfo(info), rc.caller);
       const ra = deps.remoteAccess;
       if (!ra) {
-        json(res, 200, { remoteSessions: false, principal: caller.kind === "paired" ? "lan" : caller.kind, caller: caller.kind === "paired" ? "paired" : "unconfirmed", maxApprovalMode: "auto-edit" });
+        json2(res, 200, { remoteSessions: false, principal: caller.kind === "paired" ? "lan" : caller.kind, caller: caller.kind === "paired" ? "paired" : "unconfirmed", maxApprovalMode: "auto-edit" });
         return;
       }
-      json(res, 200, path === "/unit/remote-access" ? ra.status(caller) : await ra.request(caller));
+      json2(res, 200, path === "/unit/remote-access" ? ra.status(caller) : await ra.request(caller));
       return;
     }
     if (path === "/engine" || path.startsWith("/engine/")) {
       const method = req.method || "GET";
       const info = authInfo(req);
       if (!info.ok) {
-        json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+        json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
         return;
       }
       if (isLocalOnlyEnginePath(url)) {
         if (!engineTarget(url.slice("/engine".length))) {
-          json(res, 400, { detail: "Ambiguous engine path", code: "BAD_PATH" });
+          json2(res, 400, { detail: "Ambiguous engine path", code: "BAD_PATH" });
           return;
         }
-        json(res, 403, LOCAL_ONLY_BODY);
+        json2(res, 403, LOCAL_ONLY_BODY);
         return;
       }
       if (ownerProjection) {
@@ -1196,26 +1683,26 @@ function startUnitWeb(deps, opts) {
       }
       const target = engineTarget(url.slice("/engine".length));
       if (!target) {
-        json(res, 400, { detail: "Ambiguous engine path", code: "BAD_PATH" });
+        json2(res, 400, { detail: "Ambiguous engine path", code: "BAD_PATH" });
         return;
       }
       if (engineRouteAccess(method, target.path) !== "allow") {
-        json(res, 403, LOCAL_ONLY_BODY);
+        json2(res, 403, LOCAL_ONLY_BODY);
         return;
       }
       const rc = resolveCaller(req, info);
       if (!rc.ok) {
-        json(res, 403, BAD_CALLER_BODY);
+        json2(res, 403, BAD_CALLER_BODY);
         return;
       }
       if (lockedNow() && !lockedEngineAllowed(method, target.path)) {
-        json(res, 423, REMOTE_LOCKED_BODY);
+        json2(res, 423, REMOTE_LOCKED_BODY);
         return;
       }
       const caller = callerOf(info.via, pairInfo(info), rc.caller);
       const g = deps.remoteAccess ? deps.remoteAccess.gateEngine({ method, path: target.path, via: info.via, caller }) : baseTierOnly(method, target.path);
       if (!g.ok) {
-        json(res, g.status, g.body);
+        json2(res, g.status, g.body);
         return;
       }
       proxyEngine(req, res, target.path + target.query, info.via, rc.caller);
@@ -1224,7 +1711,7 @@ function startUnitWeb(deps, opts) {
     if (path.startsWith("/vault/")) {
       const vault = deps.vault();
       if (!vault) {
-        json(res, 503, { detail: "\u672C\u673A\u667A\u5E93\u9762\u672A\u5C31\u7EEA", code: "VAULT_NOT_READY" });
+        json2(res, 503, { detail: "\u672C\u673A\u667A\u5E93\u9762\u672A\u5C31\u7EEA", code: "VAULT_NOT_READY" });
         return;
       }
       const q = new URL(url, "http://x").searchParams;
@@ -1232,52 +1719,52 @@ function startUnitWeb(deps, opts) {
       const assetAuthed = () => at !== "" && assetTokenLive(at) || authed(req);
       if (path === "/vault/rpc" && req.method === "POST") {
         if (!authed(req)) {
-          json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+          json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
           return;
         }
         let body;
         try {
           body = JSON.parse(await readBody(req, 32 * 1024 * 1024));
         } catch {
-          json(res, 400, { detail: "bad body" });
+          json2(res, 400, { detail: "bad body" });
           return;
         }
         const ch = String(body.ch || "");
         if (!VAULT_RPC_ALLOW.has(ch)) {
-          json(res, 400, { detail: `\u901A\u9053\u4E0D\u53EF\u8FDC\u7A0B\u8C03\u7528: ${ch}`, code: "VAULT_CH_DENIED" });
+          json2(res, 400, { detail: `\u901A\u9053\u4E0D\u53EF\u8FDC\u7A0B\u8C03\u7528: ${ch}`, code: "VAULT_CH_DENIED" });
           return;
         }
         if (!ownerProjection && VAULT_RPC_LOCAL_ONLY.has(ch)) {
-          json(res, 403, LOCAL_ONLY_BODY);
+          json2(res, 403, LOCAL_ONLY_BODY);
           return;
         }
         if (!ownerProjection && lockedNow() && !VAULT_RPC_READ.has(ch)) {
-          json(res, 423, REMOTE_LOCKED_BODY);
+          json2(res, 423, REMOTE_LOCKED_BODY);
           return;
         }
         const origin = String(body.client || "").slice(0, 64) || null;
         try {
           const result = await vault.call(ch, decodeRpcArgs(Array.isArray(body.args) ? body.args : []), origin);
-          json(res, 200, { ok: true, result: encodeRpcResult(result) ?? null });
+          json2(res, 200, { ok: true, result: encodeRpcResult(result) ?? null });
         } catch (e) {
-          json(res, 200, { ok: false, error: String(e?.message || e) });
+          json2(res, 200, { ok: false, error: String(e?.message || e) });
         }
         return;
       }
       if (path === "/vault/asset-token" && req.method === "POST") {
         const info = authInfo(req);
         if (!info.ok) {
-          json(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
+          json2(res, 401, { detail: "\u672A\u914D\u5BF9", code: "UNPAIRED" });
           return;
         }
         const token = randomBytes(16).toString("hex");
         assetTokens.set(token, { exp: Date.now() + ASSET_TTL_MS, pairHash: info.pairHash });
-        json(res, 200, { token, ttlSec: ASSET_TTL_MS / 1e3 });
+        json2(res, 200, { token, ttlSec: ASSET_TTL_MS / 1e3 });
         return;
       }
       if (path === "/vault/asset" && (req.method === "GET" || req.method === "HEAD")) {
         if (!assetAuthed()) {
-          json(res, 401, { detail: "\u8D44\u6E90\u4EE4\u724C\u65E0\u6548", code: "ASSET_TOKEN" });
+          json2(res, 401, { detail: "\u8D44\u6E90\u4EE4\u724C\u65E0\u6548", code: "ASSET_TOKEN" });
           return;
         }
         const exact = q.get("path");
@@ -1288,12 +1775,12 @@ function startUnitWeb(deps, opts) {
         }
         const real = abs ? await underVaultReal(abs, vault.root()) : null;
         if (!real) {
-          json(res, 404, { detail: "not found" });
+          json2(res, 404, { detail: "not found" });
           return;
         }
         const stream = createReadStream(real);
         stream.on("error", () => {
-          if (!res.headersSent) json(res, 404, { detail: "not found" });
+          if (!res.headersSent) json2(res, 404, { detail: "not found" });
           else res.destroy();
         });
         stream.once("open", () => {
@@ -1308,7 +1795,7 @@ function startUnitWeb(deps, opts) {
       }
       if (path === "/vault/events" && req.method === "GET") {
         if (!assetAuthed()) {
-          json(res, 401, { detail: "\u8D44\u6E90\u4EE4\u724C\u65E0\u6548", code: "ASSET_TOKEN" });
+          json2(res, 401, { detail: "\u8D44\u6E90\u4EE4\u724C\u65E0\u6548", code: "ASSET_TOKEN" });
           return;
         }
         const viaAt = at !== "" && assetTokenLive(at);
@@ -1342,11 +1829,11 @@ function startUnitWeb(deps, opts) {
         });
         return;
       }
-      json(res, 404, { detail: "not found" });
+      json2(res, 404, { detail: "not found" });
       return;
     }
     if (req.method !== "GET" && req.method !== "HEAD") {
-      json(res, 405, { detail: "method not allowed" });
+      json2(res, 405, { detail: "method not allowed" });
       return;
     }
     await serveStatic(res, path);
@@ -1354,7 +1841,7 @@ function startUnitWeb(deps, opts) {
   const server = http.createServer((req, res) => {
     void handler(req, res).catch((e) => {
       deps.log(`[unit-web] \u8BF7\u6C42\u5904\u7406\u5931\u8D25: ${e?.message || e}`);
-      if (!res.headersSent) json(res, 500, { detail: "internal error" });
+      if (!res.headersSent) json2(res, 500, { detail: "internal error" });
     });
   });
   server.requestTimeout = 60 * 60 * 1e3;
@@ -1398,114 +1885,8 @@ var basic_default = {
   unit: true
 };
 
-// unit/packages.ts
-import { readFile as readFile2, readdir, realpath as realpath2, stat } from "node:fs/promises";
-import { isAbsolute, resolve, sep as sep2 } from "node:path";
-
-// desktop/shared/amadeus/pluginFiles.ts
-function isSafePluginExt(extension) {
-  if (typeof extension !== "string") return false;
-  const value = extension.trim().toLowerCase();
-  if (!value.startsWith(".") || value.length < 2 || value.length > 40) return false;
-  if (value === ".md" || value === ".markdown" || value === ".txt") return false;
-  return value.endsWith(".md") ? /^\.[a-z0-9][a-z0-9-]*\.md$/.test(value) : /^\.[a-z0-9][a-z0-9.-]*$/.test(value);
-}
-
-// desktop/shared/nativeFeatures.ts
-var NATIVE_FEATURE_IDS = ["amadeus", "tangu", "calendar", "automation", "public"];
-var NATIVE_FEATURE_SPACES = {
-  amadeus: ["amadeus"],
-  tangu: ["tangu"],
-  calendar: ["calendar"],
-  automation: ["automation"],
-  public: ["public"]
-};
-var isNativeFeatureId = (value) => typeof value === "string" && NATIVE_FEATURE_IDS.includes(value);
-function nativeFeatureSpaceIds(features) {
-  return [...new Set(features.flatMap((feature) => NATIVE_FEATURE_SPACES[feature]))];
-}
-
-// unit/packages.ts
-var validId = (id) => typeof id === "string" && /^[a-z][a-z0-9-]*$/.test(id);
-function versionAtLeast(actual, minimum) {
-  const parse = (v) => /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(v) ? v.split(/[.+-]/).slice(0, 3).map(Number) : null;
-  const a = parse(actual), b = parse(minimum);
-  if (!a || !b) throw new Error("Invalid semantic version");
-  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
-  return true;
-}
-async function packagePath(root, relative2) {
-  if (typeof relative2 !== "string" || !relative2 || isAbsolute(relative2) || relative2.split(/[\\/]/).includes("..")) throw new Error("Plugin file escapes its package");
-  const file2 = await realpath2(resolve(root, relative2));
-  if (!file2.startsWith(root + sep2)) throw new Error("Plugin file escapes its package");
-  if (!(await stat(file2)).isFile()) throw new Error("Plugin entry must be a regular file");
-  return file2;
-}
-async function readPackage(dir, appVersion) {
-  const root = await realpath2(dir);
-  const manifest = JSON.parse(await readFile2(await packagePath(root, "manifest.json"), "utf8"));
-  if (!validId(manifest.id) || manifest.apiVersion !== 1) throw new Error("Invalid plugin identity or unsupported plugin API");
-  versionAtLeast(manifest.version, "0.0.0");
-  if (manifest.minAppVersion && appVersion && !versionAtLeast(appVersion, manifest.minAppVersion)) throw new Error(`Plugin ${manifest.id} requires Unit ${manifest.minAppVersion}`);
-  if (manifest.requires && (!Array.isArray(manifest.requires) || !manifest.requires.every(validId))) throw new Error("Invalid plugin dependencies");
-  const result = { root, manifest, spaces: [], spaceIds: /* @__PURE__ */ new Set() };
-  if (manifest.frontend) {
-    const { features, services = {} } = manifest.frontend;
-    if (!Array.isArray(features) || !features.length || !features.every(isNativeFeatureId) || new Set(features).size !== features.length) throw new Error("Invalid native frontend features");
-    for (const [id, service] of Object.entries(services)) {
-      if (!["amadeus", "tangu"].includes(id) || !features.includes(id) || !service || service.adapter !== "forsion-cloud-v1" || typeof service.apiBase !== "string" || !/^\/(?:[A-Za-z0-9_-]+\/?)+$/.test(service.apiBase) || id === "tangu" && service.execution !== "fleet" || id === "amadeus" && service.collaboration !== void 0 && typeof service.collaboration !== "boolean") {
-        throw new Error("Invalid frontend cloud service");
-      }
-    }
-    for (const id of nativeFeatureSpaceIds(features)) result.spaceIds.add(id);
-  }
-  if (manifest.main) {
-    const code = await readFile2(await packagePath(root, manifest.main), "utf8");
-    result.ui = {
-      id: manifest.id,
-      name: manifest.name,
-      nameEn: manifest.nameEn,
-      version: manifest.version,
-      apiVersion: manifest.apiVersion,
-      minAppVersion: manifest.minAppVersion,
-      description: manifest.description,
-      descriptionEn: manifest.descriptionEn,
-      onboarding: manifest.onboarding,
-      fileExtensions: Array.isArray(manifest.fileExtensions) ? manifest.fileExtensions.filter(isSafePluginExt).map((v) => v.trim().toLowerCase()).slice(0, 8) : [],
-      code
-    };
-  }
-  if (manifest.runtime) {
-    if (manifest.runtime.apiVersion !== 1) throw new Error("Unsupported local runtime API");
-    if (manifest.runtime.dependencies?.mode === "npm-ci") throw new Error("Local runtime dependencies must be bundled");
-    result.runtimeEntry = await packagePath(root, manifest.runtime.main);
-  }
-  if (manifest.backend) {
-    if (manifest.backend.apiVersion !== 1) throw new Error("Unsupported backend plugin API");
-    result.backendEntry = await packagePath(root, manifest.backend.main);
-  }
-  for (const deps of [manifest.backend?.dependencies, manifest.runtime?.dependencies]) {
-    if (deps && !["bundled", "npm-ci"].includes(deps.mode)) throw new Error("Unsupported dependency mode");
-    const libc = process.platform === "linux" ? process.report?.getReport()?.header?.glibcVersionRuntime ? "glibc" : "musl" : void 0;
-    if (deps?.mode === "bundled" && (deps.platform && deps.platform !== process.platform || deps.libc && deps.libc !== libc || deps.arch && deps.arch !== process.arch || deps.nodeAbi && deps.nodeAbi !== process.versions.modules)) {
-      throw new Error("Plugin dependencies were built for a different OS, architecture, Node ABI, or libc");
-    }
-  }
-  if (!result.ui && !result.backendEntry && !result.runtimeEntry && !manifest.frontend) throw new Error("Plugin has no UI or backend entry");
-  const entries = await readdir(resolve(root, "spaces"), { withFileTypes: true }).catch((error) => {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const json = await readFile2(await packagePath(root, `spaces/${entry.name}/space.json`), "utf8");
-    const spec = JSON.parse(json);
-    if (!validId(spec.id) || result.spaceIds.has(spec.id)) throw new Error("Invalid or duplicate Space id");
-    result.spaceIds.add(spec.id);
-    result.spaces.push({ slug: entry.name, json, plugin: manifest.id });
-  }
-  return result;
-}
+// unit/host.ts
+init_packages();
 
 // unit/backendRunner.ts
 import http2 from "node:http";
@@ -1884,7 +2265,7 @@ var BackendSession = class {
         return;
       }
       try {
-        this.worker.postMessage({ type: "account-resolve", requestId, token });
+        this.worker.postMessage({ type: "account-resolve", requestId, token, purpose: options.purpose });
       } catch {
         finish(null, new Error("Account provider unavailable"));
       }
@@ -2062,7 +2443,7 @@ var AccountChanged = class extends Error {
 var preferences = new Set(UNIT_PREFERENCE_KEYS);
 function createAccountHttp(options) {
   const writes = /* @__PURE__ */ new Map();
-  const json = (res, status, body) => {
+  const json2 = (res, status, body) => {
     res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
     res.end(JSON.stringify(body));
   };
@@ -2106,33 +2487,37 @@ function createAccountHttp(options) {
     res.once("close", onClose);
     try {
       const bearer = /^Bearer (\S+)$/i.exec(String(req.headers.authorization || ""))?.[1];
-      const identity = bearer ? await provider.account.resolve(bearer, { signal: controller.signal }) : null;
+      const identity = bearer ? await provider.account.resolve(bearer, { signal: controller.signal, purpose: "administration" }) : null;
       if (!identity) {
-        json(res, 401, { error: "Authentication required" });
+        json2(res, 401, { error: "Authentication required" });
         return true;
       }
       if (options.provider()?.account !== provider.account) {
-        json(res, 503, { error: "Account provider changed" });
+        json2(res, 503, { error: "Account provider changed" });
         return true;
       }
       if (path === "/unit/account") {
-        json(res, req.method === "GET" ? 200 : 405, req.method === "GET" ? identity : { error: "Method not allowed" });
+        json2(res, req.method === "GET" ? 200 : 405, req.method === "GET" ? identity : { error: "Method not allowed" });
         return true;
       }
       const plugin = path.startsWith("/unit/plugin-data/") ? path.slice("/unit/plugin-data/".length) : null;
       if (plugin !== null && (!/^[a-zA-Z0-9_-]+$/.test(plugin) || !options.pluginActive(plugin))) {
-        json(res, 404, { error: "Plugin is not active" });
+        json2(res, 404, { error: "Plugin is not active" });
         return true;
       }
       if (req.method !== "GET" && req.method !== "PUT") {
-        json(res, 405, { error: "Method not allowed" });
+        json2(res, 405, { error: "Method not allowed" });
+        return true;
+      }
+      if (identity.role === "ADMIN_SCOPED") {
+        json2(res, 403, { error: "MCP tokens cannot access personal storage" });
         return true;
       }
       const dir = join(options.dataDir, "accounts", digest([provider.id, identity.userId, identity.tenantId, identity.workspaceId]));
       const file2 = join(dir, plugin === null ? "preferences.json" : digest(plugin) + ".json");
       if (req.method === "GET") {
         const value2 = await read(file2);
-        json(res, 200, plugin === null ? { config: value2 || {} } : { data: value2 });
+        json2(res, 200, plugin === null ? { config: value2 || {} } : { data: value2 });
         return true;
       }
       let size = 0;
@@ -2140,7 +2525,7 @@ function createAccountHttp(options) {
       for await (const chunk of req) {
         size += Buffer.byteLength(chunk);
         if (size > 1024 * 1024) {
-          json(res, 413, { error: "Data exceeds 1 MB" });
+          json2(res, 413, { error: "Data exceeds 1 MB" });
           return true;
         }
         chunks.push(Buffer.from(chunk));
@@ -2149,16 +2534,16 @@ function createAccountHttp(options) {
       try {
         input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
       } catch {
-        json(res, 400, { error: "Invalid JSON" });
+        json2(res, 400, { error: "Invalid JSON" });
         return true;
       }
       if (!input || typeof input !== "object" || Array.isArray(input) || plugin !== null && typeof input.data !== "string") {
-        json(res, 400, { error: "Invalid data" });
+        json2(res, 400, { error: "Invalid data" });
         return true;
       }
       const guard = async () => {
         controller.signal.throwIfAborted();
-        const current = await provider.account.resolve(bearer, { signal: controller.signal });
+        const current = await provider.account.resolve(bearer, { signal: controller.signal, purpose: "administration" });
         if (!current || digest(current) !== digest(identity) || options.provider()?.account !== provider.account) {
           throw new AccountChanged("Account changed");
         }
@@ -2166,10 +2551,10 @@ function createAccountHttp(options) {
       await guard();
       await mkdir(dir, { recursive: true, mode: 448 });
       const value = await write(file2, (previous) => plugin === null ? { ...previous, ...Object.fromEntries(Object.entries(input).filter(([key]) => preferences.has(key))) } : input.data, guard);
-      json(res, 200, plugin === null ? { config: value } : { ok: true });
+      json2(res, 200, plugin === null ? { config: value } : { ok: true });
       return true;
     } catch (error) {
-      if (!res.headersSent && !res.destroyed) json(
+      if (!res.headersSent && !res.destroyed) json2(
         res,
         error instanceof AccountChanged ? 401 : 503,
         { error: error instanceof AccountChanged ? "Account changed" : "Account service unavailable" }
@@ -2218,75 +2603,303 @@ async function createLocalWorkspace(dataDir, workspaceDir, vaultRoot) {
         const realRoot = await realpath3(root);
         if (actual === realRoot || actual.startsWith(realRoot + sep3)) return actual;
       }
-    } catch {
+    } catch {
+    }
+    return null;
+  };
+  return {
+    token,
+    device,
+    readConfig: async () => ({ ...await read(), homeDir: workspaceDir, defaultWorkspaceDir: workspaceDir }),
+    writeConfig: async (patch) => {
+      const job = writes.then(async () => {
+        const next = { ...await read(), ...pickUnitPreferences(patch) };
+        const tmp = `${file2}.${randomUUID4()}.tmp`;
+        await writeFile2(tmp, JSON.stringify(next), { mode: 384 });
+        await rename2(tmp, file2);
+      });
+      writes = job.catch(() => {
+      });
+      await job;
+      return { ...await read(), homeDir: workspaceDir, defaultWorkspaceDir: workspaceDir };
+    },
+    readHostFile: async (path, maxBytes = 50 * 1024 * 1024) => {
+      const real = await scoped(path);
+      if (!real) return null;
+      const st = await stat2(real);
+      if (!st.isFile()) return null;
+      const types = { ".md": "text/markdown", ".txt": "text/plain", ".json": "application/json", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".svg": "image/svg+xml", ".pdf": "application/pdf", ".mp4": "video/mp4", ".mp3": "audio/mpeg", ".wav": "audio/wav" };
+      const mimeType = types[extname2(real).toLowerCase()] || "application/octet-stream";
+      if (st.size > Math.min(maxBytes, 50 * 1024 * 1024)) return { mimeType, content: "", size: st.size, mtimeMs: st.mtimeMs, tooLarge: true };
+      return { mimeType, content: (await readFile4(real)).toString("base64"), size: st.size, mtimeMs: st.mtimeMs };
+    },
+    readHostDir: async (path) => {
+      const real = await scoped(path);
+      if (!real || !(await stat2(real)).isDirectory()) return null;
+      const entries = await readdir2(real, { withFileTypes: true });
+      const values = await Promise.all(entries.slice(0, 2e3).map(async (e) => {
+        const child = await scoped(resolve2(real, e.name));
+        if (!child) return null;
+        const st = await stat2(child);
+        return { name: e.name, isDir: st.isDirectory(), size: st.size, path: child };
+      }));
+      return values.filter((e) => !!e).sort((a, b) => Number(b.isDir) - Number(a.isDir) || a.name.localeCompare(b.name));
+    },
+    readHostStat: async (path) => {
+      const real = await scoped(path);
+      if (!real) return null;
+      const st = await stat2(real);
+      return { isDir: st.isDirectory(), mtimeMs: st.mtimeMs, birthtimeMs: st.birthtimeMs || null };
+    }
+  };
+}
+
+// unit/management.ts
+init_packages();
+init_releases();
+import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile5, rename as rename5 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { randomUUID as randomUUID8 } from "node:crypto";
+var MANAGEMENT_PATH = "/api/admin/unit";
+var actions = ["enable", "disable", "restart", "update", "migrate"];
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+var json = (res, status, value) => {
+  if (res.destroyed || res.writableEnded) return;
+  res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+  res.end(JSON.stringify(value));
+};
+async function createManagement(options) {
+  const file2 = join3(options.dataDir, "management-jobs.json");
+  let jobs = [], saving = Promise.resolve(), busy = false, closing = false, pending;
+  const requests = /* @__PURE__ */ new Set();
+  if (options.enabled) {
+    try {
+      jobs = JSON.parse(await readFile7(file2, "utf8"));
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    if (!Array.isArray(jobs) || jobs.length > 100) throw new Error("Invalid Unit job journal");
+    for (const job of jobs) if (job.state === "queued" || job.state === "running") {
+      job.state = "interrupted";
+      job.error = "Unit stopped before completion; inspect current plugin state before retrying";
+      job.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  const save = () => {
+    const payload = JSON.stringify(jobs);
+    const next = saving.then(async () => {
+      await mkdir7(options.dataDir, { recursive: true, mode: 448 });
+      const temporary = file2 + "." + randomUUID8();
+      await writeFile5(temporary, payload, { mode: 384 });
+      await rename5(temporary, file2);
+    });
+    saving = next.catch(() => {
+    });
+    return next;
+  };
+  if (options.enabled && jobs.length) await save();
+  const handle = async (req, res) => {
+    const controller = new AbortController();
+    const cancel = () => {
+      if (!res.writableEnded) controller.abort();
+    };
+    res.once("close", cancel);
+    try {
+      if (!options.enabled || !options.execute) throw new HttpError(503, "Unit management is disabled; enable management.enabled in private unit.json");
+      if (closing) throw new HttpError(503, "Unit is stopping");
+      const provider = options.provider();
+      if (!provider) throw new HttpError(503, "Account authority is unavailable");
+      const token = /^Bearer (\S+)$/i.exec(String(req.headers.authorization || ""))?.[1];
+      if (!token || token.length > 16384) throw new HttpError(401, "Authentication required");
+      let permission = "unit.read";
+      const authorize = async () => {
+        if (closing) throw new HttpError(503, "Unit is stopping");
+        const identity = await provider.account.resolve(token, { signal: controller.signal, purpose: "administration" });
+        if (!identity) throw new HttpError(401, "Invalid or expired account");
+        if (identity.role !== "ADMIN" && !(identity.role === "ADMIN_SCOPED" && (identity.adminPermissions?.includes("*") || identity.adminPermissions?.includes(permission)))) throw new HttpError(403, "Administrator access required");
+        if (options.provider()?.account !== provider.account) throw new HttpError(503, "Account authority changed");
+        return identity;
+      };
+      const actor = await authorize();
+      const path = new URL(req.url, "http://unit.invalid").pathname;
+      if (req.method === "GET") {
+        if (path === MANAGEMENT_PATH + "/status") json(res, 200, { ...options.status(), management: { enabled: true, actions, busy } });
+        else if (path === MANAGEMENT_PATH + "/releases") json(res, 200, { releases: await listReleases(options.dataDir) });
+        else if (path === MANAGEMENT_PATH + "/operations") json(res, 200, { operations: [...jobs].reverse() });
+        else if (path.startsWith(MANAGEMENT_PATH + "/operations/")) {
+          const job = jobs.find((entry) => entry.id === path.slice((MANAGEMENT_PATH + "/operations/").length));
+          if (!job) throw new HttpError(404, "Operation not found");
+          json(res, 200, job);
+        } else throw new HttpError(404, "Unknown Unit management route");
+        return;
+      }
+      if (req.method !== "POST" || path !== MANAGEMENT_PATH + "/operations") throw new HttpError(405, "Method not allowed");
+      if (!/^application\/json(?:;|$)/i.test(String(req.headers["content-type"] || ""))) throw new HttpError(415, "JSON body required");
+      let size = 0;
+      const chunks = [];
+      req.setTimeout(5e3, () => req.destroy());
+      for await (const chunk of req) {
+        size += Buffer.byteLength(chunk);
+        if (size > 8192) throw new HttpError(413, "Operation body exceeds 8 KB");
+        chunks.push(Buffer.from(chunk));
+      }
+      req.setTimeout(0);
+      let input;
+      try {
+        input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      } catch {
+        throw new HttpError(400, "Invalid JSON");
+      }
+      if (!input || Array.isArray(input) || typeof input !== "object" || Object.keys(input).some((key) => !["action", "pluginId", "releaseId", "requestId", "confirm"].includes(key)) || !actions.includes(input.action) || !validId(input.pluginId) || !validReleaseId(input.requestId) || (input.action === "update" ? !validReleaseId(input.releaseId) : input.releaseId !== void 0)) throw new HttpError(400, "Invalid operation arguments");
+      if (input.confirm !== true) throw new HttpError(400, "confirm:true is required for Unit operations");
+      permission = input.action === "update" ? "unit.update" : input.action === "migrate" ? "unit.migrate" : "unit.lifecycle";
+      await authorize();
+      const previous = jobs.find((job) => job.id === input.requestId);
+      if (previous) {
+        if (previous.actor.userId !== actor.userId || previous.action !== input.action || previous.pluginId !== input.pluginId || previous.releaseId !== input.releaseId) throw new HttpError(409, "Request ID is already used for a different operation");
+        json(res, 200, previous);
+        return;
+      }
+      if (busy) throw new HttpError(409, "Another Unit operation is running");
+      if (provider.id === input.pluginId && ["disable", "migrate"].includes(input.action)) throw new HttpError(409, "Use local CLI for maintenance that stops the account authority");
+      busy = true;
+      try {
+        const status = options.status();
+        if (!status.plugins.some((plugin) => plugin.id === input.pluginId)) throw new HttpError(404, "Plugin is not installed");
+        let release;
+        if (input.action === "update") {
+          try {
+            release = await resolveRelease(options.dataDir, input.releaseId, input.pluginId, options.version, false);
+          } catch {
+            throw new HttpError(400, "Release is missing, incompatible, or its identity/content changed");
+          }
+        }
+        await authorize();
+        const job = {
+          id: input.requestId,
+          action: input.action,
+          pluginId: input.pluginId,
+          ...release ? { releaseId: input.releaseId } : {},
+          actor: { userId: actor.userId, username: actor.username },
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          state: "queued"
+        };
+        const priorJobs = jobs;
+        jobs = [...jobs.slice(-99), job];
+        try {
+          await save();
+        } catch (error) {
+          jobs = priorJobs;
+          throw error;
+        }
+        const run2 = async () => {
+          try {
+            await authorize();
+            job.state = "running";
+            await save();
+            if (release) {
+              job.phase = "verifying-release";
+              await save();
+              const verified = await resolveRelease(options.dataDir, input.releaseId, input.pluginId, options.version);
+              if (verified.item.sha256 !== release.item.sha256) throw new Error("Staged release changed during installation");
+              await authorize();
+            }
+            job.phase = "applying";
+            await save();
+            console.log(`[unit-management] ${job.id} ${job.action} ${job.pluginId} actor=${job.actor.userId}`);
+            await options.execute({ action: job.action, id: job.pluginId, ...release ? { path: release.path, releaseDigest: release.item.sha256 } : {} }, async () => {
+              await authorize();
+            });
+            job.state = "succeeded";
+          } catch (error) {
+            job.state = "failed";
+            const reason = error instanceof Error ? error.message : "";
+            job.error = error instanceof HttpError || [
+              "Disable dependent plugins first",
+              "Disable the plugin before migrating",
+              "Unit is stopping",
+              "Staged release changed during installation"
+            ].includes(reason) ? reason : "Operation failed; inspect plugin status. Updates attempt to restore the previous package.";
+          } finally {
+            job.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+            busy = false;
+            try {
+              await save();
+            } catch {
+              console.error(`[unit-management] Could not persist result for ${job.id}`);
+            }
+            console.log(`[unit-management] ${job.id} ${job.state}`);
+          }
+        };
+        let launched = false;
+        let done;
+        pending = new Promise((resolve8) => {
+          done = resolve8;
+        });
+        const launch = () => {
+          if (launched) return;
+          launched = true;
+          setTimeout(() => {
+            void run2().finally(done);
+          }, 100);
+        };
+        res.once("finish", launch);
+        res.once("close", launch);
+        if (res.destroyed || res.writableEnded) launch();
+        else json(res, 202, job);
+      } catch (error) {
+        busy = false;
+        throw error;
+      }
+    } catch (error) {
+      json(res, error instanceof HttpError ? error.status : 503, { error: error instanceof HttpError ? error.message : "Unit management is temporarily unavailable" });
+    } finally {
+      res.off("close", cancel);
     }
-    return null;
   };
   return {
-    token,
-    device,
-    readConfig: async () => ({ ...await read(), homeDir: workspaceDir, defaultWorkspaceDir: workspaceDir }),
-    writeConfig: async (patch) => {
-      const job = writes.then(async () => {
-        const next = { ...await read(), ...pickUnitPreferences(patch) };
-        const tmp = `${file2}.${randomUUID4()}.tmp`;
-        await writeFile2(tmp, JSON.stringify(next), { mode: 384 });
-        await rename2(tmp, file2);
-      });
-      writes = job.catch(() => {
-      });
-      await job;
-      return { ...await read(), homeDir: workspaceDir, defaultWorkspaceDir: workspaceDir };
-    },
-    readHostFile: async (path, maxBytes = 50 * 1024 * 1024) => {
-      const real = await scoped(path);
-      if (!real) return null;
-      const st = await stat2(real);
-      if (!st.isFile()) return null;
-      const types = { ".md": "text/markdown", ".txt": "text/plain", ".json": "application/json", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".svg": "image/svg+xml", ".pdf": "application/pdf", ".mp4": "video/mp4", ".mp3": "audio/mpeg", ".wav": "audio/wav" };
-      const mimeType = types[extname2(real).toLowerCase()] || "application/octet-stream";
-      if (st.size > Math.min(maxBytes, 50 * 1024 * 1024)) return { mimeType, content: "", size: st.size, mtimeMs: st.mtimeMs, tooLarge: true };
-      return { mimeType, content: (await readFile4(real)).toString("base64"), size: st.size, mtimeMs: st.mtimeMs };
-    },
-    readHostDir: async (path) => {
-      const real = await scoped(path);
-      if (!real || !(await stat2(real)).isDirectory()) return null;
-      const entries = await readdir2(real, { withFileTypes: true });
-      const values = await Promise.all(entries.slice(0, 2e3).map(async (e) => {
-        const child = await scoped(resolve2(real, e.name));
-        if (!child) return null;
-        const st = await stat2(child);
-        return { name: e.name, isDir: st.isDirectory(), size: st.size, path: child };
-      }));
-      return values.filter((e) => !!e).sort((a, b) => Number(b.isDir) - Number(a.isDir) || a.name.localeCompare(b.name));
+    route(req, res) {
+      const path = (req.url || "/").split("?")[0];
+      if (path !== MANAGEMENT_PATH && !path.startsWith(MANAGEMENT_PATH + "/")) return false;
+      const task = handle(req, res);
+      requests.add(task);
+      void task.then(() => requests.delete(task), () => requests.delete(task));
+      return true;
     },
-    readHostStat: async (path) => {
-      const real = await scoped(path);
-      if (!real) return null;
-      const st = await stat2(real);
-      return { isDir: st.isDirectory(), mtimeMs: st.mtimeMs, birthtimeMs: st.birthtimeMs || null };
+    async close() {
+      closing = true;
+      await Promise.allSettled([...requests]);
+      await pending;
+      await saving;
     }
   };
 }
 
 // unit/host.ts
+init_packages();
 var matches = (path, prefix) => prefix === "/" || path === prefix || path.startsWith(prefix + "/");
 var pathname = (url) => (url || "/").split("?")[0];
-async function startBasicUnit(config) {
+async function startBasicUnit(config, managementOptions = {}) {
   if (!config.instanceId || !config.name || !config.version) throw new Error("Unit identity is required");
-  await readFile5(resolve3(config.webDist, "index.html"));
-  const dataDir = resolve3(config.dataDir || resolve3(homedir(), ".forsion", "units", config.instanceId));
-  await mkdir3(dataDir, { recursive: true, mode: 448 });
+  await readFile8(resolve6(config.webDist, "index.html"));
+  const dataDir = resolve6(config.dataDir || resolve6(homedir(), ".forsion", "units", config.instanceId));
+  await mkdir8(dataDir, { recursive: true, mode: 448 });
   const workerFile = config.workerFile || fileURLToPath(new URL("./backendWorker.mjs", import.meta.url));
   if (config.workspace && config.workspace.mode !== "local") throw new Error("Invalid workspace mode");
   const local = config.workspace?.mode === "local";
-  const workspaceDir = resolve3(config.workspace?.path || resolve3(dataDir, "workspace"));
+  const workspaceDir = resolve6(config.workspace?.path || resolve6(dataDir, "workspace"));
   const records = /* @__PURE__ */ new Map();
   const runtimeVault = () => [...records.values()].find((r) => usable(r) && r.runtime?.vault)?.runtime?.vault || null;
   const runtimeEngine = () => [...records.values()].find((r) => usable(r) && r.runtime?.engine)?.runtime?.engine;
   const localWorkspace = local ? await createLocalWorkspace(dataDir, workspaceDir, () => runtimeVault()?.root() || null) : null;
   const prefix = config.basePath.replace(/\/$/, "") || "/";
   const protectedPaths = ["unit", "vault", "engine"].map((name) => (prefix === "/" ? "" : prefix) + "/" + name);
+  protectedPaths.push(MANAGEMENT_PATH);
   for (const entry of config.plugins) {
     const installation = typeof entry === "string" ? { path: entry } : { ...entry };
     const pack = await readPackage(installation.path, config.version);
@@ -2376,11 +2989,12 @@ async function startBasicUnit(config) {
     id,
     entry: rec.package.backendEntry,
     packageDir: rec.package.root,
-    dataDir: resolve3(dataDir, "plugins", id),
+    dataDir: resolve6(dataDir, "plugins", id),
     config: rec.installation.config || {},
     env: {
       ...rec.installation.config?.env || {},
       ...rec.installation.env,
+      UNIT_DATA_DIR: dataDir,
       PORT: String(web.port),
       UNIT_HTTP_ORIGIN: `http://${localHost}:${web.port}`
     },
@@ -2406,16 +3020,16 @@ async function startBasicUnit(config) {
     let backend, runtime;
     try {
       if (local && rec.package.runtimeEntry) {
-        const module = await import(pathToFileURL(rec.package.runtimeEntry).href + "?generation=" + randomUUID5());
+        const module = await import(pathToFileURL(rec.package.runtimeEntry).href + "?generation=" + randomUUID9());
         const factory = module.createRuntime || module.default;
         if (typeof factory !== "function") throw new Error("Local runtime has no factory");
-        await mkdir3(resolve3(dataDir, "plugins", id), { recursive: true, mode: 448 });
-        runtime = await factory({ packageDir: rec.package.root, dataDir: resolve3(dataDir, "plugins", id), workspaceDir, config: rec.installation.config || {}, log: (m) => console.log(`[plugin:${id}] ${m}`) });
+        await mkdir8(resolve6(dataDir, "plugins", id), { recursive: true, mode: 448 });
+        runtime = await factory({ packageDir: rec.package.root, dataDir: resolve6(dataDir, "plugins", id), workspaceDir, config: rec.installation.config || {}, log: (m) => console.log(`[plugin:${id}] ${m}`) });
         if (!runtime || typeof runtime.close !== "function") throw new Error("Invalid local runtime");
         if (runtime.vault && runtimeVault() || runtime.engine && runtimeEngine()) throw new Error("Local capability already has a provider");
       }
       if (rec.package.backendEntry) {
-        await mkdir3(resolve3(dataDir, "plugins", id), { recursive: true, mode: 448 });
+        await mkdir8(resolve6(dataDir, "plugins", id), { recursive: true, mode: 448 });
         backend = await startBackend(options(id, rec));
         if (backend.account && [...records.values()].some((r) => r !== rec && usable(r) && r.backend?.account)) {
           throw new Error("A Unit can activate only one account authority");
@@ -2498,11 +3112,30 @@ async function startBasicUnit(config) {
       return !!rec && usable(rec);
     }
   });
+  const management = await createManagement({
+    enabled: config.management?.enabled === true,
+    dataDir,
+    version: config.version,
+    provider: accountProvider,
+    execute: managementOptions.execute,
+    status: () => ({
+      instanceId: config.instanceId,
+      version: config.version,
+      pid: process.pid,
+      plugins: [...records.values()].map((r) => ({
+        id: r.package.manifest.id,
+        version: r.package.manifest.version,
+        state: r.state,
+        requires: r.package.manifest.requires || []
+      }))
+    })
+  });
   const web = await startUnitWeb({
     account: local ? void 0 : { metadata: () => accountProvider()?.account.metadata, handle: accountHttp },
     meta: { instanceId: config.instanceId, name: config.name, version: config.version },
     projection: { mode: local ? "local" : "public", basePath: config.basePath, product, capabilities, localCapabilities: () => ({ vault: !!runtimeVault(), engine: !!runtimeEngine()?.endpoint().url, host: !!runtimeEngine()?.endpoint().url }) },
     routeRequest: (req, res) => {
+      if (management.route(req, res)) return true;
       const path = pathname(req.url), backend = select(path);
       if (backend) {
         backend.handle(req, res);
@@ -2566,6 +3199,7 @@ async function startBasicUnit(config) {
   }
   return {
     ...web,
+    closeManagement: management.close,
     status: () => [...records.values()].map((r) => ({ id: r.package.manifest.id, version: r.package.manifest.version, state: r.state })),
     enable: (id) => serialize(() => activate(id)),
     disable: (id) => serialize(() => deactivate(id)),
@@ -2602,237 +3236,36 @@ async function startBasicUnit(config) {
       if (!rec.package.backendEntry) throw new Error("Plugin has no backend migration");
       await migrateBackend(options(id, rec));
     }),
-    close: () => serialize(async () => {
-      if (closing) return;
-      closing = true;
-      await web.close();
-      const errors = [];
-      for (const id of [...ordered].reverse()) {
-        try {
-          await deactivate(id, true);
-        } catch (error) {
-          errors.push(error);
+    close: async () => {
+      await management.close();
+      return serialize(async () => {
+        if (closing) return;
+        closing = true;
+        await web.close();
+        const errors = [];
+        for (const id of [...ordered].reverse()) {
+          try {
+            await deactivate(id, true);
+          } catch (error) {
+            errors.push(error);
+          }
         }
-      }
-      if (errors.length) throw new AggregateError(errors, "Some plugins failed to stop cleanly");
-    })
+        if (errors.length) throw new AggregateError(errors, "Some plugins failed to stop cleanly");
+      });
+    }
   };
 }
 
-// unit/config.ts
-import { readFile as readFile6, writeFile as writeFile3, rename as rename3, mkdir as mkdir4 } from "node:fs/promises";
-import { dirname, resolve as resolve4 } from "node:path";
-import { randomUUID as randomUUID6 } from "node:crypto";
-async function readConfig(file2) {
-  const path = resolve4(file2), root = dirname(path);
-  const config = JSON.parse(await readFile6(path, "utf8"));
-  if (!Array.isArray(config.plugins)) throw new Error("unit.json plugins must be an array");
-  config.webDist = resolve4(root, config.webDist);
-  config.dataDir = resolve4(root, config.dataDir || "data");
-  if (config.workspace?.path) config.workspace.path = resolve4(root, config.workspace.path);
-  if (config.workerFile) config.workerFile = resolve4(root, config.workerFile);
-  config.plugins = config.plugins.map((p) => typeof p === "string" ? { path: resolve4(root, p) } : { ...p, path: resolve4(root, p.path) });
-  return config;
-}
-async function writeConfig(file2, config) {
-  await mkdir4(dirname(resolve4(file2)), { recursive: true, mode: 448 });
-  const temp = `${file2}.${randomUUID6()}.tmp`;
-  await writeFile3(temp, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
-  await rename3(temp, file2);
-}
-var installations = (config) => config.plugins;
-
-// unit/install.ts
-import { cp, mkdir as mkdir6, readdir as readdir3, realpath as realpath4, rm as rm3, lstat, open, readlink, symlink } from "node:fs/promises";
-import { dirname as dirname3, resolve as resolve6, sep as sep4, relative, isAbsolute as isAbsolute3 } from "node:path";
-import { randomUUID as randomUUID7 } from "node:crypto";
-import { spawn } from "node:child_process";
-
-// unit/control.ts
-import net from "node:net";
-import { chmod, rm as rm2, mkdir as mkdir5 } from "node:fs/promises";
-import { resolve as resolve5, dirname as dirname2 } from "node:path";
-import { tmpdir } from "node:os";
-import { createHash as createHash4 } from "node:crypto";
-var controlAddress = (dataDir) => process.platform === "win32" ? `\\\\.\\pipe\\forsion-unit-${createHash4("sha256").update(resolve5(dataDir)).digest("hex").slice(0, 24)}` : resolve5(tmpdir(), `forsion-unit-${process.getuid?.() ?? "user"}`, createHash4("sha256").update(resolve5(dataDir)).digest("hex").slice(0, 24) + ".sock");
-async function sendControl(dataDir, command) {
-  return new Promise((resolveReply, reject) => {
-    const socket = net.connect(controlAddress(dataDir));
-    let body = "";
-    socket.setTimeout(24e4, () => socket.destroy(new Error("Unit control timed out")));
-    socket.once("connect", () => socket.write(JSON.stringify(command) + "\n"));
-    socket.on("data", (data) => {
-      body += data;
-      if (body.length > 1e6) {
-        socket.destroy(new Error("Oversized control response"));
-        return;
-      }
-      if (!body.includes("\n")) return;
-      try {
-        const reply = JSON.parse(body.split("\n")[0]);
-        socket.end();
-        if (reply.ok) resolveReply(reply.result);
-        else reject(new Error(reply.error || "Unit command failed"));
-      } catch (error) {
-        socket.destroy();
-        reject(error);
-      }
-    });
-    socket.once("error", reject);
-    socket.once("end", () => {
-      if (!body.includes("\n")) reject(new Error("Unit control connection closed"));
-    });
-  });
-}
-var unitIsOffline = (error) => ["ENOENT", "ECONNREFUSED"].includes(error?.code || "");
-async function startControl(dataDir, dispatch) {
-  await mkdir5(dataDir, { recursive: true, mode: 448 });
-  try {
-    await sendControl(dataDir, { action: "status" });
-    throw new Error("This Unit is already running");
-  } catch (error) {
-    if (!unitIsOffline(error)) throw error;
-  }
-  const address = controlAddress(dataDir);
-  if (process.platform !== "win32") {
-    await mkdir5(dirname2(address), { recursive: true, mode: 448 });
-    await chmod(dirname2(address), 448);
-  }
-  if (process.platform !== "win32") await rm2(address, { force: true });
-  const clients = /* @__PURE__ */ new Set();
-  const server = net.createServer((socket) => {
-    clients.add(socket);
-    socket.once("close", () => clients.delete(socket));
-    let body = "", dispatched = false;
-    socket.setTimeout(24e4, () => socket.destroy());
-    socket.on("data", (data) => {
-      if (dispatched) return;
-      body += data;
-      if (body.length > 1e6) {
-        socket.destroy();
-        return;
-      }
-      if (!body.includes("\n")) return;
-      dispatched = true;
-      void (async () => {
-        try {
-          socket.end(JSON.stringify({ ok: true, result: await dispatch(JSON.parse(body.split("\n")[0])) }) + "\n");
-        } catch (error) {
-          socket.end(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : "Unit command failed" }) + "\n");
-        }
-      })();
-    });
-    socket.on("error", () => {
-    });
-  });
-  await new Promise((ready, reject) => {
-    server.once("error", reject);
-    server.listen(address, ready);
-  });
-  if (process.platform !== "win32") await chmod(address, 384);
-  return { close: async () => {
-    await new Promise((done) => {
-      server.close(() => done());
-      for (const socket of clients) socket.destroy();
-    });
-    if (process.platform !== "win32") await rm2(address, { force: true });
-  } };
-}
-
-// unit/install.ts
-async function inspectTree(dir, root, seen = /* @__PURE__ */ new Set()) {
-  const actual = await realpath4(dir);
-  if (seen.has(actual)) return;
-  seen.add(actual);
-  for (const entry of await readdir3(dir, { withFileTypes: true })) {
-    const path = resolve6(dir, entry.name);
-    if (entry.name === ".env" || entry.name.startsWith(".env.") && !entry.name.endsWith(".example")) throw new Error("Package contains private environment files");
-    if (entry.isSymbolicLink()) {
-      const target = await realpath4(path);
-      if (!target.startsWith(root + sep4)) throw new Error("Package symlink escapes its directory");
-      if ((await lstat(target)).isDirectory()) await inspectTree(target, root, seen);
-    } else if (entry.isDirectory()) await inspectTree(path, root, seen);
-  }
-}
-async function relocateLinks(dir, source, destination) {
-  for (const entry of await readdir3(dir, { withFileTypes: true })) {
-    const path = resolve6(dir, entry.name);
-    if (entry.isSymbolicLink()) {
-      const link = await readlink(path);
-      if (isAbsolute3(link)) {
-        const relocated = resolve6(destination, relative(source, await realpath4(link)));
-        await rm3(path);
-        await symlink(relative(dirname3(path), relocated), path);
-      }
-    } else if (entry.isDirectory()) await relocateLinks(path, source, destination);
-  }
-}
-async function installDependencies(root, backendMain) {
-  const backend = resolve6(root, backendMain.split("/")[0]);
-  await packagePath(root, backendMain.split("/")[0] + "/package-lock.json");
-  await new Promise((done, reject) => {
-    const win = process.platform === "win32";
-    const child = spawn(win ? "cmd.exe" : "npm", win ? ["/c", "npm", "ci", "--omit=dev"] : ["ci", "--omit=dev"], { cwd: backend, stdio: "inherit", env: { ...process.env, PATH: dirname3(process.execPath) + (win ? ";" : ":") + (process.env.PATH || "") } });
-    child.once("error", reject);
-    child.once("exit", (code) => code === 0 ? done() : reject(new Error(`Plugin dependency installation failed (${code})`)));
-  });
-}
-async function installPackage(configPath, source) {
-  const file2 = resolve6(configPath), root = dirname3(file2);
-  const lockPath = resolve6(root, ".install.lock");
-  const lock = await open(lockPath, "wx", 384).catch(() => {
-    throw new Error("Another install is in progress");
-  });
-  let stage, committed = false;
-  try {
-    const config = await readConfig(file2), sourceRoot = await realpath4(source);
-    if (!(await lstat(sourceRoot)).isDirectory()) throw new Error("Install expects an unpacked plugin directory");
-    const pack = await readPackage(sourceRoot, config.version);
-    await inspectTree(sourceRoot, sourceRoot);
-    stage = resolve6(root, "plugins", pack.manifest.id, `${pack.manifest.version}-${randomUUID7()}`);
-    await mkdir6(dirname3(stage), { recursive: true, mode: 448 });
-    await cp(sourceRoot, stage, { recursive: true, verbatimSymlinks: true });
-    await relocateLinks(stage, sourceRoot, stage);
-    if (pack.manifest.backend?.dependencies?.mode === "npm-ci") await installDependencies(stage, pack.manifest.backend.main);
-    const ready = await readPackage(stage, config.version);
-    const entries = installations(config);
-    const existing = (await Promise.all(entries.map(async (entry) => ({ entry, pack: await readPackage(entry.path) })))).find((p) => p.pack.manifest.id === pack.manifest.id);
-    if (existing) {
-      try {
-        await sendControl(config.dataDir, { action: "update", id: pack.manifest.id, path: stage });
-        committed = true;
-        return { id: ready.manifest.id, version: ready.manifest.version, path: stage };
-      } catch (error) {
-        if (!unitIsOffline(error)) {
-          committed = true;
-          throw error;
-        }
-      }
-      existing.entry.path = stage;
-    } else {
-      try {
-        await sendControl(config.dataDir, { action: "status" });
-        throw new Error("Stop the Unit before installing a new plugin; updates can run live");
-      } catch (error) {
-        if (!unitIsOffline(error)) throw error;
-      }
-      entries.push({ path: stage, enabled: true });
-    }
-    if (!config.defaultSpace && ready.spaceIds.size) config.defaultSpace = [...ready.spaceIds][0];
-    await writeConfig(file2, config);
-    committed = true;
-    return { id: ready.manifest.id, version: ready.manifest.version, path: stage };
-  } finally {
-    await lock.close();
-    await rm3(lockPath, { force: true });
-    if (!committed && stage) await rm3(stage, { recursive: true, force: true });
-  }
-}
+// unit/main.ts
+init_config();
+init_packages();
+init_install();
+init_control();
 
 // desktop/package.json
 var package_default = {
   name: "forsion-desktop",
-  version: "2.12.2",
+  version: "2.13.1",
   description: "Forsion Desktop \u2014 AI \u9A71\u52A8\u7684\u5E94\u7528\u751F\u6001\u7CFB\u7EDF\u7684\u684C\u9762\u7AEF(Electron):Tangu Agent \u5F15\u64CE + LCL \u53EF\u505C\u9760\u5DE5\u4F5C\u533A\u6846\u67B6 + \u53EF\u63D2\u62D4\u529F\u80FD\u7A7A\u95F4(\u5BF9\u8BDD/\u7B14\u8BB0/\u65E5\u5386/\u6536\u4EF6\u7BB1/\u7F16\u7801),\u6309\u4EA7\u54C1\u6863\u6848\u88C1\u51FA\u5168\u5BB6\u6876\u4E0E\u5355\u54C1\u53D1\u884C\u7248",
   author: "Forsion",
   private: true,
@@ -2859,6 +3292,9 @@ var package_default = {
     "e2e:dnd": "node scripts/block-dnd.e2e.cjs",
     "e2e:sidebardrop": "node scripts/sidebar-drop.e2e.cjs",
     "e2e:ribbon": "node scripts/ribbon-dnd.e2e.cjs",
+    "e2e:spacewindow": "node scripts/space-window.e2e.cjs",
+    "e2e:spacewindow-input": "node scripts/space-window-input.e2e.cjs",
+    "e2e:ribbon-overflow": "node scripts/ribbon-overflow.e2e.cjs",
     "e2e:mindmap": "node scripts/mindmap.e2e.cjs",
     "e2e:canvas": "node scripts/canvas.e2e.cjs",
     "e2e:daily": "node scripts/daily-template.e2e.cjs",
@@ -2870,6 +3306,7 @@ var package_default = {
     "e2e:recall": "node scripts/recall-rewind.e2e.cjs",
     "e2e:chatevents": "node scripts/chat-events.e2e.cjs",
     "e2e:computerhistory": "node scripts/computer-history.e2e.cjs",
+    "e2e:appdock": "node scripts/app-dock.e2e.cjs",
     "e2e:remotesafety": "node scripts/remote-safety.e2e.cjs",
     "e2e:chatshimmer": "node scripts/chat-shimmer.e2e.cjs",
     "e2e:runstats": "node scripts/chat-runstats.e2e.cjs",
@@ -2881,6 +3318,7 @@ var package_default = {
     "e2e:coreplugins": "node scripts/core-plugins.e2e.cjs",
     "e2e:restart-update": "node scripts/restart-update.e2e.cjs",
     "e2e:market-submissions": "node scripts/market-submissions.e2e.cjs",
+    "e2e:storepages": "node scripts/store-pages.e2e.cjs",
     "e2e:market-auto-update": "node scripts/market-auto-update.e2e.cjs",
     "e2e:account": "node scripts/account-center.shot.cjs",
     "e2e:accountpopups": "node scripts/account-popups.shot.cjs",
@@ -2893,6 +3331,7 @@ var package_default = {
     "live:harness": "cd ../tangu-agent && npm run live:harness",
     "probe:gzipupload": "node scripts/gzip-upload.probe.cjs",
     "e2e:realtimevoice": "node scripts/realtime-voice.e2e.cjs",
+    "e2e:voicestudio": "node scripts/voice-studio.e2e.cjs",
     "e2e:dashdrag": "node scripts/dash3-drag.e2e.cjs",
     "e2e:pathgone": "node scripts/vault-pathgone.e2e.cjs",
     "check:pillbar": "node scripts/pillbar-overflow.check.cjs",
@@ -2907,6 +3346,7 @@ var package_default = {
     "check:caret": "node scripts/smooth-caret.check.cjs",
     "check:spacerestore": "node scripts/space-restore.check.cjs",
     "check:spacerestart": "node scripts/space-restart.check.cjs",
+    "check:spacefallback": "node scripts/space-fallback-persist.check.cjs",
     "check:bluebirdspace": "node scripts/bluebird-space.check.cjs",
     "check:bluebirdtimestamps": "node scripts/bluebird-space.check.cjs --timestamps",
     "check:splitregions": "node scripts/split-regions.check.cjs",
@@ -2971,6 +3411,7 @@ var package_default = {
     "check:hlband": "node scripts/pdf-highlight-geometry.check.cjs",
     "e2e:filecite": "node scripts/file-citation.e2e.cjs",
     "e2e:pathgonefiles": "node scripts/vault-pathgone-files.e2e.cjs",
+    "e2e:ftoverride": "node scripts/filetype-override.e2e.cjs",
     "e2e:pathgoneunmounted": "node scripts/vault-pathgone-unmounted.e2e.cjs",
     "check:textfrag": "electron scripts/text-fragment.check.cjs",
     "check:assetfetch": "electron scripts/asset-fetch.check.cjs",
@@ -2991,6 +3432,8 @@ var package_default = {
     "check:settingsmode": "node scripts/settings-mode.check.cjs",
     "check:themecontrast": "node scripts/theme-contrast.check.cjs",
     "check:themevisual": "node scripts/theme-visual.check.cjs",
+    "check:spaceappearance": "node scripts/space-appearance.e2e.cjs",
+    "check:fps": "node scripts/check-fps.cjs",
     "check:themeapp": "node scripts/theme-app.check.cjs",
     "check:marketui": "node scripts/market-ui.check.cjs",
     "probe:marketdl": "node scripts/market-download.probe.cjs",
@@ -3001,6 +3444,7 @@ var package_default = {
     "check:floatingpanel": "node scripts/floating-panel.check.cjs",
     "check:quietfocus": "node scripts/quiet-focus.check.cjs",
     "check:persistignore": "node scripts/persist-ignore.check.cjs",
+    "check:spaceicon": "node scripts/space-icon.check.cjs",
     "check:onboarding": "node scripts/plugin-onboarding.check.cjs",
     "check:plugindeps": "node scripts/plugin-deps.check.cjs",
     "check:pluginsync": "node scripts/plugin-install-sync.check.cjs",
@@ -3011,18 +3455,22 @@ var package_default = {
     "check:scrollbar": "node scripts/scrollbar-overlay.check.cjs",
     "check:callout": "node scripts/callout-fold.check.cjs",
     "check:toggle": "node scripts/e2e-editor.cjs --check=toggle-block",
+    "check:togglecaret": "node scripts/e2e-editor.cjs --check=toggle-caret",
     "check:togglecontent": "node scripts/e2e-editor.cjs --check=toggle-content",
     "check:togglemotion": "node scripts/e2e-editor.cjs --check=toggle-motion",
     "check:tabindent": "node scripts/e2e-editor.cjs --check=tab-indent",
     "check:srcbtn": "node scripts/source-toggle.check.cjs",
     "check:bsurface": "node scripts/e2e-editor.cjs --check=plugin-blocksurface",
     "build:unitweb": "node scripts/build-unit-web.mjs",
+    "check:unitweb": "node ../web/scripts/docker-context-build.mjs --unit-web",
     pack: "npm run build:unitweb && electron-builder --config electron-builder.config.cjs --dir",
     dist: "npm run build:unitweb && electron-builder --config electron-builder.config.cjs",
     "fetch-python": "node build/fetch-python.cjs",
     "fetch-node": "node build/fetch-node.cjs",
     "fetch-office": "node build/fetch-office.cjs",
     "fetch-git": "node build/fetch-git.cjs",
+    "check:documentagents": "node scripts/e2e-editor.cjs --check=document-agents",
+    "e2e:documentagents": "node scripts/document-agents.electron.cjs",
     typecheck: "tsc --noEmit && node ../tangu-agent/scripts/sync-command-catalog.mjs --check",
     "predev:amadeus": "node scripts/dev-version.check.cjs",
     "dev:amadeus": "FORSION_PRODUCT=amadeus electron-vite dev --noSandbox",
@@ -3042,7 +3490,9 @@ var package_default = {
     "check:hooks": 'eslint --config build/eslint.hooks.mjs "frontend/src/**/*.{ts,tsx}"',
     "check:deskshot": "node scripts/desk-shot.check.cjs",
     "check:splash": "node scripts/splash-loop.check.cjs",
+    "probe:startup-windows": "node scripts/startup-windows.probe.cjs",
     "check:parity": "node scripts/platform-parity.check.cjs",
+    "check:vitecache": "node scripts/vite-cachedir.check.cjs",
     "check:enginetarget": "node scripts/engine-target.check.cjs",
     "check:remotechain": "node scripts/remote-chain.e2e.cjs",
     "check:streamrenew": "node scripts/stream-renew.check.cjs",
@@ -3063,6 +3513,7 @@ var package_default = {
     "check:focusring": "node scripts/focus-ring.check.cjs",
     "check:layoutreset": "node scripts/layout-reset.check.cjs",
     "check:statusbar": "node scripts/status-bar.check.cjs",
+    "check:calm": "node scripts/calm.check.cjs",
     "check:dropfeedback": "node scripts/drop-feedback.check.cjs",
     "check:chatside": "node scripts/chat-sidepanel.check.cjs",
     "check:facade": "node scripts/facade-scope.check.cjs",
@@ -3139,8 +3590,8 @@ var package_default = {
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@excalidraw/excalidraw": "npm:@zsviczian/excalidraw@0.18.122",
-    "@forsion/extend": "0.7.1",
-    "@forsion/tangu-computer-use": "0.6.1",
+    "@forsion/extend": "0.8.1",
+    "@forsion/tangu-computer-use": "0.6.2",
     "@milkdown/kit": "^7.21.2",
     "@milkdown/plugin-math": "^7.5.9",
     "@milkdown/react": "^7.21.2",
@@ -3222,11 +3673,13 @@ var package_default = {
 };
 
 // unit/main.ts
+init_releases();
 var dist = dirname4(fileURLToPath2(import.meta.url));
 var args = process.argv.slice(2);
-var commands = ["init", "install", "run", "migrate", "enable", "disable", "restart", "status", "access"];
+var commands = ["init", "install", "stage", "update", "run", "migrate", "enable", "disable", "restart", "status", "access"];
 var action = commands.includes(args[0]) ? args.shift() : "run";
-var file = resolve7(args.shift() || (action === "init" ? "forsion-unit" : "unit.json"));
+var configArgument = args.shift();
+var file = resolve7(configArgument || (action === "init" ? "forsion-unit" : "unit.json"));
 var print = (result) => console.log(JSON.stringify(result, null, 2));
 async function findInstallation(config, id) {
   if (!id) throw new Error("A plugin id is required");
@@ -3234,6 +3687,15 @@ async function findInstallation(config, id) {
   throw new Error(`Plugin is not installed: ${id}`);
 }
 async function run() {
+  if (action === "update") {
+    if (!configArgument?.trim() || args.length !== 2 || args.some((arg) => !arg.trim())) {
+      throw new Error("Usage: node main.mjs update <unit.json> <plugin-id> <package-path>");
+    }
+    if (!validId(args[0])) throw new Error("Invalid plugin id");
+  }
+  if (action === "stage" && (!configArgument?.trim() || args.length !== 1 || !args[0]?.trim())) {
+    throw new Error("Usage: node main.mjs stage <unit.json> <bundled-package-path>");
+  }
   if (action === "init") {
     const option = (key, fallback) => {
       const i = args.indexOf(key);
@@ -3243,10 +3705,10 @@ async function run() {
     if (!["public", "local"].includes(mode)) throw new Error("Mode must be public or local");
     const port = Number(option("--port", "3001")), basePath = option("--base", mode === "local" ? "/" : "/admin/");
     if (!Number.isInteger(port) || port < 0 || port > 65535 || !basePath?.startsWith("/")) throw new Error("Invalid port or projection base path");
-    await mkdir7(file, { recursive: true, mode: 448 });
+    await mkdir9(file, { recursive: true, mode: 448 });
     const path = resolve7(file, "unit.json");
     const config2 = {
-      instanceId: randomUUID8(),
+      instanceId: randomUUID10(),
       name: "Forsion Unit",
       version: package_default.version,
       port,
@@ -3274,6 +3736,15 @@ async function run() {
   }
   const config = await readConfig(file);
   config.workerFile ||= resolve7(dist, "backendWorker.mjs");
+  if (action === "stage") {
+    print(await stageRelease(config.dataDir, resolve7(args[0]), config.version));
+    return;
+  }
+  if (action === "update") {
+    await findInstallation(config, args[0]);
+    print(await installPackage(file, resolve7(args[1]), { updateId: args[0] }));
+    return;
+  }
   if (action === "access") {
     if (config.workspace?.mode !== "local") throw new Error("Public sites use their Account provider");
     const token = await localOwnerToken(config.dataDir);
@@ -3302,7 +3773,7 @@ async function run() {
     const pack = await readPackage(entry.path, config.version);
     if (!pack.backendEntry) throw new Error("Plugin has no backend migration");
     const dataDir = resolve7(config.dataDir, "plugins", pack.manifest.id);
-    await mkdir7(dataDir, { recursive: true, mode: 448 });
+    await mkdir9(dataDir, { recursive: true, mode: 448 });
     const migration = new AbortController();
     const cancelMigration = () => migration.abort(new Error("Migration interrupted"));
     for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, cancelMigration);
@@ -3325,14 +3796,14 @@ async function run() {
     return;
   }
   if (process.env.UNIT_PORT) config.port = Number(process.env.UNIT_PORT);
-  await mkdir7(config.dataDir, { recursive: true, mode: 448 });
+  await mkdir9(config.dataDir, { recursive: true, mode: 448 });
   const lockPath = resolve7(config.dataDir, "run.lock");
   let lock;
   try {
     lock = await open2(lockPath, "wx", 384);
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
-    const pid = Number(await readFile7(lockPath, "utf8"));
+    const pid = Number(await readFile9(lockPath, "utf8"));
     if (!Number.isInteger(pid) || pid <= 0) throw new Error("Unit startup is locked; inspect data/run.lock");
     try {
       process.kill(pid, 0);
@@ -3340,13 +3811,14 @@ async function run() {
     } catch (failure) {
       if (failure.code !== "ESRCH") throw failure;
     }
-    await rm4(lockPath);
+    await rm5(lockPath);
     lock = await open2(lockPath, "wx", 384);
   }
   await lock.writeFile(String(process.pid));
   await lock.close();
   let unit;
   let control;
+  let executeManagement;
   let shutdownRequested = false, requestStop;
   const onSignal = () => {
     shutdownRequested = true;
@@ -3354,11 +3826,19 @@ async function run() {
   };
   for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, onSignal);
   try {
-    unit = await startBasicUnit(config);
+    unit = await startBasicUnit(config, { execute: async (command, authorize) => {
+      if (!executeManagement) throw new Error("Unit control is not ready");
+      return executeManagement(command, authorize);
+    } });
     let queue = Promise.resolve();
     const status = () => ({ running: true, pid: process.pid, instanceId: config.instanceId, port: unit.port, plugins: unit.status() });
     const dispatch = async (command) => {
       if (command.action === "status") return status();
+      if (command.action === "stage") {
+        if (command.remote && config.management?.enabled !== true) throw new Error("Remote Unit management is disabled");
+        if (!command.path) throw new Error("A prepared package is required");
+        return stageRelease(config.dataDir, command.path, config.version);
+      }
       if (!["enable", "disable", "restart", "update", "migrate"].includes(command.action)) throw new Error("Unknown Unit command");
       const entry = await findInstallation(config, command.id);
       const previous = { ...entry };
@@ -3386,13 +3866,26 @@ async function run() {
       }
       return status();
     };
-    control = await startControl(config.dataDir, (command) => {
-      const next = queue.then(() => dispatch(command));
+    const enqueue = (run2) => {
+      const next = queue.then(run2);
       queue = next.then(() => {
       }, () => {
       });
       return next;
-    });
+    };
+    executeManagement = async (command, authorize) => {
+      const apply = (action2) => enqueue(async () => {
+        await authorize();
+        return dispatch(action2);
+      });
+      if (command.action === "update") return installPackage(file, command.path, {
+        updateId: command.id,
+        releaseDigest: command.releaseDigest,
+        applyUpdate: (id, path) => apply({ action: "update", id, path })
+      });
+      return apply({ action: command.action, id: command.id });
+    };
+    control = await startControl(config.dataDir, (command) => enqueue(() => dispatch(command)));
     print(status());
     console.log(`[unit] ${config.name} http://${config.bindHost || "127.0.0.1"}:${unit.port}${config.basePath}`);
     let stopping = false;
@@ -3401,6 +3894,7 @@ async function run() {
       stopping = true;
       let failure = false;
       try {
+        await unit.closeManagement();
         await control.close();
         await queue;
         await unit.close();
@@ -3408,7 +3902,7 @@ async function run() {
         console.error(error);
         failure = true;
       } finally {
-        await rm4(lockPath, { force: true });
+        await rm5(lockPath, { force: true });
         process.exit(failure ? 1 : 0);
       }
     };
@@ -3422,7 +3916,7 @@ async function run() {
       try {
         await unit?.close();
       } finally {
-        await rm4(lockPath, { force: true });
+        await rm5(lockPath, { force: true });
       }
     }
     throw error;