@forsion/unit 2.12.2

package/main.mjs

@@ -0,0 +1,3434 @@
+// unit/main.ts
+import { mkdir as mkdir7, readFile as readFile7, open as open2, rm as rm4 } 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";
+
+// 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 { homedir } from "node:os";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// desktop/electron/unitWeb.ts
+import http from "node:http";
+import { createHash, randomBytes, randomUUID, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { extname, normalize, sep } from "node:path";
+import { readFile, realpath } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+
+// desktop/shared/amadeus/ipc.ts
+var IPC = {
+  openVault: "vault:open",
+  restoreVault: "vault:restore",
+  listPages: "vault:list",
+  listFiles: "vault:files",
+  loadPage: "page:load",
+  readPage: "page:read",
+  newPage: "page:new",
+  savePage: "page:save",
+  renamePage: "page:rename",
+  reconcilePage: "page:reconcile",
+  saveAsset: "asset:save",
+  saveVaultBytes: "vault:save-bytes",
+  readVaultBytes: "vault:read-bytes",
+  saveAttachment: "attachment:save",
+  openAttachment: "attachment:open",
+  copyAttachment: "attachment:copy",
+  openVaultFile: "vault:open-file",
+  exportPdf: "page:export-pdf",
+  exportCsv: "db:export-csv",
+  externalChange: "page:external-change",
+  search: "vault:search",
+  backlinks: "vault:backlinks",
+  exclusiveAssets: "vault:exclusive-assets",
+  reindex: "vault:reindex",
+  listTags: "vault:tags",
+  listMarks: "vault:marks",
+  patchMark: "vault:patch-mark",
+  pagesByTag: "vault:tag-pages",
+  deletePage: "page:delete",
+  movePage: "page:move",
+  resolveEmbed: "embed:resolve",
+  blockBacklinks: "embed:backlinks",
+  listFolders: "vault:folders",
+  createFolder: "folder:create",
+  renameFolder: "folder:rename",
+  deleteFolder: "folder:delete",
+  moveFolder: "folder:move",
+  trashEntry: "trash:put",
+  listTrash: "trash:list",
+  restoreTrash: "trash:restore",
+  deleteTrashEntry: "trash:delete",
+  emptyTrash: "trash:empty",
+  pageIcons: "vault:page-icons",
+  pageAliases: "vault:page-aliases",
+  unlinkedMentions: "vault:unlinked-mentions",
+  linkMention: "vault:link-mention",
+  fetchLinkMeta: "web:link-meta",
+  searchImages: "web:search-images",
+  structureChange: "vault:structure-change",
+  /** 渲染层的路径广播(改名 / 挪走 / 删除)跨窗口转发:渲染层 invoke 进主进程,主进程转给**其它**窗口。 */
+  pathGone: "vault:path-gone",
+  listPlugins: "plugins:list",
+  openPluginsFolder: "plugins:open-folder",
+  scaffoldPlugin: "plugins:scaffold",
+  uninstallPlugin: "plugins:uninstall-forsion",
+  bundleAgentOwned: "plugins:bundle-agent-owned",
+  revealInFileManager: "shell:reveal",
+  dbRead: "db:read",
+  dbWrite: "db:write",
+  dbWriteCas: "db:write-cas",
+  dbChange: "db:external-change",
+  drawingRead: "drawing:read",
+  drawingWrite: "drawing:write",
+  // 通用 vault 文本文件读写(供插件文件类型 ctx.app.readFile/writeFile;写走自写账本防 watcher 回弹)。
+  readTextFile: "file:read-text",
+  writeTextFile: "file:write-text",
+  /** 外部改动了 vault 里的**非 .md / 非 .db** 文件(附件、片段 .js…)→ ctx.app.watchFile 的数据源。 */
+  fileChange: "file:external-change",
+  /** 每插件一份 JSON blob(~/.forsion/plugins-data/<id>.json);ctx.loadData/saveData 的落点。 */
+  pluginDataRead: "plugins:data-read",
+  pluginDataWrite: "plugins:data-write",
+  setPageFrontmatter: "page:set-frontmatter",
+  listPageProps: "vault:page-props",
+  renamePageFile: "page:rename-file",
+  renameDbFile: "db:rename-file",
+  /** 页面版本历史(评审 C-20):快照存在库外(主进程 tanguDataDir()/amadeus-history),只有桌面主进程实现。 */
+  listPageHistory: "page:history-list",
+  readPageHistory: "page:history-read",
+  restorePageHistory: "page:history-restore"
+};
+
+// desktop/products/forsion.json
+var forsion_default = {
+  id: "forsion",
+  displayName: "Forsion",
+  appId: "com.forsion.tangu-desktop2",
+  productName: "Forsion",
+  artifactPrefix: "Forsion",
+  defaultSpace: "tangu",
+  spaces: [
+    "home",
+    "tangu",
+    "inbox",
+    "amadeus",
+    "calendar",
+    "coding",
+    "artificial",
+    "automation",
+    "muse",
+    "public"
+  ],
+  agentBackend: true,
+  market: true
+};
+
+// desktop/shared/product.ts
+function resolveProduct(build, runtime) {
+  const profile = build ?? runtime ?? forsion_default;
+  return { ...profile, unit: profile.unit ?? profile.agentBackend };
+}
+
+// desktop/electron/product.ts
+var PRODUCT = resolveProduct(typeof __FORSION_PRODUCT__ === "undefined" ? void 0 : __FORSION_PRODUCT__);
+
+// desktop/electron/engineRoutes.generated.ts
+var ENGINE_ROUTES = [
+  { method: "GET", path: "/agent/agents", access: "allow", src: "routes/agents.ts", why: "Agent roster; remote callers get no persona / developer instructions and the approval mode clamped to the remote cap (P1-M1A projection)" },
+  { method: "POST", path: "/agent/agents", access: "deny-remote", src: "routes/agents.ts", why: "create Agent (design appendix C)" },
+  { method: "GET", path: "/agent/agents-meta", access: "allow", src: "routes/agents.ts", why: "Agent roster meta" },
+  { method: "PUT", path: "/agent/agents-meta", access: "deny-remote", src: "routes/agents.ts", why: "Agent roster meta write" },
+  { method: "DELETE", path: "/agent/agents/:slug", access: "deny-remote", src: "routes/agents.ts", why: "delete Agent" },
+  { method: "PATCH", path: "/agent/agents/:slug", access: "deny-remote", src: "routes/agents.ts", why: "update Agent (design appendix C)" },
+  { method: "DELETE", path: "/agent/agents/:slug/avatar", access: "deny-remote", src: "routes/agents.ts", why: "update Agent avatar" },
+  { 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/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" },
+  { method: "GET", path: "/agent/agents/:slug/library/file", access: "allow", src: "routes/agents.ts", why: "Agent library file" },
+  { method: "POST", path: "/agent/agents/:slug/library/file", access: "deny-remote", src: "routes/agents.ts", why: "writes into the Agent library" },
+  { method: "GET", path: "/agent/agents/:slug/log", access: "allow", src: "routes/agents.ts", why: "Agent log" },
+  { method: "PUT", path: "/agent/agents/:slug/log", access: "deny-remote", src: "routes/agents.ts", why: "memory log write" },
+  { method: "GET", path: "/agent/agents/:slug/logs", access: "allow", src: "routes/agents.ts", why: "Agent log list" },
+  { method: "GET", path: "/agent/agents/:slug/memory", access: "allow", src: "routes/agents.ts", why: "read Agent memory" },
+  { method: "PUT", path: "/agent/agents/:slug/memory", access: "deny-remote", src: "routes/agents.ts", why: "memory write (design appendix C)" },
+  { method: "POST", path: "/agent/agents/:slug/memory/entries", access: "deny-remote", src: "routes/agents.ts", why: "memory write (design appendix C)" },
+  { method: "POST", path: "/agent/agents/:slug/memory/restore", access: "deny-remote", src: "routes/agents.ts", why: "memory write" },
+  { method: "GET", path: "/agent/agents/:slug/memory/revisions", access: "allow", src: "routes/agents.ts", why: "memory revisions" },
+  { method: "POST", path: "/agent/agents/:slug/rename", access: "deny-remote", src: "routes/agents.ts", why: "rename Agent" },
+  { method: "GET", path: "/agent/tool-catalog", access: "allow", src: "routes/agents.ts", why: "tool catalog" },
+  { method: "GET", path: "/agent/user-profile", access: "allow", src: "routes/agents.ts", why: "read user profile" },
+  { method: "PUT", path: "/agent/user-profile", access: "deny-remote", src: "routes/agents.ts", why: "user profile write (design appendix C)" },
+  { method: "GET", path: "/agent/approval-rules", access: "deny-remote", src: "routes/approvals.ts", why: "approval rules are local policy" },
+  { method: "PUT", path: "/agent/approval-rules", access: "deny-remote", src: "routes/approvals.ts", why: "approval rules are local policy" },
+  { method: "GET", path: "/agent/approvals/pending", access: "allow", src: "routes/approvals.ts", why: "per-session pending counts for the session-list badge (no ids / previews)" },
+  { method: "GET", path: "/agent/approvals/stream", access: "deny-remote", src: "routes/approvals.ts", why: "engine-wide pending approval feed for the host main process only" },
+  { method: "POST", path: "/agent/runs/:runId/approvals/:approvalId", access: "allow", src: "routes/approvals.ts", why: "answer an approval (D1: remote approval allowed; bound to its run by P0 \u2461)" },
+  { method: "POST", path: "/agent/runs/:runId/captures/:shotId", access: "allow", src: "routes/approvals.ts", why: "Agent Desk capture upload for a run (shotId bound to run, P0 \u2461)" },
+  { method: "POST", path: "/agent/runs/:runId/inquiries/:inquiryId", access: "allow", src: "routes/approvals.ts", why: "answer an inquiry (D1)" },
+  { method: "GET", path: "/agent/skills", access: "allow", src: "routes/assets.ts", why: "skills list" },
+  { method: "GET", path: "/agent/skills/catalog", access: "allow", src: "routes/assets.ts", why: "skill catalog" },
+  { method: "POST", path: "/agent/skills/catalog", access: "deny-remote", src: "routes/assets.ts", why: "create skill" },
+  { method: "DELETE", path: "/agent/skills/catalog/:key", access: "deny-remote", src: "routes/assets.ts", why: "delete skill" },
+  { method: "GET", path: "/agent/skills/catalog/:key", access: "allow", src: "routes/assets.ts", why: "skill detail" },
+  { method: "PATCH", path: "/agent/skills/catalog/:key", access: "deny-remote", src: "routes/assets.ts", why: "edit skill" },
+  { method: "POST", path: "/agent/skills/catalog/:key/copy", access: "deny-remote", src: "routes/assets.ts", why: "copy skill between Agents" },
+  { method: "PUT", path: "/agent/skills/catalog/:key/disabled", access: "deny-remote", src: "routes/assets.ts", why: "skill enablement config" },
+  { method: "POST", path: "/agent/skills/catalog/import", access: "deny-remote", src: "routes/assets.ts", why: "skill import (design appendix C)" },
+  { method: "POST", path: "/agent/skills/upload", access: "deny-remote", src: "routes/assets.ts", why: "skill upload (design appendix C)" },
+  { method: "DELETE", path: "/agent/skills/user/:id", access: "deny-remote", src: "routes/assets.ts", why: "delete user skill" },
+  { method: "GET", path: "/agent/tools", access: "allow", src: "routes/assets.ts", why: "tool list" },
+  { method: "GET", path: "/agent/browser-extension", access: "deny-remote", src: "routes/browserExtension.ts", why: "browser extension pairing credentials" },
+  { method: "POST", path: "/agent/browser-extension/reset-code", access: "deny-remote", src: "routes/browserExtension.ts", why: "rotates browser extension pairing credentials" },
+  { method: "GET", path: "/agent/channels", access: "deny-remote", src: "routes/channels.ts", why: "channel config is local-only" },
+  { method: "PUT", path: "/agent/channels/:kind/config", access: "deny-remote", src: "routes/channels.ts", why: "channel config is local-only" },
+  { method: "POST", path: "/agent/channels/:kind/connect", access: "deny-remote", src: "routes/channels.ts", why: "channel binding is local-only (design appendix C)" },
+  { method: "POST", path: "/agent/channels/:kind/connect-session", access: "deny-remote", src: "routes/channels.ts", why: "channel binding is local-only (design appendix C)" },
+  { method: "POST", path: "/agent/channels/:kind/disconnect", access: "deny-remote", src: "routes/channels.ts", why: "channel binding is local-only" },
+  { method: "POST", path: "/agent/channels/:kind/sessions/new", access: "deny-remote", src: "routes/channels.ts", why: "channel binding is local-only (design appendix C)" },
+  { method: "GET", path: "/agent/commands", access: "allow", src: "routes/commands.ts", why: "slash command catalog" },
+  { method: "POST", path: "/agent/commands/:name/expand", access: "allow", src: "routes/commands.ts", why: "expand a custom slash command template (read-only)" },
+  { method: "GET", path: "/agent/engines", access: "deny-remote", src: "routes/engines.ts", why: "external engines are local-only (engineId is stripped from remote runs)" },
+  { method: "PUT", path: "/agent/engines/:id", access: "deny-remote", src: "routes/engines.ts", why: "external engine config" },
+  { method: "GET", path: "/agent/engines/:id/assets", access: "deny-remote", src: "routes/engines.ts", why: "reads host assets of an external engine" },
+  { method: "GET", path: "/agent/engines/:id/capabilities", access: "deny-remote", src: "routes/engines.ts", why: "external engines are local-only" },
+  { method: "POST", path: "/agent/engines/:id/import", access: "deny-remote", src: "routes/engines.ts", why: "imports external engine assets" },
+  { method: "GET", path: "/agent/hooks", access: "deny-remote", src: "routes/hooks.ts", why: "hooks run host commands" },
+  { method: "PUT", path: "/agent/hooks", access: "deny-remote", src: "routes/hooks.ts", why: "hooks run host commands" },
+  { method: "POST", path: "/agent/hooks/enable", access: "deny-remote", src: "routes/hooks.ts", why: "hooks run host commands" },
+  { method: "POST", path: "/agent/hooks/trust", access: "deny-remote", src: "routes/hooks.ts", why: "hooks run host commands" },
+  { method: "GET", path: "/agent/agents/:slug/human", access: "deny-remote", src: "routes/human.ts", why: "host collaboration configuration" },
+  { method: "PUT", path: "/agent/agents/:slug/human", access: "deny-remote", src: "routes/human.ts", why: "host collaboration configuration write" },
+  { method: "POST", path: "/agent/agents/:slug/human/undo", access: "deny-remote", src: "routes/human.ts", why: "host collaboration configuration undo" },
+  { method: "GET", path: "/agent/project-context/human", access: "deny-remote", src: "routes/human.ts", why: "host collaboration configuration" },
+  { method: "PUT", path: "/agent/project-context/human", access: "deny-remote", src: "routes/human.ts", why: "host collaboration configuration write" },
+  { method: "POST", path: "/agent/project-context/human/undo", access: "deny-remote", src: "routes/human.ts", why: "host collaboration configuration undo" },
+  { method: "GET", path: "/agent/inbox", access: "allow", src: "routes/inbox.ts", why: "inbox list" },
+  { method: "POST", path: "/agent/inbox", access: "deny-remote", src: "routes/inbox.ts", why: "posts a system-sender message and forwards it to channels" },
+  { method: "DELETE", path: "/agent/inbox/:id", access: "allow", src: "routes/inbox.ts", why: "soft-delete an inbox message" },
+  { method: "PATCH", path: "/agent/inbox/:id", access: "allow", src: "routes/inbox.ts", why: "mark read / star" },
+  { method: "POST", path: "/agent/inbox/:id/claim", access: "allow", src: "routes/inbox.ts", why: "claim a reward for the same account" },
+  { method: "POST", path: "/agent/inbox/pull", access: "allow", src: "routes/inbox.ts", why: "pull cloud broadcasts" },
+  { method: "POST", path: "/agent/inbox/read-all", access: "allow", src: "routes/inbox.ts", why: "mark all read" },
+  { method: "GET", path: "/agent/inbox/unread-count", access: "allow", src: "routes/inbox.ts", why: "inbox badge" },
+  { method: "POST", path: "/agent/inline", access: "allow", src: "routes/inline.ts", why: "inline writing completion for the note editor (no tools, nothing persisted; same shape as aside)" },
+  { method: "GET", path: "/agent/log", access: "allow", src: "routes/memory.ts", why: "read daily log" },
+  { method: "POST", path: "/agent/log", access: "deny-remote", src: "routes/memory.ts", why: "memory log write" },
+  { method: "GET", path: "/agent/memory", access: "allow", src: "routes/memory.ts", why: "read memory" },
+  { method: "POST", path: "/agent/memory", access: "deny-remote", src: "routes/memory.ts", why: "memory write" },
+  { method: "POST", path: "/agent/sync", access: "deny-remote", src: "routes/memory.ts", why: "memory sync (design appendix C)" },
+  { method: "GET", path: "/agent/sync/status", access: "allow", src: "routes/memory.ts", why: "memory sync status" },
+  { method: "DELETE", path: "/agent/agents/:slug/memory/dream", access: "deny-remote", src: "routes/memoryMaintenance.ts", why: "memory maintenance control" },
+  { method: "GET", path: "/agent/agents/:slug/memory/dream", access: "allow", src: "routes/memoryMaintenance.ts", why: "read memory maintenance state" },
+  { method: "POST", path: "/agent/agents/:slug/memory/dream", access: "deny-remote", src: "routes/memoryMaintenance.ts", why: "starts a memory rewrite" },
+  { method: "PUT", path: "/agent/agents/:slug/memory/dream", access: "deny-remote", src: "routes/memoryMaintenance.ts", why: "memory maintenance config" },
+  { method: "GET", path: "/agent/models", access: "allow", src: "routes/models.ts", why: "model list" },
+  { method: "PUT", path: "/agent/models/overrides", access: "deny-remote", src: "routes/models.ts", why: "model overrides config" },
+  { method: "GET", path: "/agent/plugins", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
+  { method: "DELETE", path: "/agent/plugins/:id", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
+  { method: "PUT", path: "/agent/plugins/:id/enabled", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
+  { method: "DELETE", path: "/agent/plugins/:id/files", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
+  { method: "GET", path: "/agent/plugins/:id/files", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
+  { method: "POST", path: "/agent/plugins/:id/files", access: "deny-remote", src: "routes/plugins.ts", why: "engine plugins are local-only" },
+  { 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: "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)" },
+  { method: "GET", path: "/agent/git-settings", access: "allow", src: "routes/projectContext.ts", why: "read Settings \u2192 Git" },
+  { method: "PUT", path: "/agent/git-settings", access: "deny-remote", src: "routes/projectContext.ts", why: "engine config.json write" },
+  { method: "GET", path: "/agent/project-context", access: "allow", src: "routes/projectContext.ts", why: "read project context" },
+  { method: "PUT", path: "/agent/project-context/doc", access: "deny-remote", src: "routes/projectContext.ts", why: "project instruction write (design appendix C)" },
+  { method: "POST", path: "/agent/project-context/git/branch", access: "deny-remote", src: "routes/projectContext.ts", why: "git repository write" },
+  { method: "POST", path: "/agent/project-context/git/commit", access: "deny-remote", src: "routes/projectContext.ts", why: "git commit (runs repository hooks)" },
+  { method: "POST", path: "/agent/project-context/git/init", access: "deny-remote", src: "routes/projectContext.ts", why: "git repository write" },
+  { method: "POST", path: "/agent/project-context/git/message", access: "deny-remote", src: "routes/projectContext.ts", why: "spends model quota; may run trusted repo filters" },
+  { method: "POST", path: "/agent/project-context/git/pending", access: "deny-remote", src: "routes/projectContext.ts", why: "may run trusted repo filters (trust=true)" },
+  { method: "POST", path: "/agent/project-context/git/push", access: "deny-remote", src: "routes/projectContext.ts", why: "git push with local credentials" },
+  { method: "POST", path: "/agent/project-context/git/trust", access: "deny-remote", src: "routes/projectContext.ts", why: "trusts repo-provided executable git config" },
+  { method: "DELETE", path: "/agent/project-context/icon", access: "deny-remote", src: "routes/projectContext.ts", why: "project icon write" },
+  { 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: "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)" },
+  { method: "GET", path: "/agent/providers", access: "deny-remote", src: "routes/providers.ts", why: "provider config (device page uses /unit/providers, keys stripped)" },
+  { method: "POST", path: "/agent/providers/fetch-models", access: "deny-remote", src: "routes/providers.ts", why: "provider config (design appendix C)" },
+  { method: "POST", path: "/agent/providers/test", access: "deny-remote", src: "routes/providers.ts", why: "provider config" },
+  { method: "GET", path: "/agent/websearch", access: "deny-remote", src: "routes/providers.ts", why: "web search config" },
+  { method: "PUT", path: "/agent/websearch", access: "deny-remote", src: "routes/providers.ts", why: "web search config (design appendix C)" },
+  { method: "POST", path: "/agent/websearch/test", access: "deny-remote", src: "routes/providers.ts", why: "web search config" },
+  { method: "GET", path: "/agent/remote/activity", access: "deny-remote", src: "routes/remote.ts", why: "in-flight run registry for the host main process (tray / keep-awake)" },
+  { method: "GET", path: "/agent/remote/activity/events", access: "deny-remote", src: "routes/remote.ts", why: "in-flight run registry feed for the host main process" },
+  { method: "POST", path: "/agent/remote/estop", access: "deny-remote", src: "routes/remote.ts", why: "emergency stop is a host-only action (design \xA76.5)" },
+  { method: "GET", path: "/agent/remote/restart-status", access: "deny-remote", src: "routes/remote.ts", why: "host-only exit checklist (running tasks / background processes) before restarting to update" },
+  { method: "POST", path: "/agent/remote/unlock", access: "deny-remote", src: "routes/remote.ts", why: "unlocking remote access needs local system auth on the host (design \xA76.1, D13)" },
+  { method: "GET", path: "/agent/runs", access: "allow", src: "routes/runs.ts", why: "list runs" },
+  { method: "POST", path: "/agent/runs", access: "allow", src: "routes/runs.ts", why: "start a run (field / approval-mode clamping is engine-side, P0 \u2463)" },
+  { method: "POST", path: "/agent/runs/:id/abort", access: "allow", src: "routes/runs.ts", why: "stop a run" },
+  { method: "GET", path: "/agent/runs/:id/events", access: "allow", src: "routes/runs.ts", why: "run event stream" },
+  { method: "POST", path: "/agent/runs/:id/steer", access: "allow", src: "routes/runs.ts", why: "steer a running run" },
+  { method: "DELETE", path: "/agent/runs/:id/steer/:messageId", access: "allow", src: "routes/runs.ts", why: "withdraw a queued steer message" },
+  { method: "GET", path: "/agent/compaction", access: "allow", src: "routes/sessions.ts", why: "read compaction settings" },
+  { method: "PUT", path: "/agent/compaction", access: "deny-remote", src: "routes/sessions.ts", why: "global compaction config" },
+  { method: "GET", path: "/agent/sessions", access: "allow", src: "routes/sessions.ts", why: "session list" },
+  { method: "POST", path: "/agent/sessions", access: "allow", src: "routes/sessions.ts", why: "create a session" },
+  { method: "DELETE", path: "/agent/sessions/:id", access: "deny-remote", src: "routes/sessions.ts", why: "irreversible hard delete of a local session (runs, messages, code checkpoints); remote uses archive (PATCH archived)" },
+  { method: "PATCH", path: "/agent/sessions/:id", access: "allow", src: "routes/sessions.ts", why: "rename / archive / model / project of a session (a remote project_path never widens /unit/host* reads: only locally confirmed project roots count)" },
+  { method: "POST", path: "/agent/sessions/:id/aside", access: "allow", src: "routes/sessions.ts", why: "btw aside (taint propagates, C5)" },
+  { method: "GET", path: "/agent/sessions/:id/background", access: "allow", src: "routes/sessions.ts", why: "background child sessions" },
+  { method: "POST", path: "/agent/sessions/:id/branch", access: "allow", src: "routes/sessions.ts", why: "branch a session (remote taint propagates, C5)" },
+  { method: "GET", path: "/agent/sessions/:id/checkpoints", access: "allow", src: "routes/sessions.ts", why: "list code checkpoints" },
+  { method: "POST", path: "/agent/sessions/:id/checkpoints/restore", access: "deny-remote", src: "routes/sessions.ts", why: "restores host files from checkpoints (design appendix C)" },
+  { method: "POST", path: "/agent/sessions/:id/compact", access: "allow", src: "routes/sessions.ts", why: "compact a session" },
+  { method: "GET", path: "/agent/sessions/:id/config", access: "allow", src: "routes/sessions.ts", why: "read session config" },
+  { method: "PATCH", path: "/agent/sessions/:id/config", access: "allow", src: "routes/sessions.ts", why: "session config patch (field subset + approval ceiling enforced engine-side, P0 \u2463 / C3)" },
+  { method: "PUT", path: "/agent/sessions/:id/config", access: "deny-remote", src: "routes/sessions.ts", why: "whole-config replace; remote uses PATCH" },
+  { method: "GET", path: "/agent/sessions/:id/detail", access: "allow", src: "routes/sessions.ts", why: "session detail" },
+  { method: "GET", path: "/agent/sessions/:id/messages", access: "allow", src: "routes/sessions.ts", why: "session messages" },
+  { method: "POST", path: "/agent/sessions/:id/messages/delete", access: "deny-remote", src: "routes/sessions.ts", why: "irreversible deletion of local conversation history" },
+  { method: "POST", path: "/agent/sessions/:id/team-members/:slug", access: "allow", src: "routes/sessions.ts", why: "open a team member child session (taint propagates, C5)" },
+  { method: "GET", path: "/agent/sessions/:id/timeline", access: "allow", src: "routes/sessions.ts", why: "session timeline" },
+  { method: "GET", path: "/agent/sessions/:id/usage", access: "allow", src: "routes/sessions.ts", why: "session usage" },
+  { method: "GET", path: "/agent/sessions/search", access: "allow", src: "routes/sessions.ts", why: "session search" },
+  { method: "POST", path: "/agent/solo/:kind/:id/open", access: "allow", src: "routes/solo.ts", why: "open the Agent direct-chat session" },
+  { method: "POST", path: "/agent/solo/:kind/:id/rotate", access: "allow", src: "routes/solo.ts", why: "start a fresh Agent direct-chat session" },
+  { method: "GET", path: "/agent/special/approvals", access: "allow", src: "routes/special.ts", why: "pending async approvals" },
+  { method: "GET", path: "/agent/special/approvals/:id", access: "allow", src: "routes/special.ts", why: "pending async approval" },
+  { method: "POST", path: "/agent/special/approvals/:id/approve", access: "allow", src: "routes/special.ts", why: "answer an async approval (D1/D2)" },
+  { method: "POST", path: "/agent/special/approvals/:id/reject", access: "allow", src: "routes/special.ts", why: "answer an async approval (D1/D2)" },
+  { method: "GET", path: "/agent/special/automation/actions", access: "allow", src: "routes/special.ts", why: "automation action catalog" },
+  { method: "GET", path: "/agent/special/automation/executions", access: "allow", src: "routes/special.ts", why: "automation executions" },
+  { method: "POST", path: "/agent/special/automation/kick", access: "deny-remote", src: "routes/special.ts", why: "kicks automations (design appendix C)" },
+  { method: "GET", path: "/agent/special/automation/runs", access: "allow", src: "routes/special.ts", why: "automation runs" },
+  { method: "GET", path: "/agent/special/automation/sessions", access: "allow", src: "routes/special.ts", why: "automation sessions" },
+  { method: "POST", path: "/agent/special/automation/triggers/:id/fire", access: "deny-remote", src: "routes/special.ts", why: "fires an automation (design appendix C)" },
+  { method: "GET", path: "/agent/special/config", access: "allow", src: "routes/special.ts", why: "renderer auth probe; remote callers get only on/off + two cadence values (P1-K10b projection)" },
+  { method: "POST", path: "/agent/special/config", access: "deny-remote", src: "routes/special.ts", why: "special-agent config write (design appendix C)" },
+  { method: "GET", path: "/agent/special/historian/activity", access: "allow", src: "routes/special.ts", why: "Historian activity" },
+  { method: "POST", path: "/agent/special/muse/feedback", access: "deny-remote", src: "routes/special.ts", why: "appends to Muse LOG (memory write into an autonomous Agent)" },
+  { method: "GET", path: "/agent/special/muse/library", access: "allow", src: "routes/special.ts", why: "Muse library" },
+  { method: "GET", path: "/agent/special/muse/library/file", access: "allow", src: "routes/special.ts", why: "Muse library file (read-only, realpath-bounded to the Library)" },
+  { method: "GET", path: "/agent/special/muse/status", access: "allow", src: "routes/special.ts", why: "Muse status; remote callers get the fields the Muse view / Space read, no absolute paths, budgets or last error (P1-M1A projection)" },
+  { method: "GET", path: "/agent/special/muse/todos", access: "allow", src: "routes/special.ts", why: "Muse todos" },
+  { method: "GET", path: "/agent/special/muse/todos/:id", access: "allow", src: "routes/special.ts", why: "Muse todo" },
+  { method: "PATCH", path: "/agent/special/muse/todos/:id", access: "allow", src: "routes/special.ts", why: "Muse todo status only (card landing / dismiss)" },
+  { method: "POST", path: "/agent/special/muse/todos/:id/approve", access: "allow", src: "routes/special.ts", why: "approve a Muse todo (D1/D2)" },
+  { method: "POST", path: "/agent/special/muse/todos/inject", access: "deny-remote", src: "routes/special.ts", why: "creates persistent follow-up execution (design appendix C)" },
+  { method: "GET", path: "/agent/special/muse/triggers", access: "allow", src: "routes/special.ts", why: "Muse triggers" },
+  { method: "POST", path: "/agent/special/muse/triggers", access: "deny-remote", src: "routes/special.ts", why: "creates persistent follow-up execution (design appendix C)" },
+  { method: "DELETE", path: "/agent/special/muse/triggers/:id", access: "deny-remote", src: "routes/special.ts", why: "Muse trigger config" },
+  { method: "GET", path: "/agent/special/schedule", access: "allow", src: "routes/special.ts", why: "Agent schedules" },
+  { method: "POST", path: "/agent/special/schedule/:slug/entries", access: "deny-remote", src: "routes/special.ts", why: "creates persistent follow-up execution (design appendix C)" },
+  { method: "DELETE", path: "/agent/special/schedule/:slug/entries/:id", access: "deny-remote", src: "routes/special.ts", why: "schedule write" },
+  { method: "GET", path: "/agent/teams", access: "allow", src: "routes/teams.ts", why: "team list" },
+  { method: "POST", path: "/agent/teams", access: "deny-remote", src: "routes/teams.ts", why: "create team" },
+  { method: "GET", path: "/agent/teams-meta", access: "allow", src: "routes/teams.ts", why: "team meta" },
+  { method: "PUT", path: "/agent/teams-meta", access: "deny-remote", src: "routes/teams.ts", why: "team meta write" },
+  { method: "DELETE", path: "/agent/teams/:slug", access: "deny-remote", src: "routes/teams.ts", why: "delete team" },
+  { method: "GET", path: "/agent/teams/:slug", access: "allow", src: "routes/teams.ts", why: "team detail" },
+  { method: "PATCH", path: "/agent/teams/:slug", access: "deny-remote", src: "routes/teams.ts", why: "update team" },
+  { method: "DELETE", path: "/agent/teams/:slug/avatar", access: "deny-remote", src: "routes/teams.ts", why: "update team avatar" },
+  { method: "GET", path: "/agent/teams/:slug/avatar", access: "allow", src: "routes/teams.ts", why: "team avatar" },
+  { method: "POST", path: "/agent/teams/:slug/avatar", access: "deny-remote", src: "routes/teams.ts", why: "update team avatar" },
+  { method: "POST", path: "/agent/teams/:slug/session/open", access: "allow", src: "routes/teams.ts", why: "open a team session" },
+  { method: "POST", path: "/agent/tts", access: "allow", src: "routes/tts.ts", why: "read aloud" },
+  { method: "POST", path: "/agent/tts/voices/clone", access: "deny-remote", src: "routes/tts.ts", why: "creates a provider voice" },
+  { method: "POST", path: "/agent/tts/voices/delete", access: "deny-remote", src: "routes/tts.ts", why: "deletes a provider voice" },
+  { method: "POST", path: "/agent/tts/voices/design", access: "deny-remote", src: "routes/tts.ts", why: "creates a provider voice" },
+  { method: "POST", path: "/agent/tts/voices/list", access: "deny-remote", src: "routes/tts.ts", why: "posts to a caller-chosen baseUrl from the host network and echoes the reply (SSRF pivot into the host LAN)" },
+  { method: "POST", path: "/agent/vision/describe", access: "allow", src: "routes/vision.ts", why: "describe an image for a non-vision model" },
+  { method: "POST", path: "/agent/wechat/connect", access: "deny-remote", src: "routes/wechat.ts", why: "WeChat binding is local-only" },
+  { method: "POST", path: "/agent/wechat/disconnect", access: "deny-remote", src: "routes/wechat.ts", why: "WeChat binding is local-only" },
+  { method: "POST", path: "/agent/wechat/login/start", access: "deny-remote", src: "routes/wechat.ts", why: "WeChat binding is local-only" },
+  { method: "GET", path: "/agent/wechat/login/status", access: "deny-remote", src: "routes/wechat.ts", why: "WeChat binding is local-only" },
+  { method: "POST", path: "/agent/wechat/session-agent", access: "deny-remote", src: "routes/wechat.ts", why: "WeChat binding is local-only" },
+  { method: "GET", path: "/agent/wechat/sessions", access: "deny-remote", src: "routes/wechat.ts", why: "WeChat binding is local-only" },
+  { method: "POST", path: "/agent/wechat/sessions/new", access: "deny-remote", src: "routes/wechat.ts", why: "WeChat binding is local-only" },
+  { method: "GET", path: "/agent/wechat/status", access: "deny-remote", src: "routes/wechat.ts", why: "WeChat binding is local-only" },
+  { method: "GET", path: "/agent/projects", access: "allow", src: "routes/workspace.ts", why: "list cloud workspace projects" },
+  { method: "POST", path: "/agent/projects", access: "deny-remote", src: "routes/workspace.ts", why: "create cloud workspace project (design appendix C)" },
+  { method: "POST", path: "/agent/workspace/delete", access: "deny-remote", src: "routes/workspace.ts", why: "destructive workspace delete (design appendix C)" },
+  { method: "GET", path: "/agent/workspace/download", access: "allow", src: "routes/workspace.ts", why: "download artifacts" },
+  { method: "GET", path: "/agent/workspace/list", access: "allow", src: "routes/workspace.ts", why: "session workspace listing" },
+  { method: "GET", path: "/agent/workspace/read", access: "allow", src: "routes/workspace.ts", why: "session workspace read" },
+  { method: "POST", path: "/agent/workspace/upload", access: "allow", src: "routes/workspace.ts", why: "attachments from the remote device (design \xA76.6)" },
+  { method: "GET", path: "/health", access: "allow", src: "standalone/main.ts", why: "unauthenticated liveness probe" }
+];
+
+// desktop/electron/unitCaller.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+var UNIT_CALLER_HEADER = "x-unit-caller";
+var ENGINE_CALLER_HEADER = "x-forsion-remote-caller";
+var ASSERTION_WINDOW_MS = 6e4;
+var SEEN_TTL_MS = 12e4;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var KINDS = /* @__PURE__ */ new Set(["phone", "desktop"]);
+var UNSAFE_CHARS = /[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u2028-\u202e\u2060-\u2069\ufeff]/g;
+var cleanText = (v, max) => typeof v === "string" ? v.replace(UNSAFE_CHARS, "").trim().slice(0, max) : null;
+function sanitizeProxyCaller(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const r = raw;
+  if (typeof r.unit !== "string" || !UUID_RE.test(r.unit)) return null;
+  if (typeof r.kind !== "string" || !KINDS.has(r.kind)) return null;
+  return {
+    unit: r.unit.toLowerCase(),
+    kind: r.kind,
+    name: cleanText(r.name, 120) ?? "",
+    platform: cleanText(r.platform, 40) || null,
+    registeredAt: cleanText(r.registeredAt, 40) || null
+  };
+}
+var b64 = (s) => Buffer.from(s, "utf8").toString("base64url");
+var macOf = (key, body) => createHmac("sha256", key).update("v1." + body).digest();
+function verifyProxyCaller(key, header, req, seen, nowMs = Date.now()) {
+  if (!key || typeof header !== "string" || header.length > 8192) return { ok: false, reason: "malformed" };
+  const m = /^v1\.([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]+)$/.exec(header);
+  if (!m) return { ok: false, reason: "malformed" };
+  const given = Buffer.from(m[2], "base64url");
+  const want = macOf(key, m[1]);
+  if (given.length !== want.length || !timingSafeEqual(given, want)) return { ok: false, reason: "bad-mac" };
+  let p;
+  try {
+    p = JSON.parse(Buffer.from(m[1], "base64url").toString("utf8"));
+  } catch {
+    return { ok: false, reason: "malformed" };
+  }
+  if (!p || typeof p !== "object" || Array.isArray(p)) return { ok: false, reason: "malformed" };
+  if (p.pur !== "proxy") return { ok: false, reason: "purpose" };
+  if (p.m !== req.method) return { ok: false, reason: "method" };
+  if (p.t !== req.url) return { ok: false, reason: "target" };
+  if (typeof p.iat !== "number" || !Number.isFinite(p.iat) || Math.abs(nowMs - p.iat) > ASSERTION_WINDOW_MS) return { ok: false, reason: "stale" };
+  const d = p.d;
+  if (typeof d !== "string" || !d || d.length > 128) return { ok: false, reason: "malformed" };
+  const caller = sanitizeProxyCaller(p.c);
+  if (!caller) return { ok: false, reason: "malformed" };
+  const exp = seen.get(d);
+  if (exp !== void 0 && exp > nowMs) return { ok: false, reason: "replay" };
+  seen.set(d, nowMs + SEEN_TTL_MS);
+  return { ok: true, caller, dispatchId: d };
+}
+function gcSeenCallers(seen, nowMs = Date.now()) {
+  for (const [d, exp] of seen) if (exp <= nowMs) seen.delete(d);
+}
+function encodeEngineCaller(c) {
+  return b64(JSON.stringify({ u: c.unit, k: c.kind, n: c.name, p: c.platform, r: c.registeredAt }));
+}
+function callerOf(via, pair, caller) {
+  if (via === "tunnel") return caller ? { kind: "unit", caller } : { kind: "account" };
+  if (via === "p2p") return { kind: "p2p" };
+  return { kind: "paired", pairId: pair?.pairId ?? "", name: pair?.name ?? "" };
+}
+
+// desktop/shared/remoteSessions.ts
+var REMOTE_SESSIONS_OFF = "REMOTE_SESSIONS_OFF";
+var TRUST_REASON_SET = {
+  strict: true,
+  "never-prompts": true,
+  "not-signed-in": true,
+  "roster-miss": true,
+  "roster-unreachable": true,
+  "no-answer": true,
+  busy: true
+};
+var TRUST_REASONS = Object.keys(TRUST_REASON_SET);
+var REMOTE_PROMPT_TTL_MS = 2 * 6e4;
+
+// desktop/electron/remoteSessionGate.ts
+var REMOTE_BASE_TIER_NON_GET = [
+  ["POST", "/agent/runs/:runId/approvals/:approvalId"],
+  // 答审批(D1 / D2)
+  ["POST", "/agent/runs/:runId/inquiries/:inquiryId"],
+  // 答询问(D1)
+  ["POST", "/agent/special/approvals/:id/approve"],
+  // 异步审批(D2)
+  ["POST", "/agent/special/approvals/:id/reject"],
+  ["POST", "/agent/runs/:id/abort"],
+  // 远端停止(§6.1 急停「远端停止额外允许」)
+  // Agent Desk 截图回传:回应本机 run 的 desk_screenshot,shotId 随机且绑 run(P0 ②),与答审批同类;
+  // 放进会话档会让开关关时看着本机 run 的设备页把这个工具拖到超时。
+  ["POST", "/agent/runs/:runId/captures/:shotId"],
+  // 不起执行、不建 / 改会话的杂务(K4 §8 设计文档修正 1;开关关时设备页的收件箱照常可用):
+  ["PATCH", "/agent/inbox/:id"],
+  ["DELETE", "/agent/inbox/:id"],
+  ["POST", "/agent/inbox/:id/claim"],
+  ["POST", "/agent/inbox/pull"],
+  ["POST", "/agent/inbox/read-all"],
+  ["PATCH", "/agent/special/muse/todos/:id"],
+  // 只改卡片状态(落点 / 忽略);`…/approve` 起自主执行,在会话档
+  ["POST", "/agent/reply-segments"],
+  // 只读辅助
+  ["POST", "/agent/commands/:name/expand"]
+];
+var escapeRe = (x) => x.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var compile = (path) => new RegExp("^" + path.split("/").map((seg) => seg.startsWith(":") ? "[^/]+" : escapeRe(seg.toLowerCase())).join("/") + "$");
+var BASE_KEYS = new Set(REMOTE_BASE_TIER_NON_GET.map(([m, p]) => `${m} ${p.toLowerCase()}`));
+var ALLOW_ROWS = ENGINE_ROUTES.filter((r) => r.access === "allow").map((r) => ({
+  method: r.method,
+  base: BASE_KEYS.has(`${r.method} ${r.path.toLowerCase()}`),
+  re: compile(r.path)
+}));
+function remoteEngineTier(method, normPath) {
+  const m = method.toUpperCase() === "HEAD" ? "GET" : method.toUpperCase();
+  if (m === "GET") return "base";
+  const p = normPath.toLowerCase();
+  let hit = false;
+  for (const r of ALLOW_ROWS) {
+    if (r.method !== m || !r.re.test(p)) continue;
+    if (!r.base) return "session";
+    hit = true;
+  }
+  return hit ? "base" : "session";
+}
+var REMOTE_SESSIONS_OFF_DETAIL = "Remote sessions are turned off on this device";
+var offResult = () => ({ ok: false, status: 403, body: { code: REMOTE_SESSIONS_OFF, detail: REMOTE_SESSIONS_OFF_DETAIL } });
+function baseTierOnly(method, normPath) {
+  return remoteEngineTier(method, normPath) === "base" ? { ok: true } : offResult();
+}
+
+// desktop/shared/remoteSafety.ts
+var REMOTE_LOCKED = "REMOTE_LOCKED";
+
+// desktop/electron/remoteLockGate.ts
+var REMOTE_LOCKED_BODY = { code: REMOTE_LOCKED, detail: "Remote access to this computer is locked. Unlock it on the computer itself." };
+var READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+var ABORT_PATH = /^\/agent\/runs\/[^/]+\/abort$/i;
+function lockedRequestAllowed(method, path) {
+  const m = String(method || "GET").toUpperCase();
+  if (READ_METHODS.has(m)) return true;
+  return m === "POST" && path === "/vault/asset-token";
+}
+function lockedEngineAllowed(method, normPath) {
+  const m = String(method || "GET").toUpperCase();
+  if (READ_METHODS.has(m)) return true;
+  return m === "POST" && ABORT_PATH.test(normPath);
+}
+var VAULT_RPC_READ = /* @__PURE__ */ new Set([
+  IPC.listPages,
+  IPC.listFiles,
+  IPC.readPage,
+  IPC.readVaultBytes,
+  IPC.search,
+  IPC.backlinks,
+  IPC.exclusiveAssets,
+  IPC.listTags,
+  IPC.pagesByTag,
+  IPC.resolveEmbed,
+  IPC.blockBacklinks,
+  IPC.listFolders,
+  IPC.listTrash,
+  IPC.pageIcons,
+  IPC.dbRead,
+  IPC.drawingRead,
+  IPC.readTextFile,
+  IPC.listPageProps,
+  IPC.pluginDataRead
+]);
+
+// desktop/electron/unitWeb.ts
+var VAULT_RPC_ALLOW = /* @__PURE__ */ new Set([
+  IPC.restoreVault,
+  IPC.listPages,
+  IPC.listFiles,
+  IPC.loadPage,
+  IPC.readPage,
+  IPC.newPage,
+  IPC.savePage,
+  IPC.renamePage,
+  IPC.reconcilePage,
+  IPC.saveAsset,
+  IPC.saveVaultBytes,
+  IPC.readVaultBytes,
+  IPC.saveAttachment,
+  IPC.search,
+  IPC.backlinks,
+  IPC.exclusiveAssets,
+  IPC.reindex,
+  IPC.listTags,
+  IPC.pagesByTag,
+  IPC.deletePage,
+  IPC.movePage,
+  IPC.resolveEmbed,
+  IPC.blockBacklinks,
+  IPC.listFolders,
+  IPC.createFolder,
+  IPC.renameFolder,
+  IPC.deleteFolder,
+  IPC.moveFolder,
+  IPC.trashEntry,
+  IPC.listTrash,
+  IPC.restoreTrash,
+  IPC.deleteTrashEntry,
+  IPC.emptyTrash,
+  IPC.pageIcons,
+  IPC.fetchLinkMeta,
+  IPC.searchImages,
+  IPC.dbRead,
+  IPC.dbWrite,
+  IPC.dbWriteCas,
+  IPC.drawingRead,
+  IPC.drawingWrite,
+  IPC.readTextFile,
+  IPC.writeTextFile,
+  IPC.listPageProps,
+  IPC.setPageFrontmatter,
+  IPC.renamePageFile,
+  IPC.renameDbFile,
+  IPC.pluginDataRead,
+  IPC.pluginDataWrite,
+  IPC.patchMark
+]);
+var VAULT_RPC_LOCAL_ONLY = /* @__PURE__ */ new Set([IPC.emptyTrash, IPC.deleteTrashEntry]);
+var UNIT_INTERNAL_HEADER = "x-unit-internal";
+var UNIT_P2P_HEADER = "x-unit-p2p";
+var LOCAL_ONLY_BODY = { code: "LOCAL_ONLY", detail: "This action is only available on the device itself" };
+var BAD_CALLER_BODY = { code: "BAD_CALLER_ASSERTION", detail: "Invalid caller assertion" };
+var ENGINE_PATH_CHARS = /^(?:[A-Za-z0-9\-._~!$&'()*+,;=:@/]|%[0-9A-Fa-f]{2})*$/;
+var ENGINE_QUERY_CHARS = /^[\x21-\x7e]*$/;
+function normalizeEnginePath(raw) {
+  if (!ENGINE_PATH_CHARS.test(raw)) return null;
+  if (/%(?:2f|5c|2e)/i.test(raw)) return null;
+  const segs = raw.split("/").filter((x) => x !== "");
+  if (segs.some((x) => x === "." || x === "..")) return null;
+  return "/" + segs.join("/");
+}
+function engineTarget(rawAfterEngine) {
+  if (rawAfterEngine.includes("#")) return null;
+  const q = rawAfterEngine.indexOf("?");
+  const rawPath = q >= 0 ? rawAfterEngine.slice(0, q) : rawAfterEngine;
+  const query = q >= 0 ? rawAfterEngine.slice(q) : "";
+  if (query && !ENGINE_QUERY_CHARS.test(query.slice(1))) return null;
+  const path = normalizeEnginePath(rawPath);
+  return path ? { path, query } : null;
+}
+var escapeRe2 = (x) => x.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var COMPILED_ROUTES = ENGINE_ROUTES.map((r) => ({
+  method: r.method,
+  access: r.access,
+  re: new RegExp("^" + r.path.split("/").map((seg) => seg.startsWith(":") ? "[^/]+" : escapeRe2(seg.toLowerCase())).join("/") + "$")
+}));
+function engineRouteAccess(method, normPath) {
+  const m = method.toUpperCase() === "HEAD" ? "GET" : method.toUpperCase();
+  const p = normPath.toLowerCase();
+  let allowed = false;
+  for (const r of COMPILED_ROUTES) {
+    if (r.method !== m || !r.re.test(p)) continue;
+    if (r.access !== "allow") return "deny";
+    allowed = true;
+  }
+  return allowed ? "allow" : "unknown";
+}
+var decodeRpcArgs = (args2) => args2.map((a) => a && typeof a === "object" && typeof a.__u8 === "string" ? Buffer.from(a.__u8, "base64") : a);
+var encodeRpcResult = (r) => r instanceof Uint8Array ? { __u8: Buffer.from(r).toString("base64") } : r;
+var sha256 = (s) => createHash("sha256").update(s).digest("hex");
+var PAIR_TTL_MS = 2 * 6e4;
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".css": "text/css",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm",
+  ".webp": "image/webp",
+  ".txt": "text/plain; charset=utf-8",
+  // vault 资源面(/vault/asset)常见附件类型
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".pdf": "application/pdf",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".md": "text/markdown; charset=utf-8"
+};
+var HOST_DOWNLOAD_MAX_BYTES = 256 * 1024 * 1024;
+var DOWNLOAD_MIME = {
+  ...MIME,
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".doc": "application/msword",
+  ".xls": "application/vnd.ms-excel",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".csv": "text/csv; charset=utf-8",
+  ".zip": "application/zip",
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8"
+};
+function attachmentDisposition(name) {
+  const safe = name.replace(/[\r\n]/g, "") || "download";
+  const ascii = safe.replace(/[^\x20-\x7e]|["\\]/g, "_");
+  const utf8 = encodeURIComponent(safe).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+  return `attachment; filename="${ascii}"; filename*=UTF-8''${utf8}`;
+}
+var isLoopback = (addr) => addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+var secretEq = (got, want) => {
+  if (typeof got !== "string" || !want) return false;
+  const a = Buffer.from(got);
+  const b = Buffer.from(want);
+  return a.length === b.length && timingSafeEqual2(a, b);
+};
+var PLACEHOLDER = `<!doctype html><meta charset="utf-8"><title>Forsion Unit</title>
+<body style="font-family:system-ui;max-width:560px;margin:80px auto;line-height:1.7">
+<h2>\u672C\u673A\u672A\u6346 web \u6784\u5EFA</h2>
+<p>\u8FD9\u53F0 Forsion \u7684\u4E92\u8054\u670D\u52A1\u5DF2\u5728\u8FD0\u884C,\u4F46\u7F3A\u5C11\u7F51\u9875\u6E32\u67D3\u5C42\u6784\u5EFA\u4EA7\u7269\u3002</p>
+<p>\u5728\u8FD9\u53F0\u8BBE\u5907\u4E0A\u6267\u884C:</p>
+<pre style="background:#f4f4f4;padding:12px;border-radius:8px">cd Forsion-Genesis/desktop && node scripts/build-unit-web.mjs</pre>
+<p>\u6216\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF <code>TANGU_UNIT_WEB_DIST</code> \u6307\u5411\u5DF2\u6709\u7684 web \u6784\u5EFA\u76EE\u5F55\u540E\u91CD\u542F Forsion\u3002</p></body>`;
+function startUnitWeb(deps, opts) {
+  if (deps.projection && !/^\/(?:[a-zA-Z0-9_-]+\/)*$/.test(deps.projection.basePath)) {
+    throw new Error("Projection basePath must be an absolute path ending in /");
+  }
+  const internalSecret = randomUUID();
+  const p2pSecret = randomBytes(32).toString("hex");
+  const proxyCallerKey = randomBytes(32).toString("hex");
+  const seenCallerDispatch = /* @__PURE__ */ new Map();
+  const ownerProjection = deps.projection?.mode === "local";
+  const pending = /* @__PURE__ */ new Map();
+  const pendingByIp = /* @__PURE__ */ new Map();
+  const assetTokens = /* @__PURE__ */ new Map();
+  const ASSET_TTL_MS = 10 * 6e4;
+  const gc = () => {
+    const now = Date.now();
+    for (const [id, p] of pending) {
+      if (p.expires < now) {
+        pending.delete(id);
+        if (pendingByIp.get(p.ip) === id) pendingByIp.delete(p.ip);
+      }
+    }
+    for (const [t, rec] of assetTokens) if (rec.exp < now) assetTokens.delete(t);
+    gcSeenCallers(seenCallerDispatch, now);
+  };
+  const authInfo = (req) => {
+    if (isLoopback(req.socket.remoteAddress)) {
+      if (secretEq(req.headers[UNIT_INTERNAL_HEADER], internalSecret)) return { ok: true, pairHash: null, via: "tunnel" };
+      if (secretEq(req.headers[UNIT_P2P_HEADER], p2pSecret)) return { ok: true, pairHash: null, via: "p2p" };
+    }
+    const m = /^Bearer (.+)$/.exec(String(req.headers.authorization || ""));
+    if (!m) return { ok: false, pairHash: null, via: null };
+    const h = sha256(m[1]);
+    const hit = deps.pairedDevices.list().some((d) => d.tokenHash === h);
+    return { ok: hit, pairHash: hit ? h : null, via: hit ? "lan" : null };
+  };
+  const authed = (req) => authInfo(req).ok;
+  const pairInfo = (info) => {
+    if (!info.pairHash) return null;
+    const d = deps.pairedDevices.list().find((x) => x.tokenHash === info.pairHash);
+    return d ? { pairId: d.id, name: d.name } : null;
+  };
+  const resolveCaller = (req, info) => {
+    if (info.via !== "tunnel") return { ok: true, caller: null };
+    const raw = req.headers[UNIT_CALLER_HEADER];
+    if (raw === void 0) return { ok: true, caller: null };
+    if (typeof raw !== "string") return { ok: false };
+    const r = verifyProxyCaller(proxyCallerKey, raw, { method: req.method || "GET", url: req.url || "" }, seenCallerDispatch);
+    if (!r.ok) {
+      deps.log(`[unit-web] \u8C03\u7528\u65B9\u65AD\u8A00\u65E0\u6548(${r.reason}),\u5DF2\u62D2\u7EDD`);
+      return { ok: false };
+    }
+    return { ok: true, caller: r.caller };
+  };
+  const assetTokenLive = (at) => {
+    const rec = assetTokens.get(at);
+    if (!rec || rec.exp < Date.now()) return false;
+    return rec.pairHash === null || deps.pairedDevices.list().some((d) => d.tokenHash === rec.pairHash);
+  };
+  const underVaultReal = async (abs, rootRaw) => {
+    if (!rootRaw) return null;
+    try {
+      const [real, rootReal] = await Promise.all([realpath(abs), realpath(rootRaw)]);
+      return real === rootReal || real.startsWith(rootReal + sep) ? real : null;
+    } catch {
+      return null;
+    }
+  };
+  const json = (res, status, body) => {
+    const buf = Buffer.from(JSON.stringify(body));
+    res.writeHead(status, { "Content-Type": "application/json", "Content-Length": buf.length });
+    res.end(buf);
+  };
+  const readBody = (req, limit = 64 * 1024) => new Promise((resolve8, reject) => {
+    let n = 0;
+    const chunks = [];
+    req.on("data", (c) => {
+      n += c.length;
+      if (n > limit) {
+        reject(new Error("body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => resolve8(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+  const isLocalOnlyEnginePath = (path) => {
+    let p = path;
+    try {
+      p = decodeURIComponent(new URL(path, "http://x").pathname);
+    } catch {
+    }
+    return p.toLowerCase().replace(/\/{2,}/g, "/").startsWith("/engine/agent/browser-extension");
+  };
+  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" });
+      return;
+    }
+    const target = new URL(engine.url);
+    const headers = { Authorization: `Bearer ${engine.token}` };
+    for (const k of ["content-type", "accept", "content-length"]) {
+      const v = req.headers[k];
+      if (typeof v === "string") headers[k] = v;
+    }
+    if (via) {
+      headers["x-forsion-remote"] = via;
+      if (engine.remoteMark) headers["x-forsion-remote-mark"] = engine.remoteMark;
+      if (via === "tunnel" && caller) headers[ENGINE_CALLER_HEADER] = encodeEngineCaller(caller);
+    }
+    const up = http.request({
+      host: target.hostname,
+      port: target.port,
+      path,
+      method: req.method,
+      headers
+    }, (upRes) => {
+      const h = {};
+      for (const k of ["content-type", "cache-control"]) {
+        const v = upRes.headers[k];
+        if (typeof v === "string") h[k] = v;
+      }
+      if (String(upRes.headers["content-type"] || "").includes("text/event-stream")) h["X-Accel-Buffering"] = "no";
+      res.writeHead(upRes.statusCode || 502, h);
+      upRes.pipe(res);
+      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}` });
+    });
+    req.pipe(up);
+  };
+  const serveStatic = async (res, urlPath) => {
+    const dist2 = deps.webDistDir();
+    if (!dist2) {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-cache" });
+      res.end(PLACEHOLDER);
+      return;
+    }
+    let rel = decodeURIComponent(urlPath.split("?")[0]);
+    if (!extname(rel)) rel = "/index.html";
+    const norm = normalize(rel).replace(/^([/\\])+/, "");
+    if (norm.startsWith("..")) {
+      json(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" });
+        return;
+      }
+      let buf = await readFile(fileReal);
+      const ext = extname(norm);
+      if (norm === "index.html") {
+        const encode = (value) => JSON.stringify(value).replace(/</g, "\\u003c");
+        const meta = { ...deps.meta, ...deps.projection ? { projection: deps.projection.mode, browserStorage: deps.projection.mode === "public", account: deps.account?.metadata(), capabilities: deps.projection.capabilities?.(), localCapabilities: deps.projection.mode === "local" ? deps.projection.localCapabilities?.() : void 0 } : {} };
+        const baseTag = deps.projection ? `<base href="${deps.projection.basePath}">` : "";
+        const inject = `${baseTag}<script>window.__FORSION_UNIT_PAGE__=${encode(meta)};window.__FORSION_PRODUCT_RUNTIME__=${encode(deps.projection?.product ?? PRODUCT)}</script>`;
+        let html = buf.toString("utf8").replace(/<head>/i, `<head>${inject}`);
+        html = html.replace(/<meta[^>]*http-equiv=["']Content-Security-Policy["'][^>]*>/i, (tag) => tag.replace(/(content=(["']))([\s\S]*?)\2/i, (_m, head, quote, csp) => {
+          const next = csp.includes("'unsafe-eval'") ? csp : csp.replace(/script-src([^;]*)/i, (_d, srcs) => `script-src${srcs} 'unsafe-eval'`);
+          return `${head}${next}${quote}`;
+        }));
+        buf = Buffer.from(html);
+      }
+      const h = { "Content-Type": MIME[ext] || "application/octet-stream", "Content-Length": buf.length };
+      if (norm === "index.html") h["Cache-Control"] = "no-cache";
+      else if (/^assets[\\/]/.test(norm)) h["Cache-Control"] = "public, max-age=31536000, immutable";
+      res.writeHead(200, h);
+      res.end(buf);
+    } catch {
+      json(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" });
+      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" });
+      return;
+    }
+    const f = await deps.openHostFile(p);
+    if (!f) {
+      json(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 });
+      return;
+    }
+    const name = p.split(/[\\/]/).filter(Boolean).pop() || "download";
+    res.writeHead(200, {
+      "Content-Type": DOWNLOAD_MIME[extname(f.real).toLowerCase()] || "application/octet-stream",
+      "Content-Length": f.size,
+      "Content-Disposition": attachmentDisposition(name),
+      // 同 /vault/asset:主机文件是不受信内容。隧道的 /stream 面不转 Content-Disposition,有人把下载链接当页面直开时,
+      // HTML / SVG 会在鉴权过的 proxy origin 上执行 —— nosniff + CSP sandbox 惰化(网关宣告 stream-sec-headers 才走流式,见 unitHost.streamWorthy)。
+      "X-Content-Type-Options": "nosniff",
+      "Content-Security-Policy": "sandbox",
+      "Cache-Control": "no-store"
+    });
+    if (f.size === 0) {
+      await f.fh.close().catch(() => {
+      });
+      res.end();
+      return;
+    }
+    const stream = f.fh.createReadStream({ start: 0, end: f.size - 1 });
+    stream.on("error", () => res.destroy());
+    res.on("close", () => stream.destroy());
+    stream.pipe(res);
+  };
+  const plainPath = (req) => {
+    let u = req.url || "/";
+    if (deps.projection) {
+      const prefix = deps.projection.basePath.replace(/\/$/, "");
+      if (u.startsWith(prefix + "/")) u = u.slice(prefix.length);
+    }
+    return u.split("?")[0];
+  };
+  const lockedNow = () => {
+    if (!deps.remoteLock) return false;
+    try {
+      return deps.remoteLock();
+    } catch {
+      return true;
+    }
+  };
+  const handler = async (req, res) => {
+    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);
+        return;
+      }
+    }
+    if (await deps.routeRequest?.(req, res)) return;
+    gc();
+    let url = req.url || "/";
+    if (deps.projection) {
+      const prefix = deps.projection.basePath.replace(/\/$/, "");
+      if (url === prefix || url.startsWith(prefix + "?")) {
+        res.writeHead(308, { Location: prefix + "/" + url.slice(prefix.length) });
+        res.end();
+        return;
+      }
+      if (url.startsWith(prefix + "/")) url = url.slice(prefix.length);
+    }
+    const path = url.split("?")[0];
+    const ip = req.socket.remoteAddress || "unknown";
+    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" });
+        return;
+      }
+      if (path === "/unit/whoami") {
+        json(res, 200, { ok: true, scope: "shell" });
+        return;
+      }
+      if (path === "/unit/plugins") {
+        json(res, 200, { appVersion: deps.meta.version, plugins: await deps.readPlugins() });
+        return;
+      }
+      if (path === "/unit/spaces") {
+        json(res, 200, { spaces: await deps.readSpaces() });
+        return;
+      }
+      if (path === "/unit/config") {
+        json(res, 200, { config: {} });
+        return;
+      }
+      if (path === "/unit/providers") {
+        json(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?.() });
+        return;
+      }
+      if (/^\/(?:unit|vault|engine)(?:\/|$)/.test(path)) {
+        json(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?.() } : {} });
+      return;
+    }
+    if (deps.projection?.mode === "local" && path.startsWith("/unit/pair/")) {
+      json(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" });
+        return;
+      }
+      let name = "\u672A\u547D\u540D\u8BBE\u5907";
+      try {
+        name = String(JSON.parse(await readBody(req))?.name || name).slice(0, 60);
+      } catch {
+      }
+      const p = {
+        id: randomUUID(),
+        name,
+        code: String(Math.floor(Math.random() * 1e6)).padStart(6, "0"),
+        ip,
+        expires: Date.now() + PAIR_TTL_MS,
+        status: "pending"
+      };
+      pending.set(p.id, p);
+      pendingByIp.set(ip, p.id);
+      json(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;
+        if (!ok) {
+          live.status = "denied";
+          return;
+        }
+        const token = randomBytes(32).toString("hex");
+        await deps.pairedDevices.add({ id: randomUUID(), name: live.name, tokenHash: sha256(token), createdAt: Date.now() });
+        live.status = "approved";
+        live.token = token;
+        deps.log(`[unit-web] \u5DF2\u914D\u5BF9\u8BBE\u5907\u300C${live.name}\u300D(${ip})`);
+      }).catch((e) => deps.log(`[unit-web] \u914D\u5BF9\u786E\u8BA4\u5931\u8D25: ${e?.message || e}`));
+      return;
+    }
+    if (path === "/unit/pair/poll" && req.method === "GET") {
+      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" });
+        return;
+      }
+      if (p.status === "approved" && p.token) {
+        const token = p.token;
+        pending.delete(id);
+        pendingByIp.delete(p.ip);
+        json(res, 200, { status: "approved", token });
+        return;
+      }
+      json(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" });
+        return;
+      }
+      json(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" });
+        return;
+      }
+      if (!deps.p2pAnswer) {
+        json(res, 501, { detail: "\u672C\u7AEF\u4E0D\u652F\u6301 P2P \u76F4\u8FDE", code: "P2P_UNSUPPORTED" });
+        return;
+      }
+      let offer = "";
+      try {
+        offer = String(JSON.parse(await readBody(req))?.sdp || "");
+      } catch {
+      }
+      if (!offer) {
+        json(res, 400, { detail: "\u7F3A offer SDP" });
+        return;
+      }
+      try {
+        json(res, 200, { sdp: await deps.p2pAnswer(offer) });
+      } catch (e) {
+        json(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" });
+        return;
+      }
+      json(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" });
+        return;
+      }
+      json(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" });
+        return;
+      }
+      json(res, 200, { providers: await deps.readProviders() });
+      return;
+    }
+    if ((path === "/unit/hostfile" || path === "/unit/hostfile/download") && req.method === "GET") {
+      const q = hostFileRequest(req, res, url);
+      if (!q) return;
+      if (path === "/unit/hostfile/download") {
+        await sendHostDownload(res, q.p);
+        return;
+      }
+      const f = await deps.readHostFile(q.p, q.via === "tunnel" ? 4 * 1024 * 1024 : void 0);
+      if (!f) {
+        json(res, 404, { detail: "not readable" });
+        return;
+      }
+      json(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" });
+        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" });
+        return;
+      }
+      json(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" });
+        return;
+      }
+      if (req.method === "GET") {
+        json(res, 200, { config: await deps.readConfig() });
+        return;
+      }
+      let patch;
+      try {
+        patch = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { detail: "bad body" });
+        return;
+      }
+      json(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" });
+        return;
+      }
+      const rc = resolveCaller(req, info);
+      if (!rc.ok) {
+        json(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" });
+        return;
+      }
+      json(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" });
+        return;
+      }
+      if (isLocalOnlyEnginePath(url)) {
+        if (!engineTarget(url.slice("/engine".length))) {
+          json(res, 400, { detail: "Ambiguous engine path", code: "BAD_PATH" });
+          return;
+        }
+        json(res, 403, LOCAL_ONLY_BODY);
+        return;
+      }
+      if (ownerProjection) {
+        proxyEngine(req, res, url.slice("/engine".length) || "/", null, null);
+        return;
+      }
+      const target = engineTarget(url.slice("/engine".length));
+      if (!target) {
+        json(res, 400, { detail: "Ambiguous engine path", code: "BAD_PATH" });
+        return;
+      }
+      if (engineRouteAccess(method, target.path) !== "allow") {
+        json(res, 403, LOCAL_ONLY_BODY);
+        return;
+      }
+      const rc = resolveCaller(req, info);
+      if (!rc.ok) {
+        json(res, 403, BAD_CALLER_BODY);
+        return;
+      }
+      if (lockedNow() && !lockedEngineAllowed(method, target.path)) {
+        json(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);
+        return;
+      }
+      proxyEngine(req, res, target.path + target.query, info.via, rc.caller);
+      return;
+    }
+    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" });
+        return;
+      }
+      const q = new URL(url, "http://x").searchParams;
+      const at = String(q.get("at") || "");
+      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" });
+          return;
+        }
+        let body;
+        try {
+          body = JSON.parse(await readBody(req, 32 * 1024 * 1024));
+        } catch {
+          json(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" });
+          return;
+        }
+        if (!ownerProjection && VAULT_RPC_LOCAL_ONLY.has(ch)) {
+          json(res, 403, LOCAL_ONLY_BODY);
+          return;
+        }
+        if (!ownerProjection && lockedNow() && !VAULT_RPC_READ.has(ch)) {
+          json(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 });
+        } catch (e) {
+          json(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" });
+          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 });
+        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" });
+          return;
+        }
+        const exact = q.get("path");
+        let abs = null;
+        try {
+          abs = exact != null ? vault.absPath(exact) : await vault.assetAbs(q.get("page"), String(q.get("ref") || ""));
+        } catch {
+        }
+        const real = abs ? await underVaultReal(abs, vault.root()) : null;
+        if (!real) {
+          json(res, 404, { detail: "not found" });
+          return;
+        }
+        const stream = createReadStream(real);
+        stream.on("error", () => {
+          if (!res.headersSent) json(res, 404, { detail: "not found" });
+          else res.destroy();
+        });
+        stream.once("open", () => {
+          const mime = MIME[extname(real).toLowerCase()] || "application/octet-stream";
+          const h = { "Content-Type": mime, "X-Content-Type-Options": "nosniff" };
+          if (mime !== "application/pdf") h["Content-Security-Policy"] = "sandbox";
+          res.writeHead(200, h);
+          stream.pipe(res);
+        });
+        res.on("close", () => stream.destroy());
+        return;
+      }
+      if (path === "/vault/events" && req.method === "GET") {
+        if (!assetAuthed()) {
+          json(res, 401, { detail: "\u8D44\u6E90\u4EE4\u724C\u65E0\u6548", code: "ASSET_TOKEN" });
+          return;
+        }
+        const viaAt = at !== "" && assetTokenLive(at);
+        const bearerInfo = viaAt ? null : authInfo(req);
+        const stillAuthed = () => viaAt ? assetTokenLive(at) : bearerInfo?.pairHash != null ? deps.pairedDevices.list().some((d) => d.tokenHash === bearerInfo.pairHash) : true;
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache, no-transform",
+          "X-Accel-Buffering": "no"
+        });
+        res.write(": connected\n\n");
+        const unsub = vault.onEvent((ch, payload, origin) => {
+          if (!stillAuthed()) {
+            res.end();
+            return;
+          }
+          res.write(`data: ${JSON.stringify({ ch, payload, origin })}
+
+`);
+        });
+        const hb = setInterval(() => {
+          if (!stillAuthed()) {
+            res.end();
+            return;
+          }
+          res.write(": hb\n\n");
+        }, 25e3);
+        res.on("close", () => {
+          unsub();
+          clearInterval(hb);
+        });
+        return;
+      }
+      json(res, 404, { detail: "not found" });
+      return;
+    }
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      json(res, 405, { detail: "method not allowed" });
+      return;
+    }
+    await serveStatic(res, path);
+  };
+  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" });
+    });
+  });
+  server.requestTimeout = 60 * 60 * 1e3;
+  return new Promise((resolve8, reject) => {
+    if (deps.routeUpgrade) server.on("upgrade", (req, socket, head) => {
+      if (!deps.routeUpgrade(req, socket, head)) socket.destroy();
+    });
+    const sockets = /* @__PURE__ */ new Set();
+    server.on("connection", (socket) => {
+      sockets.add(socket);
+      socket.once("close", () => sockets.delete(socket));
+    });
+    server.once("error", reject);
+    server.listen(opts.port, opts.bindHost ?? "0.0.0.0", () => {
+      const { port } = server.address();
+      resolve8({
+        port,
+        internalSecret,
+        p2pSecret,
+        proxyCallerKey,
+        close: () => new Promise((r) => {
+          server.close(() => r());
+          for (const socket of sockets) socket.destroy();
+        })
+      });
+    });
+  });
+}
+
+// desktop/products/basic.json
+var basic_default = {
+  id: "basic",
+  displayName: "Forsion Basic",
+  appId: "com.forsion.basic",
+  productName: "Forsion Basic",
+  artifactPrefix: "ForsionBasic",
+  defaultSpace: "home",
+  spaces: ["home"],
+  agentBackend: false,
+  market: true,
+  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/backendRunner.ts
+import http2 from "node:http";
+import { isAbsolute as isAbsolute2 } from "node:path";
+import { MessageChannel, Worker } from "node:worker_threads";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// unit/portDuplex.ts
+import { Duplex } from "node:stream";
+var PortDuplex = class extends Duplex {
+  constructor(port, metadata = {}, options = {}) {
+    super({ allowHalfOpen: true, ...options });
+    this.port = port;
+    Object.assign(this, metadata);
+    this.on("error", () => {
+    });
+    port.on("message", (packet) => {
+      if (this.destroyed) return;
+      this.touch();
+      if (packet.type === "data") {
+        if (this.push(Buffer.from(packet.bytes))) this.send({ type: "ack" });
+        else this.awaitingRead = true;
+      } else if (packet.type === "ack") {
+        const callback = this.pendingWrite;
+        this.pendingWrite = void 0;
+        callback?.();
+      } else if (packet.type === "end") {
+        this.receivedEnd = true;
+        this.push(null);
+      } else if (packet.type === "close") {
+        this.destroy();
+      }
+    });
+    port.on("messageerror", () => this.destroy(new Error("Invalid backend connection message")));
+    port.on("close", () => {
+      if (!this.destroyed) this.destroy(this.receivedEnd ? void 0 : new Error("Backend connection closed"));
+    });
+  }
+  connecting = false;
+  pending = false;
+  remoteAddress;
+  remotePort;
+  remoteFamily;
+  localAddress;
+  localPort;
+  encrypted;
+  pendingWrite;
+  awaitingRead = false;
+  receivedEnd = false;
+  timeoutMs = 0;
+  timeoutTimer;
+  send(packet) {
+    try {
+      this.port.postMessage(packet);
+    } catch {
+      this.destroy(new Error("Backend connection unavailable"));
+    }
+  }
+  touch() {
+    if (!this.timeoutMs) return;
+    if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
+    this.timeoutTimer = setTimeout(() => this.emit("timeout"), this.timeoutMs);
+    this.timeoutTimer.unref();
+  }
+  _read() {
+    if (this.awaitingRead) {
+      this.awaitingRead = false;
+      this.send({ type: "ack" });
+    }
+  }
+  _write(chunk, encoding, callback) {
+    this.touch();
+    this.pendingWrite = callback;
+    this.send({ type: "data", bytes: typeof chunk === "string" ? Buffer.from(chunk, encoding) : chunk });
+  }
+  _final(callback) {
+    this.send({ type: "end" });
+    callback();
+  }
+  _destroy(error, callback) {
+    if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
+    const pending = this.pendingWrite;
+    this.pendingWrite = void 0;
+    pending?.(error ?? new Error("Backend connection closed"));
+    try {
+      this.port.postMessage({ type: "close" });
+    } catch {
+    }
+    this.port.close();
+    callback(error);
+  }
+  setTimeout(milliseconds, callback) {
+    if (callback) this.once("timeout", callback);
+    this.timeoutMs = milliseconds;
+    if (this.timeoutTimer) clearTimeout(this.timeoutTimer);
+    this.timeoutTimer = void 0;
+    this.touch();
+    return this;
+  }
+  setNoDelay() {
+    return this;
+  }
+  setKeepAlive() {
+    return this;
+  }
+  ref() {
+    this.port.ref();
+    return this;
+  }
+  unref() {
+    this.port.unref();
+    this.timeoutTimer?.unref();
+    return this;
+  }
+  address() {
+    return { address: this.localAddress ?? "", family: this.remoteFamily ?? "IPv4", port: this.localPort ?? 0 };
+  }
+};
+
+// unit/backendRunner.ts
+function environment(overrides) {
+  const env = { ...process.env };
+  for (const [key, value] of Object.entries(overrides ?? {})) {
+    if (value === void 0) delete env[key];
+    else env[key] = value;
+  }
+  return env;
+}
+function socketMetadata(socket) {
+  return {
+    remoteAddress: socket.remoteAddress,
+    remotePort: socket.remotePort,
+    remoteFamily: socket.remoteFamily,
+    localAddress: socket.localAddress,
+    localPort: socket.localPort,
+    encrypted: Boolean(socket.encrypted)
+  };
+}
+function unavailable(response) {
+  if (response.destroyed || response.writableEnded) return;
+  if (response.headersSent) {
+    response.destroy();
+    return;
+  }
+  response.writeHead(503, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+  response.end(JSON.stringify({ detail: "Backend plugin unavailable", code: "BACKEND_UNAVAILABLE" }));
+}
+var BackendSession = class {
+  constructor(options, mode) {
+    this.options = options;
+    this.mode = mode;
+    for (const path of [options.entry, options.packageDir, options.dataDir, options.workerFile]) {
+      if (!isAbsolute2(path)) throw new Error("Backend runtime paths must be absolute");
+    }
+    if (options.signal?.aborted) throw this.abortReason();
+    if (options.accountTimeoutMs !== void 0 && (!Number.isFinite(options.accountTimeoutMs) || options.accountTimeoutMs <= 0)) {
+      throw new Error("Backend account timeout must be positive and finite");
+    }
+    this.state = mode === "start" ? "starting" : "migrating";
+    this.completion = new Promise((resolve8, reject) => {
+      this.resolveCompletion = resolve8;
+      this.rejectCompletion = reject;
+    });
+    const data = {
+      id: options.id,
+      entry: options.entry,
+      packageDir: options.packageDir,
+      dataDir: options.dataDir,
+      config: options.config ?? {},
+      mode
+    };
+    this.worker = new Worker(options.workerFile, { workerData: data, env: environment(options.env), execArgv: [] });
+    this.worker.on("message", (event) => this.onMessage(event));
+    this.worker.on("error", (error) => this.fail(error));
+    this.worker.on("exit", (code) => {
+      if (this.cancellationError) this.finishCancellation();
+      else if (!this.expectedExit) this.fail(new Error(`Backend worker exited unexpectedly (${code})`));
+    });
+    this.startTimer = setTimeout(() => this.cancel(new Error(`Backend ${mode} timed out`)), options.startTimeoutMs ?? 3e4);
+    this.startTimer.unref();
+    if (options.signal) {
+      this.abortHandler = () => this.cancel(this.abortReason());
+      options.signal.addEventListener("abort", this.abortHandler, { once: true });
+      if (options.signal.aborted) this.abortHandler();
+    }
+  }
+  state;
+  mounts = [];
+  hasAccount = false;
+  accountMetadata;
+  worker;
+  completion;
+  resolveCompletion;
+  rejectCompletion;
+  completed = false;
+  failureReported = false;
+  expectedExit = false;
+  startTimer;
+  stopPromise;
+  resolveStop;
+  rejectStop;
+  stopTimer;
+  abortHandler;
+  cancellationError;
+  cancellationFinish;
+  active = /* @__PURE__ */ new Set();
+  accountCalls = /* @__PURE__ */ new Map();
+  abortReason() {
+    const reason = this.options.signal?.reason;
+    return reason instanceof Error ? reason : new Error("Backend operation cancelled", { cause: reason });
+  }
+  detachAbort() {
+    if (this.abortHandler) this.options.signal?.removeEventListener("abort", this.abortHandler);
+    this.abortHandler = void 0;
+  }
+  /** A startup deadline must abort plugin-owned jobs before their worker disappears. */
+  cancel(error) {
+    if (this.completed || this.cancellationError || this.state === "stopped" || this.state === "failed") return;
+    this.cancellationError = error;
+    this.state = "stopping";
+    if (this.startTimer) clearTimeout(this.startTimer);
+    this.detachAbort();
+    this.closeConnections();
+    this.stopTimer = setTimeout(() => this.finishCancellation(), this.options.stopTimeoutMs ?? 1e4);
+    this.stopTimer.unref();
+    try {
+      this.worker.postMessage({ type: "stop" });
+    } catch {
+      this.finishCancellation();
+    }
+  }
+  finishCancellation() {
+    if (!this.cancellationError || this.cancellationFinish) return;
+    this.expectedExit = true;
+    if (this.stopTimer) clearTimeout(this.stopTimer);
+    this.cancellationFinish = this.worker.terminate().then(() => {
+    }, () => {
+    }).then(() => {
+      this.settleFailure(this.cancellationError);
+    });
+  }
+  callback(callback) {
+    try {
+      Promise.resolve(callback?.()).catch((error) => this.fail(error));
+    } catch (error) {
+      this.fail(error);
+    }
+  }
+  onMessage(raw) {
+    if (!raw || typeof raw !== "object" || !("type" in raw)) {
+      this.fail(new Error("Invalid backend worker event"));
+      return;
+    }
+    const event = raw;
+    if (this.cancellationError) {
+      if (event.type === "stopped" || event.type === "failure" || event.type === "migrated") this.finishCancellation();
+      return;
+    }
+    if (event.type === "failure") {
+      const error = new Error(typeof event.message === "string" ? event.message : "Backend worker failed");
+      if (typeof event.stack === "string") error.stack = event.stack;
+      this.fail(error);
+    } else if (event.type === "ready" && this.state === "starting") {
+      if (!Array.isArray(event.mounts) || event.mounts.some((mount) => typeof mount !== "string")) {
+        this.fail(new Error("Invalid backend mount registration"));
+        return;
+      }
+      this.mounts = Object.freeze([...event.mounts]);
+      this.hasAccount = event.hasAccount === true;
+      this.accountMetadata = event.accountMetadata && Object.freeze({ ...event.accountMetadata });
+      this.state = "running";
+      this.finish();
+    } else if (event.type === "migrated" && this.state === "migrating") {
+      this.expectedExit = true;
+      void this.worker.terminate().then(() => {
+        if (this.cancellationError) {
+          this.finishCancellation();
+          return;
+        }
+        this.state = "stopped";
+        this.finish();
+      }, (error) => this.fail(error));
+    } else if (event.type === "stopped" && this.state === "stopping") {
+      this.expectedExit = true;
+      void this.worker.terminate().then(() => {
+        if (this.stopTimer) clearTimeout(this.stopTimer);
+        this.closeConnections();
+        this.state = "stopped";
+        this.resolveStop?.();
+      }, (error) => this.fail(error));
+    } else if (event.type === "account-result") {
+      this.accountCalls.get(event.requestId)?.finish(event.identity);
+    } else if (event.type === "account-error") {
+      this.accountCalls.get(event.requestId)?.finish(null, new Error("Account provider unavailable"));
+    } else if (event.type === "restart" && this.state === "running") {
+      this.callback(this.options.onRestart);
+    } else if (event.type === "log" && typeof event.message === "string") {
+      try {
+        this.options.onLog?.(event.message);
+      } catch {
+      }
+    }
+  }
+  finish() {
+    if (this.startTimer) clearTimeout(this.startTimer);
+    this.detachAbort();
+    if (this.completed) return;
+    this.completed = true;
+    this.resolveCompletion();
+  }
+  fail(cause) {
+    if (this.state === "stopped") return;
+    if (this.cancellationError) {
+      this.finishCancellation();
+      return;
+    }
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    this.expectedExit = true;
+    this.settleFailure(error);
+    void this.worker.terminate().catch(() => {
+    });
+  }
+  settleFailure(error) {
+    this.state = "failed";
+    this.detachAbort();
+    if (this.startTimer) clearTimeout(this.startTimer);
+    if (this.stopTimer) clearTimeout(this.stopTimer);
+    this.closeConnections();
+    if (!this.completed) {
+      this.completed = true;
+      this.rejectCompletion(error);
+    }
+    this.rejectStop?.(error);
+    if (!this.failureReported) {
+      this.failureReported = true;
+      try {
+        this.options.onFailure?.(error);
+      } catch {
+      }
+    }
+  }
+  closeConnections() {
+    for (const socket of this.active) socket.destroy(new Error("Backend plugin unavailable"));
+    this.active.clear();
+    for (const call of this.accountCalls.values()) call.finish(null, new Error("Account provider unavailable"));
+  }
+  resolveAccount = async (token, options = {}) => {
+    if (this.state !== "running" || !this.hasAccount) throw new Error("Account provider unavailable");
+    if (typeof token !== "string" || !token || token.length > 16384) return null;
+    if (options.signal?.aborted) throw new Error("Account resolution cancelled");
+    if (this.accountCalls.size >= 256) throw new Error("Account provider busy");
+    const requestId = randomUUID2();
+    return new Promise((resolve8, reject) => {
+      let timer;
+      const finish = (identity, error) => {
+        if (!this.accountCalls.delete(requestId)) return;
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", cancel);
+        if (error) reject(error);
+        else resolve8(identity);
+      };
+      const abort = (message) => {
+        finish(null, new Error(message));
+        try {
+          this.worker.postMessage({ type: "account-cancel", requestId });
+        } catch {
+        }
+      };
+      const cancel = () => abort("Account resolution cancelled");
+      this.accountCalls.set(requestId, { finish });
+      timer = setTimeout(() => abort("Account resolution timed out"), Math.min(this.options.accountTimeoutMs ?? 5e3, 3e4));
+      timer.unref();
+      options.signal?.addEventListener("abort", cancel, { once: true });
+      if (options.signal?.aborted) {
+        cancel();
+        return;
+      }
+      try {
+        this.worker.postMessage({ type: "account-resolve", requestId, token });
+      } catch {
+        finish(null, new Error("Account provider unavailable"));
+      }
+    });
+  };
+  connection(metadata) {
+    const { port1, port2 } = new MessageChannel();
+    const stream = new PortDuplex(port1);
+    this.active.add(stream);
+    stream.once("close", () => this.active.delete(stream));
+    try {
+      this.worker.postMessage({ type: "connection", port: port2, socket: metadata }, [port2]);
+    } catch (error) {
+      port2.close();
+      stream.destroy();
+      throw error;
+    }
+    return stream;
+  }
+  handle = (request, response) => {
+    if (this.state !== "running") {
+      unavailable(response);
+      return;
+    }
+    let connection;
+    try {
+      connection = this.connection(socketMetadata(request.socket));
+    } catch {
+      unavailable(response);
+      return;
+    }
+    const agent = new http2.Agent({ keepAlive: false });
+    agent.createConnection = () => connection;
+    const upstream = http2.request({
+      hostname: "unit-backend.invalid",
+      port: 80,
+      path: request.url,
+      method: request.method,
+      headers: { ...request.headers, connection: "close" },
+      agent
+    });
+    const cancel = () => {
+      upstream.destroy();
+      connection.destroy();
+      agent.destroy();
+    };
+    request.once("aborted", cancel);
+    request.once("error", cancel);
+    request.once("end", () => {
+      if (Object.keys(request.trailers).length) upstream.addTrailers(request.trailers);
+    });
+    response.once("close", cancel);
+    upstream.once("error", () => {
+      unavailable(response);
+      agent.destroy();
+    });
+    upstream.once("response", (incoming) => {
+      if (response.destroyed) {
+        incoming.destroy();
+        return;
+      }
+      const headers = { ...incoming.headers };
+      delete headers.connection;
+      delete headers["keep-alive"];
+      response.writeHead(incoming.statusCode ?? 502, incoming.statusMessage, headers);
+      incoming.once("aborted", () => response.destroy());
+      incoming.once("error", () => response.destroy());
+      incoming.once("end", () => {
+        if (Object.keys(incoming.trailers).length) response.addTrailers(incoming.trailers);
+      });
+      incoming.pipe(response);
+    });
+    request.pipe(upstream);
+  };
+  upgrade = (request, socket, head) => {
+    if (this.state !== "running") {
+      socket.end("HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
+      return;
+    }
+    let connection;
+    try {
+      connection = this.connection(socketMetadata(request.socket));
+    } catch {
+      socket.destroy();
+      return;
+    }
+    const close = () => {
+      connection.destroy();
+      socket.destroy();
+    };
+    socket.once("error", close);
+    socket.once("close", () => connection.destroy());
+    connection.once("error", close);
+    connection.once("close", () => socket.destroy());
+    const lines = [`${request.method ?? "GET"} ${request.url ?? "/"} HTTP/${request.httpVersion}`];
+    for (let i = 0; i < request.rawHeaders.length; i += 2) lines.push(`${request.rawHeaders[i]}: ${request.rawHeaders[i + 1]}`);
+    connection.write(lines.join("\r\n") + "\r\n\r\n");
+    if (head.length) connection.write(head);
+    socket.pipe(connection).pipe(socket);
+  };
+  stop = () => {
+    if (this.stopPromise) return this.stopPromise;
+    if (this.state === "stopped") return Promise.resolve();
+    if (this.state === "failed") return this.worker.terminate().then(() => {
+    });
+    this.state = "stopping";
+    this.closeConnections();
+    this.stopPromise = new Promise((resolve8, reject) => {
+      this.resolveStop = resolve8;
+      this.rejectStop = reject;
+    });
+    this.stopTimer = setTimeout(() => this.fail(new Error("Backend stop timed out")), this.options.stopTimeoutMs ?? 1e4);
+    this.stopTimer.unref();
+    this.worker.postMessage({ type: "stop" });
+    return this.stopPromise;
+  };
+};
+async function startBackend(options) {
+  const session = new BackendSession(options, "start");
+  await session.completion;
+  return {
+    get mounts() {
+      return session.mounts;
+    },
+    get state() {
+      return session.state;
+    },
+    account: session.hasAccount ? { metadata: session.accountMetadata, resolve: session.resolveAccount } : void 0,
+    handle: session.handle,
+    upgrade: session.upgrade,
+    stop: session.stop
+  };
+}
+async function migrateBackend(options) {
+  await new BackendSession(options, "migrate").completion;
+}
+
+// unit/accountHttp.ts
+import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+import { mkdir, readFile as readFile3, rename, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+
+// desktop/shared/unitPreferences.ts
+var UNIT_PREFERENCE_KEYS = [
+  "modelId",
+  "asrModelId",
+  "visionModelId",
+  "visionMode",
+  "backgroundModelId",
+  "agentDeskEnabled",
+  "summaryOpenIn",
+  "ttsModelId",
+  "ttsVoice",
+  "ttsSpeed",
+  "ttsAutoSpeak",
+  "asrBackend",
+  "lastApprovalMode",
+  "lastThinkingLevel",
+  "lastChatThinkingLevel",
+  "notesAttachmentMode",
+  "notesAttachmentFolder",
+  "notesImportPreview",
+  "notesDailyFolder",
+  "notesWikiIncludeFiles",
+  "notesUpgradeV4"
+];
+function pickUnitPreferences(input) {
+  return Object.fromEntries(UNIT_PREFERENCE_KEYS.filter((key) => Object.hasOwn(input, key)).map((key) => [key, input[key]]));
+}
+
+// unit/accountHttp.ts
+var digest = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+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) => {
+    res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(body));
+  };
+  async function read(path) {
+    try {
+      return JSON.parse(await readFile3(path, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+  async function write(path, update, guard) {
+    const job = (writes.get(path) || Promise.resolve()).catch(() => {
+    }).then(async () => {
+      await guard();
+      const value = update(await read(path)), temporary = path + "." + randomUUID3();
+      try {
+        await writeFile(temporary, JSON.stringify(value), { mode: 384 });
+        await guard();
+        await rename(temporary, path);
+      } finally {
+        await rm(temporary, { force: true });
+      }
+      return value;
+    });
+    writes.set(path, job);
+    try {
+      return await job;
+    } finally {
+      if (writes.get(path) === job) writes.delete(path);
+    }
+  }
+  return async (path, req, res) => {
+    if (path !== "/unit/account" && path !== "/unit/config" && !path.startsWith("/unit/plugin-data/")) return false;
+    const provider = options.provider();
+    if (!provider) return false;
+    const controller = new AbortController();
+    const onClose = () => {
+      if (!res.writableEnded) controller.abort();
+    };
+    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;
+      if (!identity) {
+        json(res, 401, { error: "Authentication required" });
+        return true;
+      }
+      if (options.provider()?.account !== provider.account) {
+        json(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" });
+        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" });
+        return true;
+      }
+      if (req.method !== "GET" && req.method !== "PUT") {
+        json(res, 405, { error: "Method not allowed" });
+        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 });
+        return true;
+      }
+      let size = 0;
+      const chunks = [];
+      for await (const chunk of req) {
+        size += Buffer.byteLength(chunk);
+        if (size > 1024 * 1024) {
+          json(res, 413, { error: "Data exceeds 1 MB" });
+          return true;
+        }
+        chunks.push(Buffer.from(chunk));
+      }
+      let input;
+      try {
+        input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      } catch {
+        json(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" });
+        return true;
+      }
+      const guard = async () => {
+        controller.signal.throwIfAborted();
+        const current = await provider.account.resolve(bearer, { signal: controller.signal });
+        if (!current || digest(current) !== digest(identity) || options.provider()?.account !== provider.account) {
+          throw new AccountChanged("Account changed");
+        }
+      };
+      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 });
+      return true;
+    } catch (error) {
+      if (!res.headersSent && !res.destroyed) json(
+        res,
+        error instanceof AccountChanged ? 401 : 503,
+        { error: error instanceof AccountChanged ? "Account changed" : "Account service unavailable" }
+      );
+      return true;
+    } finally {
+      res.off("close", onClose);
+    }
+  };
+}
+
+// unit/localWorkspace.ts
+import { randomBytes as randomBytes2, createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
+import { readFile as readFile4, writeFile as writeFile2, rename as rename2, mkdir as mkdir2, realpath as realpath3, readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { resolve as resolve2, sep as sep3, extname as extname2 } from "node:path";
+async function localOwnerToken(dataDir) {
+  await mkdir2(dataDir, { recursive: true, mode: 448 });
+  const path = resolve2(dataDir, "owner-token");
+  try {
+    await writeFile2(path, randomBytes2(32).toString("hex"), { mode: 384, flag: "wx" });
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const token = (await readFile4(path, "utf8")).trim();
+  if (!/^[a-f0-9]{64}$/.test(token)) throw new Error("Invalid local workspace owner token");
+  return token;
+}
+async function createLocalWorkspace(dataDir, workspaceDir, vaultRoot) {
+  await mkdir2(workspaceDir, { recursive: true, mode: 448 });
+  const token = await localOwnerToken(dataDir);
+  const device = { id: "local-owner", name: "Workspace owner", tokenHash: createHash3("sha256").update(token).digest("hex"), createdAt: 0 };
+  const file2 = resolve2(dataDir, "preferences.json");
+  const read = async () => {
+    try {
+      return pickUnitPreferences(JSON.parse(await readFile4(file2, "utf8")));
+    } catch (error) {
+      if (error.code === "ENOENT") return {};
+      throw error;
+    }
+  };
+  let writes = Promise.resolve();
+  const scoped = async (path) => {
+    try {
+      const actual = await realpath3(path);
+      for (const root of [workspaceDir, vaultRoot()].filter(Boolean)) {
+        const realRoot = await realpath3(root);
+        if (actual === realRoot || actual.startsWith(realRoot + sep3)) return actual;
+      }
+    } 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/host.ts
+var matches = (path, prefix) => prefix === "/" || path === prefix || path.startsWith(prefix + "/");
+var pathname = (url) => (url || "/").split("?")[0];
+async function startBasicUnit(config) {
+  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 });
+  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 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);
+  for (const entry of config.plugins) {
+    const installation = typeof entry === "string" ? { path: entry } : { ...entry };
+    const pack = await readPackage(installation.path, config.version);
+    if (records.has(pack.manifest.id)) throw new Error("Duplicate plugin id");
+    records.set(pack.manifest.id, { package: pack, installation, state: "disabled", mounts: [] });
+  }
+  const ordered = [], spaceOwners = /* @__PURE__ */ new Set();
+  const mustGet = (id) => {
+    const r = records.get(id);
+    if (!r) throw new Error(`Plugin is not installed: ${id}`);
+    return r;
+  };
+  const dependencyOrder = (replacement) => {
+    const order = [], visiting = /* @__PURE__ */ new Set();
+    const visit = (id) => {
+      if (order.includes(id)) return;
+      if (visiting.has(id)) throw new Error("Cyclic plugin dependency");
+      visiting.add(id);
+      const pack = replacement?.id === id ? replacement.package : mustGet(id).package;
+      for (const dep of pack.manifest.requires || []) visit(dep);
+      visiting.delete(id);
+      order.push(id);
+    };
+    for (const id of records.keys()) visit(id);
+    return order;
+  };
+  ordered.push(...dependencyOrder());
+  for (const record of records.values()) for (const id of record.package.spaceIds) {
+    if (spaceOwners.has(id)) throw new Error("Duplicate Space id");
+    spaceOwners.add(id);
+  }
+  if (config.defaultSpace && !spaceOwners.has(config.defaultSpace)) throw new Error("The default Space must be supplied by an installed plugin");
+  const validateFeatures = (replacement) => {
+    const packs = [...records.entries()].map(([id, rec]) => replacement?.id === id ? replacement.package : rec.package);
+    const features = new Set(packs.flatMap((p) => p.manifest.frontend?.features || []));
+    if (features.has("calendar") && !features.has("amadeus")) throw new Error("Calendar requires the Amadeus frontend");
+    if (features.has("automation") && !features.has("tangu")) throw new Error("Automation requires the Tangu frontend");
+    for (const pack of packs) {
+      const owns = pack.manifest.frontend?.features || [];
+      for (const [feature, dependency] of [["calendar", "amadeus"], ["automation", "tangu"]]) {
+        if (!owns.includes(feature) || owns.includes(dependency)) continue;
+        const owner = packs.find((p) => p.manifest.frontend?.features.includes(dependency));
+        if (!pack.manifest.requires?.includes(owner.manifest.id)) throw new Error(`${feature} must require the ${dependency} package`);
+      }
+    }
+  };
+  validateFeatures();
+  const usable = (rec) => rec.state === "active" && (rec.package.manifest.requires || []).every((id) => usable(mustGet(id)));
+  const visible = (rec) => usable(rec) && rec.installation.publish !== false && (rec.package.manifest.requires || []).every((id) => !mustGet(id).package.manifest.frontend || visible(mustGet(id)));
+  const published = () => [...records.values()].filter(visible);
+  const product = resolveProduct(void 0, { ...basic_default, market: false, onboarding: false, nativeFeatures: [] });
+  const capabilities = () => {
+    const services = {};
+    if (local) return services;
+    for (const rec of published()) Object.assign(services, rec.package.manifest.frontend?.services);
+    const account = [...records.values()].find((r) => usable(r) && r.backend?.account)?.backend?.account;
+    if (!account?.metadata) return {};
+    for (const [id, service] of Object.entries(services)) {
+      const base = account.metadata.apiBase.replace(/\/$/, "");
+      if (service.apiBase !== base && !service.apiBase.startsWith(base + "/")) delete services[id];
+    }
+    return services;
+  };
+  const refreshProduct = () => {
+    const visible2 = published();
+    const spaces = visible2.flatMap((r) => [...r.package.spaceIds]);
+    product.nativeFeatures = visible2.flatMap((r) => r.package.manifest.frontend?.features || []);
+    product.agentBackend = product.nativeFeatures.includes("tangu");
+    product.spaces = spaces.length ? [] : ["home"];
+    product.defaultSpace = spaces.includes(config.defaultSpace || "") ? config.defaultSpace : spaces[0] || "home";
+  };
+  let chain = Promise.resolve(), closing = false, started = false;
+  const syncRuntimes = async () => {
+    const roots = [...records.values()].filter(usable).map((r) => r.package.root);
+    for (const rec of records.values()) if (usable(rec)) await rec.runtime?.setPackages?.(roots, [...records.values()].map((r) => r.package.root));
+  };
+  const serialize = (action2) => {
+    const job = chain.then(action2);
+    chain = job.then(() => {
+    }, () => {
+    });
+    return job;
+  };
+  const bindAddress = config.bindHost === "::" ? "::1" : config.bindHost === "0.0.0.0" || !config.bindHost ? "127.0.0.1" : config.bindHost;
+  const localHost = bindAddress.includes(":") ? `[${bindAddress}]` : bindAddress;
+  const options = (id, rec) => ({
+    id,
+    entry: rec.package.backendEntry,
+    packageDir: rec.package.root,
+    dataDir: resolve3(dataDir, "plugins", id),
+    config: rec.installation.config || {},
+    env: {
+      ...rec.installation.config?.env || {},
+      ...rec.installation.env,
+      PORT: String(web.port),
+      UNIT_HTTP_ORIGIN: `http://${localHost}:${web.port}`
+    },
+    workerFile,
+    startTimeoutMs: 12e4,
+    onLog: (message) => console.log(`[plugin:${id}] ${message}`),
+    onRestart: () => {
+      if (!closing) void serialize(() => restart(id)).catch(() => console.error(`[unit] Plugin ${id} restart failed`));
+    },
+    onFailure: (error) => {
+      console.error(`[unit] Plugin ${id}: ${error.message}`);
+      rec.state = "failed";
+      rec.backend = void 0;
+      refreshProduct();
+    }
+  });
+  async function activate(id) {
+    if (closing) throw new Error("Unit is stopping");
+    const rec = mustGet(id);
+    if (rec.state === "active") return;
+    for (const dep of rec.package.manifest.requires || []) if (mustGet(dep).state !== "active") throw new Error(`Plugin dependency is not active: ${dep}`);
+    rec.state = "starting";
+    let backend, runtime;
+    try {
+      if (local && rec.package.runtimeEntry) {
+        const module = await import(pathToFileURL(rec.package.runtimeEntry).href + "?generation=" + randomUUID5());
+        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}`) });
+        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 });
+        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");
+        }
+        if (rec.state === "failed") throw new Error("Plugin stopped during startup");
+        const mounts = backend.mounts.map((p) => p === "/" ? p : p.replace(/\/$/, ""));
+        for (const mount of mounts) {
+          if (!/^\/(?:[A-Za-z0-9._~-]+\/?)*$/.test(mount) || mount.split("/").includes("..") || mount === prefix || protectedPaths.some((p) => matches(mount, p))) throw new Error("Plugin claims an invalid or reserved route");
+          if ([...records.values()].some((r) => r !== rec && r.state === "active" && r.mounts.includes(mount))) throw new Error("Plugin route conflict");
+        }
+        rec.mounts = [...new Set(mounts)];
+      }
+      rec.backend = backend;
+      rec.runtime = runtime;
+      rec.state = "active";
+      rec.installation.enabled = true;
+      if (started) await syncRuntimes();
+    } catch (error) {
+      rec.state = "failed";
+      rec.backend = void 0;
+      rec.runtime = void 0;
+      try {
+        if (typeof runtime?.close === "function") await runtime.close();
+      } finally {
+        await backend?.stop();
+      }
+      throw error;
+    } finally {
+      refreshProduct();
+    }
+  }
+  async function deactivate(id, force = false, preserveIntent = false) {
+    const rec = mustGet(id);
+    if (!force && [...records.values()].some((r) => r.state === "active" && r.package.manifest.requires?.includes(id))) throw new Error("Disable dependent plugins first");
+    const backend = rec.backend, runtime = rec.runtime;
+    rec.backend = void 0;
+    rec.runtime = void 0;
+    rec.state = "stopping";
+    refreshProduct();
+    try {
+      try {
+        await runtime?.close();
+      } finally {
+        await backend?.stop();
+      }
+    } finally {
+      rec.state = "disabled";
+      if (!preserveIntent) rec.installation.enabled = false;
+      refreshProduct();
+      if (started && !closing) await syncRuntimes();
+    }
+  }
+  const activeTree = (id) => {
+    const affected = /* @__PURE__ */ new Set([id]);
+    for (const candidate of ordered) if (mustGet(candidate).package.manifest.requires?.some((dep) => affected.has(dep))) affected.add(candidate);
+    return ordered.filter((candidate) => affected.has(candidate) && (mustGet(candidate).state === "active" || mustGet(candidate).installation.enabled !== false));
+  };
+  async function restart(id) {
+    mustGet(id);
+    const active = activeTree(id);
+    for (const candidate of [...active].reverse()) await deactivate(candidate, false, true);
+    for (const candidate of ordered.filter((candidate2) => candidate2 === id || active.includes(candidate2))) await activate(candidate);
+  }
+  const select = (path) => {
+    if (protectedPaths.some((p) => matches(path, p))) return void 0;
+    const candidates = [...records.values()].filter((r) => usable(r) && r.backend).flatMap((r) => r.mounts.filter((m) => matches(path, m)).map((m) => ({ rec: r, length: m.length }))).sort((a, b) => b.length - a.length);
+    const winner = candidates[0];
+    return winner && (!matches(path, prefix) || winner.length > prefix.length) ? winner.rec.backend : void 0;
+  };
+  refreshProduct();
+  const accountProvider = () => {
+    const record = [...records.entries()].find(([, r]) => usable(r) && r.backend?.account);
+    return record ? { id: record[0], account: record[1].backend.account } : void 0;
+  };
+  const accountHttp = createAccountHttp({
+    dataDir,
+    provider: accountProvider,
+    pluginActive: (id) => {
+      const rec = records.get(id);
+      return !!rec && usable(rec);
+    }
+  });
+  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) => {
+      const path = pathname(req.url), backend = select(path);
+      if (backend) {
+        backend.handle(req, res);
+        return true;
+      }
+      if ([...records.values()].some((r) => r.package.backendEntry) && !matches(path, prefix)) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end('{"detail":"No active plugin route"}');
+        return true;
+      }
+      return false;
+    },
+    routeUpgrade: (req, socket, head) => {
+      const backend = select(pathname(req.url));
+      if (!backend?.upgrade) return false;
+      backend.upgrade(req, socket, head);
+      return true;
+    },
+    getEngine: () => runtimeEngine()?.endpoint() || { url: null, token: "" },
+    pairedDevices: { list: () => localWorkspace ? [localWorkspace.device] : [], add: async () => {
+      throw new Error("Pairing is disabled");
+    } },
+    confirmPair: async () => false,
+    readPlugins: async () => published().flatMap((r) => r.package.ui ? [r.package.ui] : []),
+    readSpaces: async () => published().flatMap((r) => r.package.spaces),
+    readConfig: localWorkspace?.readConfig || (async () => ({})),
+    writeConfig: localWorkspace?.writeConfig || (async () => {
+      throw new Error("Host configuration is not published");
+    }),
+    readProviders: async () => {
+      const rec = [...records.values()].find((r) => usable(r) && r.runtime?.readProviders);
+      return await rec?.runtime?.readProviders?.() || [];
+    },
+    readHostFile: localWorkspace?.readHostFile || (async () => null),
+    readHostDir: localWorkspace?.readHostDir || (async () => null),
+    readHostStat: localWorkspace?.readHostStat || (async () => null),
+    webDistDir: () => config.webDist,
+    vault: runtimeVault,
+    log: (message) => console.log(message)
+  }, { port: config.port, bindHost: config.bindHost ?? "127.0.0.1" });
+  for (const id of ordered) if (mustGet(id).installation.enabled !== false) {
+    try {
+      await activate(id);
+    } catch {
+      console.error(`[unit] Plugin ${id} failed to activate; Unit remains available`);
+    }
+  }
+  started = true;
+  try {
+    await syncRuntimes();
+  } catch (error) {
+    await web.close();
+    await Promise.allSettled([...records.values()].map(async (rec) => {
+      try {
+        await rec.runtime?.close();
+      } finally {
+        await rec.backend?.stop();
+      }
+    }));
+    throw error;
+  }
+  return {
+    ...web,
+    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)),
+    restart: (id) => serialize(() => restart(id)),
+    update: (id, path) => serialize(async () => {
+      const rec = mustGet(id), next = await readPackage(path, config.version);
+      if (next.manifest.id !== id) throw new Error("Update changes plugin identity");
+      for (const dep of next.manifest.requires || []) if (mustGet(dep).state !== "active") throw new Error("New dependency is not active");
+      for (const other of records.values()) if (other !== rec) {
+        for (const space of next.spaceIds) if (other.package.spaceIds.has(space)) throw new Error("Duplicate Space id");
+      }
+      const nextOrder = dependencyOrder({ id, package: next });
+      validateFeatures({ id, package: next });
+      if (config.defaultSpace && rec.package.spaceIds.has(config.defaultSpace) && !next.spaceIds.has(config.defaultSpace)) throw new Error("Update removes the Unit default Space");
+      const previous = rec.package, active = activeTree(id);
+      for (const candidate of [...active].reverse()) await deactivate(candidate, false, true);
+      rec.package = next;
+      try {
+        for (const candidate of nextOrder.filter((candidate2) => active.includes(candidate2))) await activate(candidate);
+        rec.installation.path = next.root;
+        ordered.splice(0, ordered.length, ...nextOrder);
+      } catch (error) {
+        for (const candidate of [...nextOrder].reverse().filter((candidate2) => active.includes(candidate2))) await deactivate(candidate, true, true);
+        rec.package = previous;
+        for (const candidate of active) await activate(candidate);
+        throw error;
+      } finally {
+        refreshProduct();
+      }
+    }),
+    migrate: (id) => serialize(async () => {
+      const rec = mustGet(id);
+      if (rec.state === "active") throw new Error("Disable the plugin before migrating");
+      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);
+        }
+      }
+      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 });
+  }
+}
+
+// desktop/package.json
+var package_default = {
+  name: "forsion-desktop",
+  version: "2.12.2",
+  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,
+  type: "module",
+  main: "out/main/main.js",
+  scripts: {
+    postinstall: "node build/link-lcl.cjs && node build/copy-excalidraw-assets.cjs && node build/gen-fonts.cjs && node build/fix-pty-helper.cjs",
+    predev: "node scripts/dev-version.check.cjs",
+    dev: "electron-vite dev --noSandbox",
+    "check:visualize": "node scripts/visualize.check.cjs",
+    "check:version": "node scripts/dev-version.check.cjs",
+    build: "electron-vite build",
+    preview: "electron-vite preview",
+    web: "vite frontend",
+    gallery: "echo '\u2192 http://localhost:8100/lcl/gallery/' && python3 -m http.server 8100 --bind 127.0.0.1 --directory ..",
+    test: "npm run check:shadowcontract && vitest run",
+    "check:run-lifecycle": "node scripts/run-lifecycle.check.cjs",
+    "check:installer": "node scripts/installer-compile.check.cjs",
+    "check:backend-deps": "node scripts/backend-dependencies.check.cjs",
+    "test:sync": "vitest run electron/amadeus/ipc.move.test.ts electron/amadeus/ipc.account.test.ts electron/amadeus/settings.account.test.ts frontend/src/amadeus/store/pageStore.move-race.test.ts frontend/src/stores/entrySyncStore frontend/src/services/cloudBridgeVanished.test.ts frontend/src/components/ShareCard.race.test.ts frontend/src/amadeusFolderPublish.test.ts",
+    "test:accounts": "vitest run forsionAuth accountCore accountTransition AccountCard cloudAccount cloudHttpAccount cloudBridgeCacheAccount contentLayoutAccount settings.account ipc.account collabMain.account appStore.connect engine.lifecycle writeFailures pageStore.vaultswitch dbStore.test drawingStore.test",
+    "e2e:automation": "node scripts/automation-space.e2e.cjs",
+    "e2e:editor": "node scripts/e2e-editor.cjs",
+    "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:mindmap": "node scripts/mindmap.e2e.cjs",
+    "e2e:canvas": "node scripts/canvas.e2e.cjs",
+    "e2e:daily": "node scripts/daily-template.e2e.cjs",
+    "e2e:plugview": "node scripts/plugin-view.e2e.cjs",
+    "e2e:eventsspace": "node scripts/events-space-switch.repro.cjs",
+    "check:listsrc": "node scripts/plugin-listsrc.check.cjs",
+    "e2e:latex": "node scripts/e2e-editor.cjs --script=latex-suite.e2e.cjs",
+    "e2e:activewindow": "node scripts/active-window.e2e.cjs",
+    "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:remotesafety": "node scripts/remote-safety.e2e.cjs",
+    "e2e:chatshimmer": "node scripts/chat-shimmer.e2e.cjs",
+    "e2e:runstats": "node scripts/chat-runstats.e2e.cjs",
+    "e2e:ctxwindow": "node scripts/ctxwindow-settings.e2e.cjs",
+    "e2e:ctxlimit": "node scripts/ctxlimit-menu.e2e.cjs",
+    "e2e:livewait": "node scripts/chat-livewait.e2e.cjs",
+    "e2e:queue": "node scripts/queued-commands.e2e.cjs",
+    "e2e:musespace": "node scripts/muse-space.e2e.cjs",
+    "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: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",
+    "e2e:extend": "node scripts/extend-seam.e2e.cjs",
+    "e2e:musesettings": "node scripts/muse-settings.e2e.cjs",
+    "e2e:modelcatalog": "node scripts/model-catalog.e2e.cjs",
+    "e2e:museagentspace": "node scripts/muse-agentspace.e2e.cjs",
+    "e2e:inboxamadeus": "node scripts/inbox-amadeus.e2e.cjs",
+    "e2e:planlive": "node scripts/plan-live.e2e.cjs",
+    "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:dashdrag": "node scripts/dash3-drag.e2e.cjs",
+    "e2e:pathgone": "node scripts/vault-pathgone.e2e.cjs",
+    "check:pillbar": "node scripts/pillbar-overflow.check.cjs",
+    "check:feedback": "node scripts/feedback.check.cjs",
+    "check:floatingsession": "node scripts/floating-session.check.cjs",
+    "check:btw": "node scripts/btw.check.cjs",
+    "check:chatlayout": "node scripts/chat-layout.check.cjs",
+    "check:sessionemoji": "node scripts/session-emoji.check.cjs",
+    "check:messageactions": "node scripts/chat-message-actions.check.cjs",
+    "check:approval": "node scripts/approval-menu.check.cjs",
+    "check:addmenu": "node scripts/add-menu.check.cjs",
+    "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:bluebirdspace": "node scripts/bluebird-space.check.cjs",
+    "check:bluebirdtimestamps": "node scripts/bluebird-space.check.cjs --timestamps",
+    "check:splitregions": "node scripts/split-regions.check.cjs",
+    "check:br": "node scripts/e2e-editor.cjs --check=blank-line-br",
+    "check:computerhistory": "node scripts/e2e-editor.cjs --check=computer-history-settings",
+    "check:browserext": "node scripts/e2e-editor.cjs --check=browserext-settings",
+    "check:attention": "node scripts/e2e-editor.cjs --check=attention-save",
+    "check:rtcorpus": "node scripts/e2e-editor.cjs --check=rtcorpus",
+    "check:cjk": "node scripts/e2e-editor.cjs --check=cjk-flanking",
+    "check:linkcard": "node scripts/e2e-editor.cjs --check=linkcard",
+    "check:pastefidelity": "node scripts/e2e-editor.cjs --check=pastefidelity",
+    "check:templatefm": "node scripts/e2e-editor.cjs --check=template-fm",
+    "check:enter": "node scripts/e2e-editor.cjs --check=enter-semantics",
+    "check:caretmerge": "node scripts/e2e-editor.cjs --check=caret-merge",
+    "check:canvascaret": "node scripts/e2e-editor.cjs --check=canvas-caret",
+    "check:unifiedro": "node scripts/e2e-editor.cjs --check=unified-readonly",
+    "check:unifiedcas": "node scripts/e2e-editor.cjs --check=unifiedcas",
+    "check:spellctx": "node scripts/e2e-editor.cjs --check=unified-spellctx",
+    "check:unifiedkeys": "node scripts/e2e-editor.cjs --check=unified-keys",
+    "check:taskbox": "node scripts/e2e-editor.cjs --check=taskbox",
+    "check:table": "node scripts/e2e-editor.cjs --check=unified-table",
+    "check:unifiedsync": "node scripts/e2e-editor.cjs --check=unified-sync",
+    "check:editorai": "node scripts/e2e-editor.cjs --check=editor-ai",
+    "check:menus": "node scripts/e2e-editor.cjs --check=editor-menus",
+    "check:cloudgap": "node scripts/cloud-gap.check.cjs",
+    "check:amadeusinteractions": "node scripts/e2e-editor.cjs --check=amadeus-interactions",
+    "check:dashboard": "node scripts/e2e-editor.cjs --check=dashboard",
+    "check:embedinputs": "node scripts/e2e-editor.cjs --check=embed-inputs",
+    "check:embedkeep": "node scripts/e2e-editor.cjs --check=embed-keep",
+    "check:outlinereveal": "node scripts/e2e-editor.cjs --check=outline-reveal",
+    "check:coverrepo": "node scripts/e2e-editor.cjs --check=cover-reposition",
+    "check:pagestyle": "node scripts/e2e-editor.cjs --check=page-style",
+    "check:pagehistory": "node scripts/e2e-editor.cjs --check=page-history",
+    "check:mobilebar": "node scripts/e2e-editor.cjs --check=mobile-bar",
+    "check:editorperf": "node scripts/e2e-editor.cjs --check=editor-perf",
+    "check:codelanguage": "node scripts/e2e-editor.cjs --check=code-language",
+    "check:dbinteractions": "node scripts/e2e-editor.cjs --check=db-interactions",
+    "e2e:dbrecords": "node scripts/db-records.e2e.cjs",
+    "e2e:dbvisual": "node scripts/db-records.e2e.cjs --visual",
+    "check:colorder": "node scripts/e2e-editor.cjs --check=db-colorder",
+    "check:viewcols": "node scripts/e2e-editor.cjs --check=db-viewcols",
+    "shot:dashboard": "node scripts/e2e-editor.cjs --check=dashboard --shot",
+    "check:dashgrid": "node scripts/e2e-editor.cjs --check=dashgrid",
+    "check:dashrecipe": "node scripts/e2e-editor.cjs --check=dashrecipe",
+    "check:dashmount": "node scripts/e2e-editor.cjs --check=dashmount",
+    "check:tablemount": "node scripts/e2e-editor.cjs --check=tablemount",
+    "check:erp": "node scripts/e2e-editor.cjs --check=erp",
+    "check:rowlink": "node scripts/rowlink.check.mjs",
+    "e2e:erp": "node scripts/erp-space.e2e.cjs",
+    "check:boot": "node scripts/boot-replay.check.cjs",
+    "shot:dashgrid": "node scripts/e2e-editor.cjs --check=dashgrid --shot",
+    "check:overlay": "node scripts/overlay-zoom.check.cjs",
+    "check:leadicon": "node scripts/t2s-lead-icon.check.cjs",
+    "check:tasksummary": "node scripts/task-summary.check.cjs",
+    "check:plancard": "node scripts/plan-card.check.cjs",
+    "check:searchrow": "node scripts/search-row.check.cjs",
+    "check:diffmulti": "node scripts/diff-multifile.check.cjs",
+    "check:railjank": "node scripts/rail-jank.check.cjs",
+    "check:deskrail": "node scripts/desk-rail.check.cjs",
+    "check:deskcompanion": "node scripts/desk-companion.check.cjs",
+    "e2e:pdfcite": "node scripts/pdf-citation.e2e.cjs",
+    "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:pathgoneunmounted": "node scripts/vault-pathgone-unmounted.e2e.cjs",
+    "check:textfrag": "electron scripts/text-fragment.check.cjs",
+    "check:assetfetch": "electron scripts/asset-fetch.check.cjs",
+    "check:rtc": "electron scripts/rtc-capability.check.cjs",
+    "check:rtcsdk": "electron scripts/rtc-sdk.check.cjs",
+    "probe:rtc": "electron scripts/rtc-live.probe.cjs",
+    "e2e:inspect": "node scripts/inspect-overlay.e2e.cjs",
+    "e2e:mediacite": "node scripts/media-citation.e2e.cjs",
+    "e2e:chatembed": "node scripts/chat-embed.e2e.cjs",
+    "e2e:webcite": "node scripts/web-citation.e2e.cjs",
+    "check:ctxring": "node scripts/ctxring.check.cjs",
+    "check:ctxusage": "node scripts/e2e-editor.cjs --check=ctxusage --shot",
+    "check:connect": "node scripts/connect-preview.check.cjs",
+    "check:modelmenu": "node scripts/model-menu.check.cjs",
+    "check:menutap": "node scripts/menu-tap.check.cjs",
+    "check:settingsui": "node scripts/settings-ui.check.cjs",
+    "check:agentmemory": "node scripts/agent-memory.check.cjs",
+    "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:themeapp": "node scripts/theme-app.check.cjs",
+    "check:marketui": "node scripts/market-ui.check.cjs",
+    "probe:marketdl": "node scripts/market-download.probe.cjs",
+    "check:uiscale": "node scripts/ui-scale.check.cjs",
+    "check:uifont": "node scripts/ui-font.check.cjs",
+    "check:topchrome": "node scripts/top-chrome.check.cjs",
+    "check:minicard": "node scripts/mini-card.check.cjs",
+    "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:onboarding": "node scripts/plugin-onboarding.check.cjs",
+    "check:plugindeps": "node scripts/plugin-deps.check.cjs",
+    "check:pluginsync": "node scripts/plugin-install-sync.check.cjs",
+    "check:first-run": "node scripts/onboarding.check.cjs",
+    "check:miniauto": "node scripts/mini-auto.check.cjs",
+    "check:board": "node scripts/board-paper.check.cjs",
+    "check:boardlive": "node scripts/e2e-editor.cjs --check=board-live",
+    "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: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",
+    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",
+    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",
+    "build:amadeus": "FORSION_PRODUCT=amadeus electron-vite build",
+    "pack:amadeus": "FORSION_PRODUCT=amadeus npm run build:amadeus && FORSION_PRODUCT=amadeus electron-builder --config electron-builder.config.cjs --dir",
+    "check:extendview": "node scripts/extend-view.check.cjs",
+    "check:tablegroups": "node scripts/extend-view.check.cjs --groups-only",
+    "check:bottompanel": "node scripts/bottom-panel.check.cjs",
+    "check:bottomiframe": "node scripts/bottom-toggle-iframe.electron.cjs",
+    "shot:bottompanel": "node scripts/bottom-panel.check.cjs --shot",
+    "check:remount": "node scripts/main-remount.check.cjs",
+    "check:nav": "node scripts/nav-history.check.cjs",
+    "check:builtins": "node scripts/builtins.check.cjs",
+    "check:runblock": "node scripts/runblock.check.cjs",
+    "live:runblock": "node scripts/runblock-live.e2e.cjs",
+    "check:suggest": "node scripts/suggest-chip.check.cjs",
+    "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",
+    "check:parity": "node scripts/platform-parity.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",
+    "check:phonedist": "node scripts/lib/phone-dist-stamp.selftest.cjs",
+    "check:unitswitcher": "node scripts/unit-switcher.check.cjs",
+    "check:secrets": "node scripts/device-secrets.e2e.cjs",
+    "gen:engineroutes": "node scripts/gen-engine-routes.mjs",
+    "test:ics-tz": 'for tz in Europe/London America/New_York Asia/Shanghai Australia/Lord_Howe UTC; do echo "== $tz"; TZ=$tz vitest run frontend/src/views/calendar/ics.test.ts || exit 1; done',
+    "check:arrowtrap": "node scripts/arrow-trap.check.cjs",
+    "check:wikisuggest": "node scripts/e2e-editor.cjs --check=wiki-suggest",
+    "check:qfentry": "node scripts/e2e-editor.cjs --check=quickfind-entry",
+    "check:bsfocus": "node scripts/backspace-focus.check.cjs",
+    "check:docs": "node scripts/docs-links.check.cjs",
+    "check:menuclamp": "node scripts/menu-clamp.check.cjs",
+    "check:capsule": "node scripts/mobile-capsule.check.cjs",
+    "check:drawer": "node scripts/mobile-drawer.check.cjs",
+    "check:uimode": "node scripts/uimode-auto.check.cjs",
+    "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:dropfeedback": "node scripts/drop-feedback.check.cjs",
+    "check:chatside": "node scripts/chat-sidepanel.check.cjs",
+    "check:facade": "node scripts/facade-scope.check.cjs",
+    "check:sessionmode": "node scripts/session-mode.check.cjs",
+    "check:orbitside": "node scripts/orbitside.check.cjs",
+    "check:sidewidth": "node scripts/side-width.check.cjs",
+    "check:firstclick": "node scripts/first-click.check.cjs",
+    "check:firstenter": "node scripts/first-enter.check.cjs",
+    "fix:zhpunct": "node scripts/zh-punct.codemod.cjs",
+    "shot:walk": "node scripts/uiux-walk.shot.cjs",
+    "check:agentprofile": "node scripts/agent-profile.check.cjs",
+    "check:projectdetails": "node scripts/project-details.check.cjs",
+    "check:creationcard": "node scripts/creation-card.check.cjs",
+    "check:teamoutputs": "node scripts/team-outputs.check.cjs",
+    "check:teamprofile": "node scripts/team-profile.check.cjs",
+    "check:teamdesk": "node scripts/team-desk.check.cjs",
+    "check:ultra": "node scripts/ultra-effort.check.cjs",
+    "check:canvas": "node scripts/e2e-editor.cjs --check=unified-canvas",
+    "check:tutorial": "node scripts/e2e-editor.cjs --check=tutorial-note",
+    "check:tabicon": "node scripts/e2e-editor.cjs --check=tab-icon",
+    "shot:tabicon": "node scripts/e2e-editor.cjs --check=tab-icon --shot",
+    "shot:tutorial": "node scripts/e2e-editor.cjs --check=tutorial-note --shot",
+    "check:canvasreal": "node scripts/e2e-editor.cjs --check=canvas-realinput",
+    "check:canvastouch": "node scripts/e2e-editor.cjs --check=canvas-touch",
+    "check:blockops": "node scripts/e2e-editor.cjs --check=block-file-ops",
+    "check:selection-display": "node scripts/e2e-editor.cjs --check=selection-display",
+    "check:quickfind": "node scripts/e2e-editor.cjs --check=quickfind-cats",
+    "check:findbar": "node scripts/findbar.check.cjs",
+    "check:cssvar": "node scripts/css-var-override.check.cjs",
+    "check:shadowcontract": "node scripts/shadow-contract.check.cjs",
+    "check:shadowsurface": "node scripts/shadow-surface.check.cjs",
+    "check:calendarui": "node scripts/calendar-ui.check.cjs",
+    "check:astryxscope": "node scripts/astryx-scope.check.cjs",
+    "check:todo": "node scripts/todo-view.check.cjs",
+    "check:chattabs": "node scripts/chat-multitab.check.cjs",
+    "check:newtab": "node scripts/newtab-open.check.cjs",
+    "check:newnote": "node scripts/new-note-nav.check.cjs",
+    "check:calendarplugin": "node scripts/builtin-calendar.check.cjs",
+    "check:achtoast": "node scripts/ach-toast.check.cjs",
+    "check:homepage": "node scripts/builtin-homepage.check.cjs",
+    "check:artificial": "node scripts/builtin-artificial.check.cjs",
+    "check:sandbox": "node scripts/sandbox.check.cjs",
+    "check:homepageglass": "node scripts/homepage-glass.check.cjs",
+    "check:homepagepinned": "node scripts/homepage-pinned-spaces.check.cjs",
+    "check:homeslot": "node scripts/home-slot.check.cjs",
+    "e2e:canvaslive": "node scripts/canvas-live.e2e.cjs",
+    "e2e:attachment-clipboard": "node scripts/attachment-clipboard.e2e.cjs",
+    "e2e:seams": "node scripts/plugin-seams.e2e.cjs",
+    "check:imgsel": "node scripts/image-select.check.cjs",
+    "check:coldrag": "node scripts/e2e-editor.cjs --check=columns-realdrag",
+    "check:topdrag": "node scripts/e2e-editor.cjs --check=toplevel-realdrag",
+    "check:dragdel": "node scripts/e2e-editor.cjs --check=unified-dragdelete",
+    "check:formbase": "node scripts/form-baseline.check.cjs",
+    "e2e:mediaembed": "node scripts/media-embed.e2e.cjs",
+    "check:mediaembed": "node scripts/e2e-editor.cjs --check=media-embed",
+    "check:notescroll": "node scripts/note-scroll-memory.check.cjs",
+    "check:floatingtoc": "node scripts/floating-toc.check.cjs",
+    "check:shellnoscroll": "node scripts/shell-noscroll.check.cjs",
+    "check:manual": "node scripts/e2e-editor.cjs --check=manual-note",
+    "shot:manual": "node scripts/e2e-editor.cjs --check=manual-note --shot",
+    "e2e:coding": "node scripts/coding-studio.e2e.cjs",
+    "e2e:image-studio": "node scripts/image-studio.e2e.cjs",
+    "e2e:image-studio:live": "node scripts/image-studio.live.cjs",
+    "check:permissions": "node scripts/permissions.check.cjs",
+    "check:mininative": "node scripts/mini-auto.check.cjs --native-helper"
+  },
+  dependencies: {
+    "@astryxdesign/core": "^0.1.4",
+    "@astryxdesign/theme-neutral": "^0.1.4",
+    "@aws-sdk/client-s3": "^3.1091.0",
+    "@aws-sdk/lib-storage": "^3.1091.0",
+    "@codemirror/language-data": "^6.5.1",
+    "@dnd-kit/core": "^6.3.1",
+    "@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",
+    "@milkdown/kit": "^7.21.2",
+    "@milkdown/plugin-math": "^7.5.9",
+    "@milkdown/react": "^7.21.2",
+    "@milkdown/theme-nord": "^7.21.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@stylexjs/stylex": "^0.18.3",
+    "@uiw/react-codemirror": "^4.25.2",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/xterm": "^5.5.0",
+    chokidar: "^5.0.0",
+    diff: "^8.0.4",
+    diff2html: "^3.4.55",
+    dockview: "^7.0.2",
+    "dockview-react": "^7.0.2",
+    "docx-preview": "^0.3.5",
+    "electron-updater": "^6.3.9",
+    "framer-motion": "^12.40.0",
+    jszip: "^3.10.1",
+    katex: "^0.16.27",
+    lowlight: "^3.3.0",
+    "lucide-react": "^1.17.0",
+    "lz-string": "^1.5.0",
+    "micromark-util-classify-character": "^2.0.1",
+    nanoid: "^5.1.11",
+    "node-diff3": "^3.2.1",
+    "pdf-lib": "^1.17.1",
+    "pdfjs-dist": "^5.7.284",
+    "perfect-freehand": "^1.2.3",
+    qrcode: "^1.5.4",
+    react: "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-markdown": "^10.1.0",
+    "rehype-highlight": "^7.0.2",
+    "rehype-katex": "^7.0.1",
+    "remark-cjk-friendly": "^2.3.1",
+    "remark-cjk-friendly-gfm-strikethrough": "^2.3.1",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "sherpa-onnx-node": "^1.13.4",
+    sucrase: "^3.35.1",
+    unified: "^11.0.5",
+    "unist-util-visit": "^5.1.0",
+    webdav: "^5.10.0",
+    xlsx: "^0.18.5",
+    zod: "^4.4.3",
+    zustand: "^5.0.2"
+  },
+  devDependencies: {
+    "@electron/rebuild": "^3.7.1",
+    "@fontsource-variable/inter": "^5.3.0",
+    "@fontsource-variable/jetbrains-mono": "^5.3.0",
+    "@fontsource/lxgw-wenkai": "^5.3.0",
+    "@fontsource/noto-sans-sc": "^5.3.0",
+    "@iarna/toml": "^2.2.5",
+    "@types/node": "^20.10.0",
+    "@types/qrcode": "^1.5.6",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^5.1.4",
+    electron: "^40.8.0",
+    "electron-builder": "^26.15.3",
+    "electron-vite": "^5.0.0",
+    eslint: "^9.39.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "gray-matter": "^4.0.3",
+    "happy-dom": "^20.10.6",
+    "playwright-core": "^1.61.1",
+    typescript: "^5.7.0",
+    "typescript-eslint": "^8.65.0",
+    vitest: "^3.0.0",
+    yaml: "^2.9.0"
+  },
+  optionalDependencies: {
+    "node-pty": "^1.1.0"
+  }
+};
+
+// unit/main.ts
+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 action = commands.includes(args[0]) ? args.shift() : "run";
+var file = resolve7(args.shift() || (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");
+  for (const entry of installations(config)) if ((await readPackage(entry.path)).manifest.id === id) return entry;
+  throw new Error(`Plugin is not installed: ${id}`);
+}
+async function run() {
+  if (action === "init") {
+    const option = (key, fallback) => {
+      const i = args.indexOf(key);
+      return i < 0 ? fallback : args[i + 1];
+    };
+    const mode = option("--mode", "public");
+    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 });
+    const path = resolve7(file, "unit.json");
+    const config2 = {
+      instanceId: randomUUID8(),
+      name: "Forsion Unit",
+      version: package_default.version,
+      port,
+      bindHost: option("--host", "127.0.0.1"),
+      basePath,
+      webDist: resolve7(dist, "web"),
+      workerFile: resolve7(dist, "backendWorker.mjs"),
+      dataDir: resolve7(file, "data"),
+      plugins: [],
+      ...mode === "local" ? { workspace: { mode: "local" } } : {}
+    };
+    const handle = await open2(path, "wx", 384);
+    try {
+      await handle.writeFile(JSON.stringify(config2, null, 2) + "\n");
+    } finally {
+      await handle.close();
+    }
+    print({ config: path, instanceId: config2.instanceId });
+    return;
+  }
+  if (action === "install") {
+    if (!args[0]) throw new Error("A plugin package directory is required");
+    print(await installPackage(file, resolve7(args[0])));
+    return;
+  }
+  const config = await readConfig(file);
+  config.workerFile ||= resolve7(dist, "backendWorker.mjs");
+  if (action === "access") {
+    if (config.workspace?.mode !== "local") throw new Error("Public sites use their Account provider");
+    const token = await localOwnerToken(config.dataDir);
+    print({ url: `http://${config.bindHost || "127.0.0.1"}:${config.port}${config.basePath}#unit-owner=${token}` });
+    return;
+  }
+  if (action !== "run") {
+    try {
+      print(await sendControl(config.dataDir, { action, id: args[0] }));
+      return;
+    } catch (error) {
+      if (!unitIsOffline(error)) throw error;
+    }
+    if (action === "status") {
+      print({ running: false, instanceId: config.instanceId, plugins: await Promise.all(installations(config).map(async (p) => ({ id: (await readPackage(p.path)).manifest.id, enabled: p.enabled !== false }))) });
+      return;
+    }
+    const entry = await findInstallation(config, args[0]);
+    if (action === "enable" || action === "disable") {
+      entry.enabled = action === "enable";
+      await writeConfig(file, config);
+      print({ id: args[0], enabled: entry.enabled });
+      return;
+    }
+    if (action === "restart") throw new Error("Unit is not running");
+    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 });
+    const migration = new AbortController();
+    const cancelMigration = () => migration.abort(new Error("Migration interrupted"));
+    for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, cancelMigration);
+    try {
+      await migrateBackend({
+        signal: migration.signal,
+        id: pack.manifest.id,
+        entry: pack.backendEntry,
+        packageDir: pack.root,
+        dataDir,
+        config: entry.config || {},
+        env: { ...entry.config?.env || {}, ...entry.env },
+        workerFile: config.workerFile,
+        startTimeoutMs: 6e5
+      });
+    } finally {
+      for (const signal of ["SIGINT", "SIGTERM"]) process.off(signal, cancelMigration);
+    }
+    print({ id: pack.manifest.id, migrated: true });
+    return;
+  }
+  if (process.env.UNIT_PORT) config.port = Number(process.env.UNIT_PORT);
+  await mkdir7(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"));
+    if (!Number.isInteger(pid) || pid <= 0) throw new Error("Unit startup is locked; inspect data/run.lock");
+    try {
+      process.kill(pid, 0);
+      throw new Error("This Unit is already running");
+    } catch (failure) {
+      if (failure.code !== "ESRCH") throw failure;
+    }
+    await rm4(lockPath);
+    lock = await open2(lockPath, "wx", 384);
+  }
+  await lock.writeFile(String(process.pid));
+  await lock.close();
+  let unit;
+  let control;
+  let shutdownRequested = false, requestStop;
+  const onSignal = () => {
+    shutdownRequested = true;
+    void requestStop?.();
+  };
+  for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, onSignal);
+  try {
+    unit = await startBasicUnit(config);
+    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 (!["enable", "disable", "restart", "update", "migrate"].includes(command.action)) throw new Error("Unknown Unit command");
+      const entry = await findInstallation(config, command.id);
+      const previous = { ...entry };
+      if (command.action === "update") {
+        if (!command.path) throw new Error("An update package path is required");
+        await unit.update(command.id, command.path);
+        entry.path = resolve7(command.path);
+      } else if (command.action === "enable") {
+        await unit.enable(command.id);
+        entry.enabled = true;
+      } else if (command.action === "disable") {
+        await unit.disable(command.id);
+        entry.enabled = false;
+      } else if (command.action === "restart") await unit.restart(command.id);
+      else await unit.migrate(command.id);
+      try {
+        await writeConfig(file, config);
+      } catch (error) {
+        Object.assign(entry, previous);
+        entry.enabled = previous.enabled;
+        if (command.action === "update") await unit.update(command.id, previous.path);
+        if (command.action === "enable" && previous.enabled === false) await unit.disable(command.id);
+        if (command.action === "disable" && previous.enabled !== false) await unit.enable(command.id);
+        throw error;
+      }
+      return status();
+    };
+    control = await startControl(config.dataDir, (command) => {
+      const next = queue.then(() => dispatch(command));
+      queue = next.then(() => {
+      }, () => {
+      });
+      return next;
+    });
+    print(status());
+    console.log(`[unit] ${config.name} http://${config.bindHost || "127.0.0.1"}:${unit.port}${config.basePath}`);
+    let stopping = false;
+    const stop = async () => {
+      if (stopping) return;
+      stopping = true;
+      let failure = false;
+      try {
+        await control.close();
+        await queue;
+        await unit.close();
+      } catch (error) {
+        console.error(error);
+        failure = true;
+      } finally {
+        await rm4(lockPath, { force: true });
+        process.exit(failure ? 1 : 0);
+      }
+    };
+    requestStop = stop;
+    if (shutdownRequested) await stop();
+  } catch (error) {
+    for (const signal of ["SIGINT", "SIGTERM"]) process.off(signal, onSignal);
+    try {
+      await control?.close();
+    } finally {
+      try {
+        await unit?.close();
+      } finally {
+        await rm4(lockPath, { force: true });
+      }
+    }
+    throw error;
+  }
+}
+await run().catch((error) => {
+  console.error(`[unit] ${error instanceof Error ? error.message : "Command failed"}`);
+  process.exitCode = 1;
+});