niuma-codex 0.0.1-beta.11 → 0.0.1-beta.13

package/dist/cli.js

@@ -1963,11 +1963,11 @@ function token(value) {
 function size(kind, bytes3) {
   return (kind === "image" || kind === "file") && integer(bytes3, kind === "image" ? 20971520 : 52428800, kind === "image" ? 1 : 0);
 }
-function dataUrl(value, path55) {
+function dataUrl(value, path56) {
   if (typeof value !== "string") return false;
   try {
     const u = new URL(value);
-    return ["ws:", "wss:"].includes(u.protocol) && !u.username && !u.password && !u.search && !u.hash && (path55 ? u.pathname === path55 : ["/direct/v1/attachment/data", "/ws/v1/attachment/data"].includes(u.pathname));
+    return ["ws:", "wss:"].includes(u.protocol) && !u.username && !u.password && !u.search && !u.hash && (path56 ? u.pathname === path56 : ["/direct/v1/attachment/data", "/ws/v1/attachment/data"].includes(u.pathname));
   } catch {
     return false;
   }
@@ -6797,7 +6797,7 @@ var init_src = __esm({
 // apps/desktop/src/release-version.ts
 import { readFileSync } from "node:fs";
 function desktopReleaseVersion() {
-  return false ? null : "0.0.1-beta.11";
+  return false ? null : "0.0.1-beta.13";
 }
 function desktopPresenceVersion() {
   return desktopReleaseVersion() ?? sourcePresenceVersion;
@@ -9132,9 +9132,9 @@ var init_server_client = __esm({
         if (data.binding_revision !== snapshot2.binding_revision) throw new NotificationTransportError("invalid_response");
         return { binding_revision: snapshot2.binding_revision };
       }
-      async signedPost(path55, input, signal, method2 = "POST") {
+      async signedPost(path56, input, signal, method2 = "POST") {
         if (!this.identity || !this.serverOrigin.startsWith("https://")) throw new NotificationTransportError("business_error", 200, 200004);
-        const query2 = method2 === "GET" ? input : {}, body = method2 === "GET" ? "" : JSON.stringify(input), pathname = `/api/v1/push/${path55}`;
+        const query2 = method2 === "GET" ? input : {}, body = method2 === "GET" ? "" : JSON.stringify(input), pathname = `/api/v1/push/${path56}`;
         const key_id = createHash("sha256").update(this.identity.identity_public_key).digest("base64url");
         const operation_id = randomUUID(), nonce = encodeBase64Url(randomBytes2(32)), timestamp = Math.floor(Date.now() / 1e3);
         const bytes3 = createPushSigningBytes({ audience: this.serverOrigin, method: method2, pathname, query: query2, body_sha256: createHash("sha256").update(body).digest("base64url"), key_id, operation_id, timestamp, nonce });
@@ -11892,11 +11892,11 @@ var init_runtime_version = __esm({
       retryAt = 0;
       pending = null;
       controller = null;
-      setConnection(path55) {
+      setConnection(path56) {
         this.epoch++;
         this.controller?.abort();
         this.controller = null;
-        this.path = path55;
+        this.path = path56;
         this.value = null;
         this.pending = null;
         this.retryAt = 0;
@@ -12807,20 +12807,20 @@ function sendJson(response, httpStatus, body) {
 }
 function zodErrorToHttpApiError(error2) {
   const messages = error2.issues.map((issue) => {
-    const path55 = issue.path.join(".") || "\u53C2\u6570";
+    const path56 = issue.path.join(".") || "\u53C2\u6570";
     if (issue.code === "custom") {
       return issue.message;
     }
     if (issue.code === "invalid_type" && issue.received === "undefined") {
-      return `${path55}\u4E0D\u80FD\u4E3A\u7A7A`;
+      return `${path56}\u4E0D\u80FD\u4E3A\u7A7A`;
     }
     if (issue.code === "invalid_type") {
-      return `${path55}\u7C7B\u578B\u9519\u8BEF`;
+      return `${path56}\u7C7B\u578B\u9519\u8BEF`;
     }
     if (issue.code === "unrecognized_keys") {
       return `\u4E0D\u652F\u6301\u7684\u53C2\u6570: ${issue.keys.join(",")}`;
     }
-    return `${path55}\u683C\u5F0F\u9519\u8BEF`;
+    return `${path56}\u683C\u5F0F\u9519\u8BEF`;
   });
   const custom = error2.issues.some((issue) => issue.code === "custom");
   const missing4 = error2.issues.some(
@@ -17431,12 +17431,24 @@ async function installRelease(options) {
     const manifest = JSON.parse(await fs14.readFile(path19.join(pkg, "package.json"), "utf8"));
     if (manifest.name !== "niuma-codex" || manifest.version !== options.version) throw Error("version");
     if (!(await fs14.lstat(entry(dir))).isFile()) throw Error("entry");
-    await options.run(options.node, [
-      "--input-type=module",
-      "-e",
-      'import {createRequire} from "node:module";const r=createRequire(process.argv[1]);const p=r("./package.json");for(const name of Object.keys(p.dependencies||{}))r.resolve(name);if(p.dependencies?.sharp)r("sharp");',
-      path19.join(pkg, "package.json")
-    ], 3e4);
+    const probe = path19.join(pkg, `.verify-${randomUUID10()}.mjs`);
+    await fs14.writeFile(probe, `
+import { createRequire } from 'node:module';
+import { access } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+const manifest = require('./package.json');
+for (const name of Object.keys(manifest.dependencies || {})) {
+  await access(fileURLToPath(import.meta.resolve(name)));
+}
+// sharp \u4ECD\u987B\u5B9E\u9645\u52A0\u8F7D\uFF1B\u5176\u4F59\u670D\u52A1\u7AEF\u5BFC\u5165\u94FE\u7531 CLI \u5E2E\u52A9\u9A8C\u8BC1\u3002
+if (manifest.dependencies?.sharp) require('sharp');
+`, { flag: "wx", mode: 384 });
+    try {
+      await options.run(options.node, [probe], 3e4);
+    } finally {
+      await fs14.rm(probe, { force: true });
+    }
     await options.run(options.node, [entry(dir), "--help"], 3e4);
   }
   let exists = false;
@@ -17478,7 +17490,7 @@ var init_installer = __esm({
 });
 
 // apps/desktop/src/autostart/launch-agent.ts
-function renderLaunchAgent(config, entry, logs) {
+function autostartEnvironment(config) {
   const env = {
     HOME: config.home,
     PATH: config.path,
@@ -17488,12 +17500,16 @@ function renderLaunchAgent(config, entry, logs) {
   };
   if (config.codexHome) env.CODEX_HOME = config.codexHome;
   if (config.pushServerOrigin) env.NIUMA_PUSH_SERVER_ORIGIN = config.pushServerOrigin;
+  return env;
+}
+function renderLaunchAgent(config, entry, logs, application = false) {
+  const env = autostartEnvironment(config);
   const str = (v) => `<string>${xml(v)}</string>`;
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0"><dict>
-<key>Label</key>${str(AUTOSTART_LABEL)}
-<key>ProgramArguments</key><array>${[config.nodeExecutable, entry, "--background"].map(str).join("")}</array>
+<key>Label</key>${str(application ? AUTOSTART_APP_LABEL : AUTOSTART_LABEL)}
+${application ? "<key>BundleProgram</key><string>Contents/MacOS/Niuma</string>" : `<key>ProgramArguments</key><array>${[config.nodeExecutable, entry, "--background"].map(str).join("")}</array>`}
 <key>RunAtLoad</key><true/>
 <key>WorkingDirectory</key>${str(config.home)}
 <key>EnvironmentVariables</key><dict>${Object.entries(env).map(([k, v]) => `<key>${k}</key>${str(v)}`).join("")}</dict>
@@ -17502,19 +17518,124 @@ function renderLaunchAgent(config, entry, logs) {
 </dict></plist>
 `;
 }
-var AUTOSTART_LABEL, xml;
+var AUTOSTART_LABEL, AUTOSTART_APP_ID, AUTOSTART_APP_LABEL, xml;
 var init_launch_agent = __esm({
   "apps/desktop/src/autostart/launch-agent.ts"() {
     "use strict";
     AUTOSTART_LABEL = "com.niuma.desktop";
+    AUTOSTART_APP_ID = "com.niuma.npm-autostart";
+    AUTOSTART_APP_LABEL = "com.niuma.npm-autostart.agent";
     xml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
   }
 });
 
+// apps/desktop/src/assets.ts
+function desktopAssetUrl(area, file) {
+  const release2 = true;
+  return new URL(release2 ? `./assets/${area}/${file}` : `./${area}/static/${file}`, import.meta.url);
+}
+var init_assets = __esm({
+  "apps/desktop/src/assets.ts"() {
+    "use strict";
+  }
+});
+
+// apps/desktop/src/autostart/app-bundle.ts
+import fs15 from "node:fs/promises";
+import path20 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+async function checkAutostartApp(app) {
+  for (const directory of [app, ...["Contents", "Contents/MacOS", "Contents/Resources", "Contents/Library", "Contents/Library/LaunchAgents"].map((item) => path20.join(app, item))]) {
+    const stat3 = await fs15.lstat(directory);
+    if (!stat3.isDirectory() || stat3.uid !== process.getuid?.() || stat3.mode & 18) throw new AutostartError(900611, "\u81EA\u542F\u52A8\u5E94\u7528\u5305\u76EE\u5F55\u4E0D\u5B89\u5168");
+  }
+  for (const file of bundleFiles) {
+    const stat3 = await fs15.lstat(path20.join(app, file));
+    if (!stat3.isFile() || stat3.uid !== process.getuid?.() || stat3.mode & 18) throw new AutostartError(900611, "\u81EA\u542F\u52A8\u5E94\u7528\u5305\u6587\u4EF6\u4E0D\u5B89\u5168");
+  }
+  await fs15.access(path20.join(app, "Contents/MacOS/Niuma"), 1);
+  try {
+    await runProcess("/usr/bin/codesign", ["--verify", "--strict", app]);
+  } catch {
+    throw new AutostartError(900611, "\u81EA\u542F\u52A8\u5E94\u7528\u5305\u7B7E\u540D\u9A8C\u8BC1\u5931\u8D25\uFF0C\u672A\u8986\u76D6");
+  }
+}
+async function prepareAutostartApp(root, config, entry) {
+  const icon = await fs15.readFile(desktopAssetUrl("autostart", "Niuma.icns"));
+  const launcher = await fs15.readFile(desktopAssetUrl("autostart", "Niuma"));
+  const plist = Buffer.from(`<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>CFBundleIdentifier</key><string>${AUTOSTART_APP_ID}</string>
+<key>CFBundleName</key><string>Niuma</string>
+<key>CFBundleDisplayName</key><string>Niuma</string>
+<key>CFBundleExecutable</key><string>Niuma</string>
+<key>CFBundleIconFile</key><string>Niuma.icns</string>
+<key>CFBundlePackageType</key><string>APPL</string>
+<key>CFBundleVersion</key><string>1</string>
+<key>LSUIElement</key><true/>
+</dict></plist>
+`);
+  const script3 = Buffer.from(`#!/bin/sh
+# \u4EC5\u542F\u52A8\u5DF2\u9A8C\u8BC1\u7684\u56FA\u5B9A npm \u7248\u672C\uFF0C\u73AF\u5883\u4E0E\u767B\u5F55\u9879\u4F7F\u7528\u540C\u4E00\u767D\u540D\u5355\u3002
+${Object.entries(autostartEnvironment(config)).map(([key, value]) => `export ${key}=${quote(value)}`).join("\n")}
+cd ${quote(config.home)} || exit 1
+exec ${quote(config.nodeExecutable)} ${quote(entry)} --background
+`);
+  const contents = [plist, launcher, icon, script3, Buffer.from(renderLaunchAgent(config, entry, root, true))];
+  const digest5 = createHash2("sha256");
+  for (const data of contents) digest5.update(data);
+  const parent = path20.join(root, "applications");
+  await privateDirectory(parent);
+  const directory = path20.join(parent, digest5.digest("hex"));
+  await privateDirectory(directory);
+  const app = path20.join(directory, "Niuma.app");
+  let exists = false;
+  try {
+    await fs15.lstat(app);
+    exists = true;
+  } catch (error2) {
+    if (error2.code !== "ENOENT") throw error2;
+  }
+  if (exists) {
+    await checkAutostartApp(app);
+    for (let i = 0; i < bundleFiles.length; i++) if (i !== 1 && !(await fs15.readFile(path20.join(app, bundleFiles[i]))).equals(contents[i])) throw new AutostartError(900611, "\u81EA\u542F\u52A8\u5E94\u7528\u5305\u5DF2\u88AB\u4FEE\u6539\uFF0C\u672A\u8986\u76D6");
+    return app;
+  }
+  const staging = await fs15.mkdtemp(path20.join(directory, ".prepare-"));
+  const temporary = path20.join(staging, "Niuma.app");
+  try {
+    await fs15.mkdir(path20.join(temporary, "Contents/MacOS"), { recursive: true, mode: 448 });
+    await fs15.mkdir(path20.join(temporary, "Contents/Resources"), { mode: 448 });
+    await fs15.mkdir(path20.join(temporary, "Contents/Library/LaunchAgents"), { recursive: true, mode: 448 });
+    for (let i = 0; i < bundleFiles.length; i++) await fs15.writeFile(path20.join(temporary, bundleFiles[i]), contents[i], { flag: "wx", mode: i === 1 ? 448 : 384 });
+    await runProcess("/usr/bin/codesign", ["--force", "--sign", "-", temporary]);
+    await checkAutostartApp(temporary);
+    await fs15.rename(temporary, app);
+    return app;
+  } finally {
+    await fs15.rm(staging, { recursive: true, force: true });
+  }
+}
+var LSREGISTER, quote, bundleFiles;
+var init_app_bundle = __esm({
+  "apps/desktop/src/autostart/app-bundle.ts"() {
+    "use strict";
+    init_assets();
+    init_installer();
+    init_launch_agent();
+    init_types2();
+    LSREGISTER = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
+    quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+    bundleFiles = ["Contents/Info.plist", "Contents/MacOS/Niuma", "Contents/Resources/Niuma.icns", "Contents/Resources/launch.sh", `Contents/Library/LaunchAgents/${AUTOSTART_APP_LABEL}.plist`];
+  }
+});
+
 // apps/desktop/src/autostart/manager.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import fsp from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
+import os2 from "node:os";
 import { randomUUID as randomUUID11 } from "node:crypto";
 async function readJson(file) {
   try {
@@ -17537,13 +17658,13 @@ async function atomic(file, value) {
 }
 function acquire(file) {
   try {
-    const fd = fs15.openSync(file, fs15.constants.O_CREAT | fs15.constants.O_RDWR | fs15.constants.O_NOFOLLOW | fs15.constants.O_NONBLOCK | 32, 384);
-    const s = fs15.fstatSync(fd);
+    const fd = fs16.openSync(file, fs16.constants.O_CREAT | fs16.constants.O_RDWR | fs16.constants.O_NOFOLLOW | fs16.constants.O_NONBLOCK | 32, 384);
+    const s = fs16.fstatSync(fd);
     if (!s.isFile() || s.uid !== process.getuid?.() || s.mode & 63) {
-      fs15.closeSync(fd);
+      fs16.closeSync(fd);
       throw Error("unsafe");
     }
-    return () => fs15.closeSync(fd);
+    return () => fs16.closeSync(fd);
   } catch {
     throw new AutostartError(900511, "\u5DF2\u6709\u81EA\u542F\u52A8\u64CD\u4F5C\u6B63\u5728\u8FDB\u884C\uFF0C\u6216\u64CD\u4F5C\u9501\u4E0D\u53EF\u7528");
   }
@@ -17554,12 +17675,13 @@ var init_manager = __esm({
     "use strict";
     init_installer();
     init_launch_agent();
+    init_app_bundle();
     init_types2();
     AutostartManager = class {
       constructor(options) {
         this.options = options;
-        this.root = path20.join(options.home, "Library/Application Support/Niuma/autostart");
-        this.plist = path20.join(options.home, "Library/LaunchAgents", `${AUTOSTART_LABEL}.plist`);
+        this.root = path21.join(options.home, "Library/Application Support/Niuma/autostart");
+        this.plist = path21.join(options.home, "Library/LaunchAgents", `${AUTOSTART_LABEL}.plist`);
         this.run = options.run ?? runProcess;
       }
       options;
@@ -17575,29 +17697,62 @@ var init_manager = __esm({
         return `${this.domain}/${AUTOSTART_LABEL}`;
       }
       get metadata() {
-        return path20.join(this.root, "registration.json");
+        return path21.join(this.root, "registration.json");
       }
       get operationFile() {
-        return path20.join(this.root, "operation.json");
+        return path21.join(this.root, "operation.json");
       }
       supported() {
-        return (this.options.platform ?? process.platform) === "darwin";
+        return (this.options.platform ?? process.platform) === "darwin" && Number((this.options.osRelease ?? os2.release()).split(".")[0]) >= 22;
       }
-      async loaded() {
+      // 2 表示已注册但待批准，不能等同于未注册；未知状态不能触发破坏性恢复。
+      async registrationState(registration) {
+        if (registration?.service === "application-agent" && registration.appPath) {
+          try {
+            await checkAutostartApp(registration.appPath);
+            const result = JSON.parse(await this.run(path21.join(registration.appPath, "Contents/MacOS/Niuma"), ["--autostart-status"]));
+            return [0, 1, 2, 3].includes(result.status) ? result.status : null;
+          } catch {
+            return null;
+          }
+        }
         try {
           await this.run("/bin/launchctl", ["print", this.target]);
-          return true;
+          return 1;
         } catch (e) {
-          return e.code === 113 ? false : null;
+          return e.code === 113 ? 0 : null;
         }
       }
+      async loaded(registration) {
+        const state = await this.registrationState(registration);
+        return state === null ? null : state === 1;
+      }
+      async stopRegistration(registration) {
+        const state = await this.registrationState(registration);
+        if (state === null) throw new AutostartError(900614, "\u65E0\u6CD5\u786E\u8BA4\u542F\u52A8\u9879\u72B6\u6001\uFF0C\u4FDD\u7559\u539F\u6CE8\u518C");
+        if (state === 1 || state === 2) await this.unload(registration);
+      }
+      /** 应用注册由 ServiceManagement 持有；legacy 注册继续用原 launchctl 路径回滚。 */
+      async load(registration, allowPending = false) {
+        if (registration.service === "application-agent" && registration.appPath) {
+          await checkAutostartApp(registration.appPath);
+          const result = JSON.parse(await this.run(path21.join(registration.appPath, "Contents/MacOS/Niuma"), ["--autostart-register"]));
+          if (result.status !== 1 && !(allowPending && result.status === 2)) throw new AutostartError(900614, "\u8BF7\u5728\u7CFB\u7EDF\u8BBE\u7F6E\u7684\u767B\u5F55\u9879\u4E2D\u5141\u8BB8 Niuma \u5728\u540E\u53F0\u8FD0\u884C\u540E\u91CD\u8BD5");
+        } else await this.run("/bin/launchctl", ["bootstrap", this.domain, this.plist]);
+      }
+      async unload(registration) {
+        if (registration?.service === "application-agent" && registration.appPath) {
+          await checkAutostartApp(registration.appPath);
+          await this.run(path21.join(registration.appPath, "Contents/MacOS/Niuma"), ["--autostart-unregister"]);
+        } else await this.run("/bin/launchctl", ["bootout", this.target]);
+      }
       async status() {
-        if (!this.supported() || this.options.unavailableReason) return { supported: false, registered: false, loaded: null, available: false, registeredVersion: null, runningVersion: null, running: null, reason: this.options.unavailableReason ?? "\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301\u767B\u5F55\u81EA\u542F\u52A8", logPath: this.root, operation: null };
+        if (!this.supported() || this.options.unavailableReason) return { supported: false, registered: false, loaded: null, available: false, registeredVersion: null, runningVersion: null, running: null, reason: this.options.unavailableReason ?? "\u767B\u5F55\u81EA\u542F\u52A8\u9700\u8981 macOS 13 \u6216\u66F4\u65B0\u7248\u672C", logPath: this.root, operation: null };
         const registration = await readJson(this.metadata);
         let operation = await readJson(this.operationFile);
         if (operation?.state === "running" && !this.busy) {
           try {
-            const release2 = acquire(path20.join(this.root, "operation.lock"));
+            const release2 = acquire(path21.join(this.root, "operation.lock"));
             release2();
             operation = { ...operation, state: "interrupted", code: 900615, message: "\u4E0A\u6B21\u81EA\u542F\u52A8\u64CD\u4F5C\u5DF2\u4E2D\u65AD\uFF0C\u8BF7\u91CD\u8BD5" };
           } catch {
@@ -17607,17 +17762,21 @@ var init_manager = __esm({
         if (registration) {
           if (registration.owner !== "niuma-autostart-v1") throw new AutostartError(900611, "\u81EA\u542F\u52A8\u914D\u7F6E\u4E0D\u5C5E\u4E8E Niuma");
           try {
-            const stat3 = await fsp.lstat(this.plist);
-            registered = stat3.isFile() && await fsp.readFile(this.plist, "utf8") === registration.plist;
-            await fsp.access(registration.config.nodeExecutable, fs15.constants.X_OK);
-            await fsp.access(registration.entryPath, fs15.constants.R_OK);
+            if (registration.service === "application-agent") registered = true;
+            else {
+              const stat3 = await fsp.lstat(this.plist);
+              registered = stat3.isFile() && await fsp.readFile(this.plist, "utf8") === registration.plist;
+            }
+            await fsp.access(registration.config.nodeExecutable, fs16.constants.X_OK);
+            await fsp.access(registration.entryPath, fs16.constants.R_OK);
+            if (registration.appPath) await checkAutostartApp(registration.appPath);
             available = registered;
           } catch {
             reason = "\u81EA\u542F\u52A8\u8FD0\u884C\u6587\u4EF6\u6216 Node \u4E0D\u53EF\u7528\uFF0C\u8BF7\u91CD\u65B0\u914D\u7F6E";
           }
         }
         const running = await this.options.running?.().catch(() => ({ running: null, version: null })) ?? { running: null, version: null };
-        const loaded = await this.loaded();
+        const loaded = await this.loaded(registration);
         if (registered && loaded !== true) {
           available = false;
           reason = "\u542F\u52A8\u9879\u672A\u52A0\u8F7D\u6216\u65E0\u6CD5\u67E5\u8BE2\uFF0C\u8BF7\u91CD\u65B0\u914D\u7F6E";
@@ -17636,13 +17795,13 @@ var init_manager = __esm({
         };
       }
       async beginSetEnabled(enabled, config) {
-        if (!this.supported() || this.options.unavailableReason) throw new AutostartError(900611, this.options.unavailableReason ?? "\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301\u767B\u5F55\u81EA\u542F\u52A8");
+        if (!this.supported() || this.options.unavailableReason) throw new AutostartError(900611, this.options.unavailableReason ?? "\u767B\u5F55\u81EA\u542F\u52A8\u9700\u8981 macOS 13 \u6216\u66F4\u65B0\u7248\u672C");
         if (this.busy) throw new AutostartError(900511, "\u5DF2\u6709\u81EA\u542F\u52A8\u64CD\u4F5C\u6B63\u5728\u8FDB\u884C");
         this.busy = true;
         let release2;
         try {
           await privateDirectory(this.root);
-          release2 = acquire(path20.join(this.root, "operation.lock"));
+          release2 = acquire(path21.join(this.root, "operation.lock"));
           const operation = { id: randomUUID11(), targetEnabled: enabled, state: "running", startedAt: Date.now(), finishedAt: null, pid: process.pid };
           await atomic(this.operationFile, JSON.stringify(operation));
           this.active = (async () => {
@@ -17682,7 +17841,7 @@ var init_manager = __esm({
       }
       /** 注册文件和元数据的两次写入由恢复记录覆盖，崩溃后只恢复可证明自有的内容。 */
       async recoverTransaction() {
-        const file = path20.join(this.root, "transaction.json");
+        const file = path21.join(this.root, "transaction.json");
         const transaction = await readJson(file);
         if (!transaction) return;
         if (transaction.owner !== "niuma-autostart-v1") throw new AutostartError(900611, "\u6CE8\u518C\u6062\u590D\u8BB0\u5F55\u65E0\u6548");
@@ -17695,21 +17854,22 @@ var init_manager = __esm({
           if (e.code !== "ENOENT") throw new AutostartError(900611, "\u65E0\u6CD5\u5B89\u5168\u6062\u590D\u542F\u52A8\u9879");
         }
         if (current2 !== null && current2 !== transaction.previous?.plist && current2 !== transaction.next?.plist) throw new AutostartError(900611, "\u542F\u52A8\u9879\u5DF2\u88AB\u5176\u4ED6\u7A0B\u5E8F\u4FEE\u6539\uFF0C\u672A\u8986\u76D6");
-        const loaded = await this.loaded();
-        if (loaded === null) throw new AutostartError(900614, "\u65E0\u6CD5\u786E\u8BA4\u542F\u52A8\u9879\u72B6\u6001\uFF0C\u6062\u590D\u672A\u5B8C\u6210");
-        if (loaded) await this.run("/bin/launchctl", ["bootout", this.target]);
+        if (transaction.next) await this.stopRegistration(transaction.next);
+        if (transaction.previous) await this.stopRegistration(transaction.previous);
         if (transaction.previous) {
-          await atomic(this.plist, transaction.previous.plist);
+          if (transaction.previous.service === "application-agent") await fsp.rm(this.plist, { force: true });
+          else await atomic(this.plist, transaction.previous.plist);
           await atomic(this.metadata, JSON.stringify(transaction.previous));
         } else {
           await fsp.rm(this.plist, { force: true });
           await fsp.rm(this.metadata, { force: true });
         }
-        if (transaction.wasLoaded) await this.run("/bin/launchctl", ["bootstrap", this.domain, this.plist]);
+        if (transaction.previous?.appPath) await this.run(LSREGISTER, ["-f", transaction.previous.appPath]);
+        if ((transaction.wasRegistered ?? transaction.wasLoaded) && transaction.previous) await this.load(transaction.previous, !transaction.wasLoaded);
         await fsp.rm(file);
       }
       async change(enabled, input) {
-        await privateDirectory(path20.dirname(this.plist));
+        await privateDirectory(path21.dirname(this.plist));
         await this.recoverTransaction();
         const previous = await readJson(this.metadata);
         let existing = null;
@@ -17726,30 +17886,38 @@ var init_manager = __esm({
         } catch {
           throw new AutostartError(900611, "\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u7684 macOS \u56FE\u5F62\u767B\u5F55\u4F1A\u8BDD");
         }
-        const wasLoaded = await this.loaded();
-        if (wasLoaded === null) throw new AutostartError(900614, "\u65E0\u6CD5\u786E\u8BA4\u542F\u52A8\u9879\u52A0\u8F7D\u72B6\u6001");
+        if (previous && previous.owner !== "niuma-autostart-v1") throw new AutostartError(900611, "\u81EA\u542F\u52A8\u914D\u7F6E\u4E0D\u5C5E\u4E8E Niuma");
+        const priorState = await this.registrationState(previous);
+        const wasLoaded = priorState === 1, wasRegistered = priorState === 1 || priorState === 2;
+        if (priorState === null) throw new AutostartError(900614, "\u65E0\u6CD5\u786E\u8BA4\u542F\u52A8\u9879\u52A0\u8F7D\u72B6\u6001");
         if (wasLoaded && !previous) throw new AutostartError(900611, "\u5DF2\u52A0\u8F7D\u7684\u540C\u540D\u670D\u52A1\u7F3A\u5C11 Niuma \u5F52\u5C5E\u8BB0\u5F55\uFF0C\u672A\u63A5\u7BA1");
         let next = null;
         if (enabled) {
           const config = input ?? this.options.config();
           await this.options.guard?.();
-          if (previous && existing === previous.plist && JSON.stringify(config) === JSON.stringify(previous.config) && (await this.status()).available) return;
-          const installed = await (this.options.install?.(config) ?? installRelease({ root: this.root, version: config.releaseVersion, node: config.nodeExecutable, npm: path20.join(path20.dirname(config.nodeExecutable), "npm"), run: this.run }));
+          const reusable = previous && (previous.service === "application-agent" ? existing === null : existing === previous.plist) && JSON.stringify(config) === JSON.stringify(previous.config) && (await this.status()).available;
+          const installed = reusable ? { entryPath: previous.entryPath } : await (this.options.install?.(config) ?? installRelease({ root: this.root, version: config.releaseVersion, node: config.nodeExecutable, npm: path21.join(path21.dirname(config.nodeExecutable), "npm"), run: this.run }));
+          const appPath = await prepareAutostartApp(this.root, config, installed.entryPath);
           await this.options.guard?.();
-          next = { owner: "niuma-autostart-v1", config, entryPath: installed.entryPath, plist: renderLaunchAgent(config, installed.entryPath, this.root) };
+          next = { owner: "niuma-autostart-v1", service: "application-agent", config, entryPath: installed.entryPath, appPath, plist: renderLaunchAgent(config, installed.entryPath, this.root, true) };
+          if (reusable && previous.service === next.service && previous.appPath === appPath && previous.plist === next.plist) {
+            await this.run(LSREGISTER, ["-f", appPath]);
+            return;
+          }
           for (const name2 of ["stdout.log", "stderr.log"]) {
-            const handle = await fsp.open(path20.join(this.root, name2), fs15.constants.O_WRONLY | fs15.constants.O_APPEND | fs15.constants.O_CREAT | fs15.constants.O_NOFOLLOW, 384);
+            const handle = await fsp.open(path21.join(this.root, name2), fs16.constants.O_WRONLY | fs16.constants.O_APPEND | fs16.constants.O_CREAT | fs16.constants.O_NOFOLLOW, 384);
             await handle.close();
           }
         }
-        const transactionFile = path20.join(this.root, "transaction.json");
-        await atomic(transactionFile, JSON.stringify({ owner: "niuma-autostart-v1", previous, next, wasLoaded }));
+        const transactionFile = path21.join(this.root, "transaction.json");
+        await atomic(transactionFile, JSON.stringify({ owner: "niuma-autostart-v1", previous, next, wasLoaded, wasRegistered }));
         try {
-          if (wasLoaded) await this.run("/bin/launchctl", ["bootout", this.target]);
+          if (next?.appPath) await this.run(LSREGISTER, ["-f", next.appPath]);
+          if (wasRegistered) await this.unload(previous);
           if (next) {
-            await atomic(this.plist, next.plist);
+            await fsp.rm(this.plist, { force: true });
             await atomic(this.metadata, JSON.stringify(next));
-            await this.run("/bin/launchctl", ["bootstrap", this.domain, this.plist]);
+            await this.load(next);
           } else {
             await fsp.rm(this.plist, { force: true });
             await fsp.rm(this.metadata, { force: true });
@@ -17758,13 +17926,7 @@ var init_manager = __esm({
         } catch {
           let restored = true;
           try {
-            if (await this.loaded()) await this.run("/bin/launchctl", ["bootout", this.target]);
-            if (existing !== null) await atomic(this.plist, existing);
-            else await fsp.rm(this.plist, { force: true });
-            if (previous) await atomic(this.metadata, JSON.stringify(previous));
-            else await fsp.rm(this.metadata, { force: true });
-            if (wasLoaded) await this.run("/bin/launchctl", ["bootstrap", this.domain, this.plist]);
-            await fsp.rm(transactionFile, { force: true });
+            await this.recoverTransaction();
           } catch {
             restored = false;
           }
@@ -17776,8 +17938,8 @@ var init_manager = __esm({
 });
 
 // apps/desktop/src/autostart/production.ts
-import os2 from "node:os";
-import path21 from "node:path";
+import os3 from "node:os";
+import path22 from "node:path";
 function autostartConfig(args, relayOrigin) {
   const version2 = desktopReleaseVersion();
   if (!version2) throw new AutostartError(900611, "\u6E90\u7801\u8FD0\u884C\u4E0D\u652F\u6301\u6CE8\u518C\u81EA\u542F\u52A8\uFF0C\u8BF7\u4F7F\u7528\u5DF2\u53D1\u5E03\u7684 niuma-codex");
@@ -17785,8 +17947,8 @@ function autostartConfig(args, relayOrigin) {
   return {
     releaseVersion: version2,
     nodeExecutable: process.execPath,
-    home: os2.homedir(),
-    path: [path21.dirname(process.execPath), process.env.PATH ?? "/usr/bin:/bin"].join(":"),
+    home: os3.homedir(),
+    path: [path22.dirname(process.execPath), process.env.PATH ?? "/usr/bin:/bin"].join(":"),
     ...process.env.CODEX_HOME ? { codexHome: process.env.CODEX_HOME } : {},
     relayOrigin: resolveRelayConfig({ relay_origin: relayOrigin ?? resolveRelayStartupOrigin({ env: process.env, cliOrigin: args.flags.relayOrigin }) }).origin,
     pushServerOrigin: resolvePushServerOrigin(process.env),
@@ -17801,7 +17963,7 @@ function statusRecord(value) {
 function createAutostartManager(args = parseRootArgs(process.argv.slice(2)), page4 = false, relayOrigin) {
   const client = new DaemonClient();
   return new AutostartManager({
-    home: os2.homedir(),
+    home: os3.homedir(),
     ...page4 && !desktopReleaseVersion() ? { unavailableReason: "\u6E90\u7801\u8FD0\u884C\u4E0D\u652F\u6301\u767B\u5F55\u81EA\u542F\u52A8\uFF0C\u8BF7\u4F7F\u7528\u5DF2\u53D1\u5E03\u7684 niuma-codex" } : {},
     config: () => autostartConfig(args, relayOrigin),
     running: async () => {
@@ -18224,15 +18386,15 @@ var init_client_turn_query_context = __esm({
 });
 
 // apps/desktop/src/niuma/session-history-file.ts
-import fs16 from "node:fs/promises";
-import path22 from "node:path";
-import { createHash as createHash2 } from "node:crypto";
+import fs17 from "node:fs/promises";
+import path23 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
 function matchesSessionFileIdentity(file, stat3) {
   const exact = (value) => typeof value === "number" ? Number.isSafeInteger(value) && value >= 0 ? String(value) : null : /^(0|[1-9]\d{0,39})$/.test(value) ? value : null;
   return exact(file.dev) === String(stat3.dev) && exact(file.ino) === String(stat3.ino);
 }
 async function preciseStat(file) {
-  const stat3 = await fs16.stat(file, { bigint: true });
+  const stat3 = await fs17.stat(file, { bigint: true });
   const size2 = Number(stat3.size);
   if (!Number.isSafeInteger(size2)) throw new SessionHistoryError("RESOURCE_LIMIT", "\u4F1A\u8BDD\u6587\u4EF6\u8D85\u51FA\u8BFB\u53D6\u8303\u56F4");
   return { dev: stat3.dev, ino: stat3.ino, size: size2, mtimeMs: Number(stat3.mtimeNs) / 1e6, isFile: () => stat3.isFile() };
@@ -18248,12 +18410,12 @@ function rethrowUnreadableHistoryPath(error2) {
 }
 function fileIdentity(file) {
   const uuid7 = "[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}";
-  const match = path22.basename(file).match(new RegExp(`(${uuid7})(?:_(${uuid7}))?\\.jsonl$`, "i"));
+  const match = path23.basename(file).match(new RegExp(`(${uuid7})(?:_(${uuid7}))?\\.jsonl$`, "i"));
   return match ? { owner: match[1], segment: match[2] ?? match[1] } : null;
 }
 async function readBytes(file, start, length, onRead, signal) {
   abortIfRequested(signal);
-  const handle = await fs16.open(file, "r").catch(rethrowUnreadableHistoryPath);
+  const handle = await fs17.open(file, "r").catch(rethrowUnreadableHistoryPath);
   try {
     const buffer = Buffer.allocUnsafe(length);
     let filled = 0;
@@ -18311,7 +18473,7 @@ async function header(file, size2, onRead, signal) {
 }
 async function openSessionFile(file, threadId2, chunkBytes, end, onRead, signal, onCutoffCaptured) {
   abortIfRequested(signal);
-  const resolved3 = await fs16.realpath(file).catch(rethrowUnreadableHistoryPath);
+  const resolved3 = await fs17.realpath(file).catch(rethrowUnreadableHistoryPath);
   const stat3 = await preciseStat(resolved3).catch(rethrowUnreadableHistoryPath);
   abortIfRequested(signal);
   if (!stat3.isFile()) throw new SessionHistoryError("INVALID_METADATA", "\u4F1A\u8BDD\u8DEF\u5F84\u4E0D\u662F\u666E\u901A\u6587\u4EF6");
@@ -18458,7 +18620,7 @@ var init_session_history_file = __esm({
     nonempty = (value) => typeof value === "string" && value.length > 0 ? value : null;
     SESSION_RECORD_LOCATION = /* @__PURE__ */ Symbol("sessionHistoryLocation");
     SESSION_RECORD_RANGE = /* @__PURE__ */ Symbol("sessionHistoryRange");
-    hash = (value) => createHash2("sha256").update(value).digest("hex");
+    hash = (value) => createHash3("sha256").update(value).digest("hex");
   }
 });
 
@@ -20592,9 +20754,9 @@ var init_create = __esm({
 });
 
 // apps/desktop/src/daemon/async-question-response.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function submissionId(input) {
-  const h = createHash3("sha256").update(JSON.stringify([input.principal, input.threadId, input.idempotencyKey])).digest("hex");
+  const h = createHash4("sha256").update(JSON.stringify([input.principal, input.threadId, input.idempotencyKey])).digest("hex");
   return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-8${h.slice(17, 20)}-${h.slice(20, 32)}`;
 }
 function questionWasNotDispatched(result) {
@@ -20602,7 +20764,7 @@ function questionWasNotDispatched(result) {
 }
 async function respondAsyncQuestion(options) {
   const { store, input } = options;
-  const fingerprint2 = createHash3("sha256").update(JSON.stringify([input.questionId, input.answer])).digest("hex");
+  const fingerprint2 = createHash4("sha256").update(JSON.stringify([input.questionId, input.answer])).digest("hex");
   const key = { principal: input.principal, threadId: input.threadId, clientMessageId: submissionId(input) };
   if (store.get(key).state !== "untracked") {
     const existing = await store.reserve({ ...key, questionId: input.questionId, fingerprint: fingerprint2, nativeToken: key.clientMessageId });
@@ -21125,7 +21287,7 @@ function formatRedactedSeparator(separator) {
 function cleanDetail(detail) {
   return detail.replace(/<!--[\s\S]*?-->/g, " ").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(
     SENSITIVE_KEY_PATTERN,
-    (_match, prefix, quote, key, separator) => `${prefix}${quote}${key}${quote}${formatRedactedSeparator(separator)}[REDACTED]`
+    (_match, prefix, quote2, key, separator) => `${prefix}${quote2}${key}${quote2}${formatRedactedSeparator(separator)}[REDACTED]`
   ).replace(
     BEARER_PATTERN,
     (_match, prefix, scheme, separator) => `${prefix}${scheme}${formatRedactedSeparator(separator)}[REDACTED]`
@@ -21288,10 +21450,10 @@ var init_status = __esm({
 });
 
 // apps/desktop/src/niuma/thread-summary.ts
-import path23 from "node:path";
+import path24 from "node:path";
 function pathBelongsToProjectRoot(projectRoot, candidateRoot) {
-  const relative = path23.relative(path23.resolve(projectRoot), path23.resolve(candidateRoot));
-  return relative === "" || !relative.startsWith("..") && !path23.isAbsolute(relative);
+  const relative = path24.relative(path24.resolve(projectRoot), path24.resolve(candidateRoot));
+  return relative === "" || !relative.startsWith("..") && !path24.isAbsolute(relative);
 }
 function toLatestTurn(turns) {
   const latest = turns.at(-1);
@@ -21359,7 +21521,7 @@ function normalizeThreadSummary(thread4, pending = null, options = {}) {
     id: thread4.id,
     title: thread4.name ?? thread4.preview ?? "",
     projectRoot: thread4.cwd,
-    projectName: path23.basename(thread4.cwd) || thread4.cwd,
+    projectName: path24.basename(thread4.cwd) || thread4.cwd,
     status: status2,
     pending: normalizedPending,
     createdAt: thread4.createdAt,
@@ -22679,7 +22841,7 @@ var init_codex_input = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/message-send-operation.ts
-import { createHash as createHash4, randomUUID as randomUUID15 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID15 } from "node:crypto";
 function createMessageSendOperation(ports) {
   return async (params, options) => ports.runResponseOperation(async (generation) => {
     const threadId2 = params.threadId;
@@ -22821,7 +22983,7 @@ function createMessageSendOperation(ports) {
                   attachmentId: part.attachmentId,
                   clientMessageId: clientUserMessageId ?? `legacy-${randomUUID15()}`,
                   partIndex,
-                  sha256: createHash4("sha256").update(Buffer.from(native.url.slice(native.url.indexOf(",") + 1), "base64")).digest("hex")
+                  sha256: createHash5("sha256").update(Buffer.from(native.url.slice(native.url.indexOf(",") + 1), "base64")).digest("hex")
                 });
                 dispatchedImageIds.add(part.attachmentId);
               }
@@ -24378,12 +24540,12 @@ var init_requests = __esm({
 });
 
 // apps/desktop/src/niuma/async-questions.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function asyncQuestionId(rawId, index) {
   if (!rawId || !Number.isSafeInteger(index) || index < 0 || index > 2) {
     throw new TypeError("invalid_async_question_identity");
   }
-  return `aq_${createHash5("sha256").update(JSON.stringify([rawId, index])).digest("base64url")}`;
+  return `aq_${createHash6("sha256").update(JSON.stringify([rawId, index])).digest("base64url")}`;
 }
 function exactRecord2(value, keys3) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
@@ -24491,9 +24653,9 @@ function resourcePaths(platform2 = process.platform) {
     toLink(value) {
       const parsed = parseLocal(value);
       if (parsed === null) return null;
-      const path55 = windows2 ? parsed.replaceAll("\\", "/") : parsed;
+      const path56 = windows2 ? parsed.replaceAll("\\", "/") : parsed;
       try {
-        return encodeURIComponent(path55).replace(/%2F/gu, "/").replace(/^([a-z])%3A\//iu, "$1:/");
+        return encodeURIComponent(path56).replace(/%2F/gu, "/").replace(/^([a-z])%3A\//iu, "$1:/");
       } catch {
         return null;
       }
@@ -24524,7 +24686,7 @@ var init_resource_paths = __esm({
 });
 
 // apps/desktop/src/attachments/file-input.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function desktopFileAttachments(content2) {
   return content2.flatMap((part) => (desktopFiles.get(part) ?? []).map((file) => ({ ...file })));
 }
@@ -24560,12 +24722,12 @@ function nativeInputFingerprint(value) {
       if (previous?.type === "text") previous.value += part.text;
       else canonical.push({ type: "text", value: part.text });
     } else if (part.type === "image" && typeof (part.url ?? part.image_url) === "string") {
-      canonical.push({ type: "image", value: createHash6("sha256").update(part.url ?? part.image_url).digest("hex") });
+      canonical.push({ type: "image", value: createHash7("sha256").update(part.url ?? part.image_url).digest("hex") });
     } else if (["localImage", "local_image"].includes(String(part.type)) && typeof part.path === "string") {
       canonical.push({ type: "localImage", value: part.path });
     } else return null;
   }
-  return createHash6("sha256").update(JSON.stringify(canonical)).digest("hex");
+  return createHash7("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 function cloneWithNativeInputEvidence(value) {
   const copy2 = structuredClone(value);
@@ -24636,10 +24798,10 @@ var init_response_annotations = __esm({
 });
 
 // apps/desktop/src/attachments/image-identity.ts
-import { createHash as createHash7 } from "node:crypto";
-function unavailableImageId(path55, itemId, partIndex) {
-  const identity6 = itemId ? JSON.stringify([itemId, partIndex ?? null, path55]) : path55;
-  return `unavailable:${createHash7("sha256").update(identity6).digest("hex")}`;
+import { createHash as createHash8 } from "node:crypto";
+function unavailableImageId(path56, itemId, partIndex) {
+  const identity6 = itemId ? JSON.stringify([itemId, partIndex ?? null, path56]) : path56;
+  return `unavailable:${createHash8("sha256").update(identity6).digest("hex")}`;
 }
 var init_image_identity = __esm({
   "apps/desktop/src/attachments/image-identity.ts"() {
@@ -24732,15 +24894,15 @@ function normalizeMessageContent(value, resolveKnownLocalImage, itemId, original
   }
   return content2;
 }
-function userFile(name2, path55) {
+function userFile(name2, path56) {
   const part = { type: "file", name: name2 };
-  userFileSource.set(part, path55);
+  userFileSource.set(part, path56);
   return part;
 }
 function userFileSources(content2 = []) {
   return content2.flatMap((part, index) => {
-    const path55 = userFileSource.get(part);
-    return part.type === "file" && typeof path55 === "string" ? [{ index, path: path55 }] : [];
+    const path56 = userFileSource.get(part);
+    return part.type === "file" && typeof path56 === "string" ? [{ index, path: path56 }] : [];
   });
 }
 function codexImageWrapperFileList(text11) {
@@ -24777,11 +24939,11 @@ function standardCodexImageFileListEntries(fileList) {
       break;
     }
     const name2 = safeCodexFileName(match[1] ?? match[3] ?? "");
-    const path55 = match[2] ?? match[4] ?? "";
-    if (!name2 || !isRecordedResourcePath(path55)) {
+    const path56 = match[2] ?? match[4] ?? "";
+    if (!name2 || !isRecordedResourcePath(path56)) {
       return null;
     }
-    entries.push({ name: name2, path: path55 });
+    entries.push({ name: name2, path: path56 });
     remaining = remaining.slice(match[0].length);
     remaining = remaining.replace(/^Image attachment: true\r?\n/u, "");
   }
@@ -24797,10 +24959,10 @@ function redactCodexImageWrapperPaths(text11) {
   }
   const fileList = wrapper.fileList.replace(
     /(^## [^\r\n]+:[ \t]*\r?\n)[ \t]*([^\r\n]+)/gmu,
-    (all, prefix, path55) => isRecordedResourcePath(path55) ? `${prefix}[\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]` : all
+    (all, prefix, path56) => isRecordedResourcePath(path56) ? `${prefix}[\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]` : all
   ).replace(
     /^(## [^\r\n]+:)[ \t]+([^\r\n]+)$/gmu,
-    (all, prefix, path55) => isRecordedResourcePath(path55) ? `${prefix} [\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]` : all
+    (all, prefix, path56) => isRecordedResourcePath(path56) ? `${prefix} [\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]` : all
   );
   const fileListEnd = wrapper.requestIndex === -1 ? text11.length : wrapper.requestIndex;
   return `${wrapper.prefix}${fileList}${text11.slice(fileListEnd)}`;
@@ -24811,7 +24973,7 @@ function redactKnownCodexWrapperPaths(text11, paths) {
     return text11;
   }
   const fileList = paths.reduce(
-    (result, path55) => result.replaceAll(path55, "[\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]"),
+    (result, path56) => result.replaceAll(path56, "[\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]"),
     wrapper.fileList
   );
   const fileListEnd = wrapper.requestIndex === -1 ? text11.length : wrapper.requestIndex;
@@ -24828,8 +24990,8 @@ function normalizeUserFileMessageContent(value, resolveKnownLocalImage, itemId,
     }
     const localImagePaths = value.flatMap((part) => {
       const record26 = asRecord11(part);
-      const path55 = localImagePath(record26);
-      return path55 === null ? [] : [path55];
+      const path56 = localImagePath(record26);
+      return path56 === null ? [] : [path56];
     });
     const text11 = redactKnownCodexWrapperPaths(
       redactCodexImageWrapperPaths(firstPart2.text),
@@ -24863,9 +25025,9 @@ function normalizeUserFileMessageContent(value, resolveKnownLocalImage, itemId,
   const localImages = value.flatMap((part, index) => {
     const partIndex = originalPartIndices?.[index] ?? index;
     const record26 = asRecord11(part);
-    const path55 = localImagePath(record26);
-    return path55 === null ? [] : [{
-      path: path55,
+    const path56 = localImagePath(record26);
+    return path56 === null ? [] : [{
+      path: path56,
       partIndex,
       image: record26.type === "historyImage" ? historyImageContent(record26, itemId, partIndex) : null
     }];
@@ -24994,8 +25156,8 @@ function redactRawLocalImagePaths(rawItem) {
   let containsLocalImage = false;
   let containsRedactedWrapperPath = false;
   const localImagePaths = item.content.map((part) => asRecord11(part)).flatMap((part) => {
-    const path55 = localImagePath(part);
-    return path55 === null ? [] : [path55];
+    const path56 = localImagePath(part);
+    return path56 === null ? [] : [path56];
   });
   const content2 = item.content.map((part) => {
     const record26 = asRecord11(part);
@@ -25963,8 +26125,8 @@ var init_events = __esm({
         const patches = Array.isArray(change.patches) ? change.patches : [];
         for (const patch of patches) {
           const candidate = objectRecord6(patch);
-          const path55 = Array.isArray(candidate.path) ? candidate.path : [];
-          if ((candidate.op === "add" || candidate.op === "replace") && path55.length === 1 && path55[0] === "threadRuntimeStatus") {
+          const path56 = Array.isArray(candidate.path) ? candidate.path : [];
+          if ((candidate.op === "add" || candidate.op === "replace") && path56.length === 1 && path56[0] === "threadRuntimeStatus") {
             runtimeStatusValue = candidate.value;
           }
         }
@@ -26931,7 +27093,7 @@ var init_device_upload_cache_policy = __esm({
 });
 
 // apps/desktop/src/attachments/device-upload-cache-store.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 async function cacheReadBlock(storage, entry, index, size2) {
   const snapshot2 = await storage.readDocument(entry, 131072);
   const handle = await storage.openContent(entry, { expected: snapshot2.content, match: "object", maxBytes: Math.max(1, size2) });
@@ -26951,12 +27113,12 @@ var init_device_upload_cache_store = __esm({
   "apps/desktop/src/attachments/device-upload-cache-store.ts"() {
     "use strict";
     CACHE_CHUNK_BYTES = 49152;
-    cacheDigest = (bytes3) => createHash8("sha256").update(bytes3).digest("hex");
+    cacheDigest = (bytes3) => createHash9("sha256").update(bytes3).digest("hex");
   }
 });
 
 // apps/desktop/src/attachments/device-upload-cache.ts
-import { randomUUID as randomUUID16, createHash as createHash9 } from "node:crypto";
+import { randomUUID as randomUUID16, createHash as createHash10 } from "node:crypto";
 import { setTimeout as sleep2 } from "node:timers/promises";
 import { z as z9 } from "zod";
 async function createDeviceUploadCache({ storage, now = Date.now, policy = DEVICE_UPLOAD_CACHE_POLICY, admit = async (_bytes, work) => work() }) {
@@ -27028,7 +27190,7 @@ async function createDeviceUploadCache({ storage, now = Date.now, policy = DEVIC
       continue;
     }
     let next = 0;
-    const hash3 = createHash9("sha256");
+    const hash3 = createHash10("sha256");
     for (; next < m.chunks.length; next++) {
       try {
         const b = await cacheReadBlock(storage, handle, next, m.key.byteSize);
@@ -27131,7 +27293,7 @@ async function createDeviceUploadCache({ storage, now = Date.now, policy = DEVIC
     seal: (lease) => serial(async () => {
       const e = owned(lease), m = e.manifest;
       if (m.chunks.length !== Math.ceil(m.key.byteSize / CACHE_CHUNK_BYTES)) throw busy();
-      const hash3 = createHash9("sha256");
+      const hash3 = createHash10("sha256");
       for (let i = 0; i < m.chunks.length; i++) {
         const b = await cacheReadBlock(storage, e.handle, i, m.key.byteSize);
         if (cacheDigest(b) !== m.chunks[i]) throw busy();
@@ -27967,13 +28129,13 @@ var init_upload_task_store = __esm({
 import { execFile as execFile7 } from "node:child_process";
 import { constants as constants2 } from "node:fs";
 import { lstat, open } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 function limit(max) {
   if (!Number.isSafeInteger(max) || max < 1 || max > 50 * 1024 * 1024) throw new PrivateBinaryFileError("capacity");
 }
 function resolved2(file) {
   try {
-    return windows() ? localWindowsPath(file) : path24.resolve(file);
+    return windows() ? localWindowsPath(file) : path25.resolve(file);
   } catch {
     throw unavailable2();
   }
@@ -28016,7 +28178,7 @@ async function windowsMode(file, seal = false) {
   return output;
 }
 async function parentIdentity(file) {
-  const directory = path24.dirname(file), initial = await lstat(directory, { bigint: true });
+  const directory = path25.dirname(file), initial = await lstat(directory, { bigint: true });
   if (!initial.isDirectory() || initial.isSymbolicLink()) throw unavailable2();
   if (windows()) {
     try {
@@ -28083,10 +28245,10 @@ async function openFile(file, options) {
     let tail = Promise.resolve();
     async function guard() {
       if (closed || poisoned) throw unavailable2();
-      const held = await h.stat({ bigint: true }), current2 = await lstat(file, { bigint: true }), directory = await lstat(path24.dirname(file), { bigint: true });
+      const held = await h.stat({ bigint: true }), current2 = await lstat(file, { bigint: true }), directory = await lstat(path25.dirname(file), { bigint: true });
       if (!trusted2(held) || !trusted2(current2) || !same3(held, baseline) || !sameSnapshot(held, current2) || !same3(parent, directory) || !directory.isDirectory() || directory.isSymbolicLink() || held.size > BigInt(options.maxBytes) || (!options.writable || mode === "immutable") && !sameSnapshot(baseline, held)) throw unavailable2();
       if (!windows() && posixMode(held) !== mode) throw unavailable2();
-      if (!windows()) privateLogFiles.checkDirectory(path24.dirname(file));
+      if (!windows()) privateLogFiles.checkDirectory(path25.dirname(file));
     }
     await guard();
     checkExpected(await status(h), options);
@@ -28223,11 +28385,11 @@ if($env:NIUMA_BINARY_SEAL -eq '1' -and $mode -ne 'immutable') {
           handle = await open(file, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | (windows() ? 0 : constants2.O_NOFOLLOW), 384);
           if (!windows()) await handle.chmod(384);
           const held = await handle.stat({ bigint: true }), current2 = await lstat(file, { bigint: true });
-          if (!trusted2(held) || !sameSnapshot(held, current2) || !same3(parent, await lstat(path24.dirname(file), { bigint: true }))) throw unavailable2();
+          if (!trusted2(held) || !sameSnapshot(held, current2) || !same3(parent, await lstat(path25.dirname(file), { bigint: true }))) throw unavailable2();
           if (windows() && await windowsMode(file) !== "mutable") throw unavailable2();
           await handle.sync();
           const result = await status(handle);
-          if (!sameSnapshot(await handle.stat({ bigint: true }), await lstat(file, { bigint: true })) || !same3(parent, await lstat(path24.dirname(file), { bigint: true }))) throw unavailable2();
+          if (!sameSnapshot(await handle.stat({ bigint: true }), await lstat(file, { bigint: true })) || !same3(parent, await lstat(path25.dirname(file), { bigint: true }))) throw unavailable2();
           await handle.close();
           handle = void 0;
           return result;
@@ -28327,7 +28489,7 @@ import { randomUUID as randomUUID18 } from "node:crypto";
 import { execFile as execFile9 } from "node:child_process";
 import { constants as constants3 } from "node:fs";
 import { chmod, lstat as lstat3, mkdir, open as open2, readdir, rename, rm } from "node:fs/promises";
-import path25 from "node:path";
+import path26 from "node:path";
 function nameOnly(name2) {
   if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/u.test(name2)) throw unavailable3();
 }
@@ -28336,7 +28498,7 @@ function budget(maxBytes) {
 }
 async function openDirectories(requested, windowsCandidate) {
   const windows2 = process.platform === "win32";
-  const root = windows2 ? localWindowsPath(requested) : path25.resolve(requested);
+  const root = windows2 ? localWindowsPath(requested) : path26.resolve(requested);
   let rootIdentity;
   try {
     if (windows2) await ensureWindowsPrivateDirectoryAsync(root);
@@ -28381,7 +28543,7 @@ async function openDirectories(requested, windowsCandidate) {
   }
   function token3(value) {
     const directory = Object.freeze({ get sourcePath() {
-      return path25.join(value.path, "source");
+      return path26.join(value.path, "source");
     } });
     records.set(directory, value);
     return directory;
@@ -28437,7 +28599,7 @@ async function openDirectories(requested, windowsCandidate) {
       return serial(async () => {
         nameOnly(name2);
         await guard();
-        const directory = path25.join(root, name2);
+        const directory = path26.join(root, name2);
         if (!windows2) privateLogFiles.checkDirectory(directory);
         const identity6 = await lstat3(directory, { bigint: true });
         const result = token3({ name: name2, path: directory, identity: identity6, staged: false, pending: true, ready: true });
@@ -28450,7 +28612,7 @@ async function openDirectories(requested, windowsCandidate) {
         mutable();
         nameOnly(name2);
         await guard();
-        const directory = path25.join(root, ".pending-" + name2);
+        const directory = path26.join(root, ".pending-" + name2);
         await mkdir(directory, { mode: 448 });
         const identity6 = await lstat3(directory, { bigint: true });
         if (windows2) {
@@ -28480,7 +28642,7 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
       return serial(async () => {
         budget(maxBytes);
         await guard(directory);
-        const handle = await privateBinaryFiles.open(path25.join(record26(directory).path, "manifest.json"), { maxBytes, mode: "mutable" });
+        const handle = await privateBinaryFiles.open(path26.join(record26(directory).path, "manifest.json"), { maxBytes, mode: "mutable" });
         let failed = false;
         const bytes3 = Buffer.alloc(maxBytes);
         try {
@@ -28529,7 +28691,7 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
         async function currentManifest() {
           let stats;
           try {
-            stats = await lstat3(path25.join(value.path, "manifest.json"), { bigint: true });
+            stats = await lstat3(path26.join(value.path, "manifest.json"), { bigint: true });
           } catch (error2) {
             if (error2.code === "ENOENT") return null;
             throw error2;
@@ -28537,7 +28699,7 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
           if (!stats.isFile() || stats.isSymbolicLink() || stats.nlink !== 1n || !windows2 && (stats.uid !== BigInt(process.getuid()) || (stats.mode & 0o777n) !== 0o600n)) throw unavailable3();
           if (stats.size > BigInt(maxBytes)) throw new PrivateUploadDirectoryError("capacity");
           if (windows2) {
-            const handle = await privateBinaryFiles.open(path25.join(value.path, "manifest.json"), {
+            const handle = await privateBinaryFiles.open(path26.join(value.path, "manifest.json"), {
               maxBytes,
               mode: "mutable",
               match: "object",
@@ -28554,13 +28716,13 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
             } finally {
               await handle.close();
             }
-            const after = await lstat3(path25.join(value.path, "manifest.json"), { bigint: true });
+            const after = await lstat3(path26.join(value.path, "manifest.json"), { bigint: true });
             if (!same4(stats, after) || stats.size !== after.size || stats.mtimeNs !== after.mtimeNs || stats.ctimeNs !== after.ctimeNs) throw unavailable3();
           }
           return stats;
         }
         const original = await currentManifest();
-        const temporary = path25.join(value.path, ".manifest-" + randomUUID18());
+        const temporary = path26.join(value.path, ".manifest-" + randomUUID18());
         let created = false, published = false, identity6;
         try {
           if (windows2) {
@@ -28615,7 +28777,7 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
           if (!identity6 || !same4(identity6, current2) || !current2.isFile() || current2.isSymbolicLink() || current2.nlink !== 1n || !windows2 && (current2.uid !== BigInt(process.getuid()) || (current2.mode & 0o777n) !== 0o600n)) throw unavailable3();
           const previous = await currentManifest();
           if (original === null ? previous !== null : previous === null || !same4(original, previous) || original.size !== previous.size || original.mtimeNs !== previous.mtimeNs || original.ctimeNs !== previous.ctimeNs) throw unavailable3();
-          await rename(temporary, path25.join(value.path, "manifest.json"));
+          await rename(temporary, path26.join(value.path, "manifest.json"));
           published = true;
           created = false;
           value.pending = true;
@@ -28652,7 +28814,7 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
         const value = record26(directory);
         if (!value.staged || !value.ready) throw unavailable3();
         await finish(directory);
-        const target = path25.join(root, value.name);
+        const target = path26.join(root, value.name);
         try {
           await lstat3(target);
           throw unavailable3();
@@ -28727,7 +28889,7 @@ var init_private_upload_content_types = __esm({
 });
 
 // apps/desktop/src/platform/legacy-upload-contents.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 async function using(handle, operation) {
   let failed = false;
   try {
@@ -29030,14 +29192,14 @@ var init_legacy_upload_contents = __esm({
     init_private_binary_files();
     init_private_upload_directories();
     init_private_upload_content_types();
-    revision = (body) => body === null ? "empty" : createHash10("sha256").update(body).digest("hex");
+    revision = (body) => body === null ? "empty" : createHash11("sha256").update(body).digest("hex");
     unavailable4 = () => new PrivateUploadContentError("unavailable");
   }
 });
 
 // apps/desktop/src/daemon/runtime/attachment-access.ts
-import { createHash as createHash11 } from "node:crypto";
-import path26 from "node:path";
+import { createHash as createHash12 } from "node:crypto";
+import path27 from "node:path";
 import process2 from "node:process";
 var RuntimeAttachmentAccess;
 var init_attachment_access = __esm({
@@ -29075,7 +29237,7 @@ var init_attachment_access = __esm({
         const cached = createCachedUploadTaskStore({
           base,
           cache: () => cache2 ??= (async () => {
-            const root = path26.join(this.ports.options().niumaDataDirectory ?? desktopPlatform().directories.data, "attachments", "device-cache");
+            const root = path27.join(this.ports.options().niumaDataDirectory ?? desktopPlatform().directories.data, "attachments", "device-cache");
             return createDeviceUploadCache({
               storage: composeLegacyUploadContents(await openPrivateUploadDirectories(root), privateBinaryFiles),
               admit: (bytes3, operation) => this.ports.attachmentStorage().withAttachmentUploadAdmission(void 0, bytes3, operation)
@@ -29170,7 +29332,7 @@ var init_attachment_access = __esm({
       captureFileResourceSource(threadId2) {
         const generation = this.ports.lifecycle().runtimeGenerationValue, resources = this.ports.projection().resources, viewStore = this.ports.projection().store;
         const source2 = viewStore.getOrderSource(threadId2);
-        const projectFingerprint = () => createHash11("sha256").update(this.ports.catalog().storeValue.getThread(threadId2, { tailCount: 0 })?.projectRoot ?? "").digest("hex");
+        const projectFingerprint = () => createHash12("sha256").update(this.ports.catalog().storeValue.getThread(threadId2, { tailCount: 0 })?.projectRoot ?? "").digest("hex");
         const project3 = projectFingerprint();
         const appGeneration = this.ports.appServerLoads().connectionGeneration, ipcGeneration = this.ports.desktopSession().ipcConnectionGenerationValue;
         const appAuthority = this.ports.appProjection().authorityFor(threadId2);
@@ -29218,8 +29380,8 @@ var init_attachment_access = __esm({
 });
 
 // apps/desktop/src/niuma/project-state.ts
-import fs17 from "node:fs/promises";
-import path27 from "node:path";
+import fs18 from "node:fs/promises";
+import path28 from "node:path";
 import { z as z10 } from "zod";
 function emptyProjectState() {
   return {
@@ -29288,9 +29450,9 @@ function isMissingFileError(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
 }
 async function readProjectState(codexHome) {
-  const statePath = path27.join(codexHome, ".codex-global-state.json");
+  const statePath = path28.join(codexHome, ".codex-global-state.json");
   try {
-    const raw = await fs17.readFile(statePath, "utf8");
+    const raw = await fs18.readFile(statePath, "utf8");
     const parsed = RawProjectStateSchema.parse(JSON.parse(raw));
     const localProjects = readLocalProjects(parsed["local-projects"]);
     const rootsByProjectId = new Map(localProjects.map((project3) => [project3.id, project3.root]));
@@ -29383,7 +29545,7 @@ var init_project_state = __esm({
 });
 
 // apps/desktop/src/niuma/session-originator.ts
-import fs18 from "node:fs/promises";
+import fs19 from "node:fs/promises";
 function record9(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -29400,7 +29562,7 @@ async function readFirstLine(filePath) {
   let byteCount = 0;
   let position = 0;
   try {
-    handle = await fs18.open(filePath, "r");
+    handle = await fs19.open(filePath, "r");
     while (true) {
       const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
       const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
@@ -29496,7 +29658,7 @@ var init_session_originator = __esm({
 });
 
 // apps/desktop/src/niuma/session-timestamps.ts
-import fs19 from "node:fs/promises";
+import fs20 from "node:fs/promises";
 import { createInterface as createInterface2 } from "node:readline";
 function record10(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -29782,7 +29944,7 @@ var init_session_timestamps = __esm({
         try {
           const sessionPath = explicitPath === void 0 ? await this.resolveSessionPath(threadId2) : explicitPath;
           if (!sessionPath || this.closed) return "unavailable";
-          const stat3 = await fs19.stat(sessionPath);
+          const stat3 = await fs20.stat(sessionPath);
           if (this.closed) return "unavailable";
           return JSON.stringify([stat3.dev, stat3.ino, stat3.size, stat3.mtimeMs, stat3.ctimeMs]);
         } catch {
@@ -29955,7 +30117,7 @@ var init_session_timestamps = __esm({
         }
       }
       async readReplay(sessionPath, threadId2, fingerprint2, empty) {
-        const handle = await fs19.open(sessionPath, "r");
+        const handle = await fs20.open(sessionPath, "r");
         if (this.closed) {
           await handle.close();
           return empty;
@@ -30550,7 +30712,7 @@ var init_app_server_upgrade = __esm({
 
 // apps/desktop/src/daemon/codex-subagent-avatars.ts
 import { open as open3 } from "node:fs/promises";
-import path28 from "node:path";
+import path29 from "node:path";
 import sharp from "sharp";
 function record11(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -30591,7 +30753,7 @@ async function parseCatalog(source2, readAsset) {
   }
   return new CodexSubagentAvatars(images);
 }
-async function loadCodexSubagentAvatars(archivePath = path28.join(path28.dirname(resolveDefaultAppServerExecutablePath()), "app.asar")) {
+async function loadCodexSubagentAvatars(archivePath = path29.join(path29.dirname(resolveDefaultAppServerExecutablePath()), "app.asar")) {
   let file;
   try {
     file = await open3(archivePath, "r");
@@ -30658,8 +30820,8 @@ var init_codex_subagent_avatars = __esm({
 });
 
 // apps/desktop/src/platform/private-document-files.ts
-import fs20 from "node:fs";
-import path29 from "node:path";
+import fs21 from "node:fs";
+import path30 from "node:path";
 import { randomUUID as randomUUID20 } from "node:crypto";
 function checkLimit(maxBytes) {
   if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 32 * 1024 * 1024) throw new PrivateDocumentFileError("capacity");
@@ -30671,7 +30833,7 @@ function trusted3(stats, directory = false, strictDirectory = false) {
 }
 function statFile(file, maxBytes) {
   try {
-    const stats = fs20.lstatSync(file, { bigint: true });
+    const stats = fs21.lstatSync(file, { bigint: true });
     if (!trusted3(stats)) throw new PrivateDocumentFileError("unavailable");
     if (stats.size > BigInt(maxBytes)) throw new PrivateDocumentFileError("capacity");
     return stats;
@@ -30691,33 +30853,33 @@ function readPosix(file, maxBytes, strictDirectory) {
   let directoryFd;
   let fd;
   try {
-    const directory = path29.dirname(file);
+    const directory = path30.dirname(file);
     let parent;
     try {
-      parent = fs20.lstatSync(directory, { bigint: true });
+      parent = fs21.lstatSync(directory, { bigint: true });
     } catch (error2) {
       if (missing(error2)) return null;
       throw error2;
     }
     if (!trusted3(parent, true, strictDirectory)) throw new PrivateDocumentFileError("unavailable");
-    directoryFd = fs20.openSync(directory, fs20.constants.O_RDONLY | fs20.constants.O_NOFOLLOW);
-    if (!same5(parent, fs20.fstatSync(directoryFd, { bigint: true }))) throw new PrivateDocumentFileError("unavailable");
+    directoryFd = fs21.openSync(directory, fs21.constants.O_RDONLY | fs21.constants.O_NOFOLLOW);
+    if (!same5(parent, fs21.fstatSync(directoryFd, { bigint: true }))) throw new PrivateDocumentFileError("unavailable");
     const original = statFile(file, maxBytes);
     if (original === null) return null;
-    fd = fs20.openSync(file, fs20.constants.O_RDONLY | fs20.constants.O_NOFOLLOW);
-    const opened = fs20.fstatSync(fd, { bigint: true });
+    fd = fs21.openSync(file, fs21.constants.O_RDONLY | fs21.constants.O_NOFOLLOW);
+    const opened = fs21.fstatSync(fd, { bigint: true });
     if (!trusted3(opened) || !same5(original, opened) || original.size !== opened.size) throw new PrivateDocumentFileError("unavailable");
     const contents = Buffer.alloc(maxBytes + 1);
     try {
       let length = 0;
       while (length < contents.length) {
-        const count = fs20.readSync(fd, contents, length, contents.length - length, null);
+        const count = fs21.readSync(fd, contents, length, contents.length - length, null);
         if (count === 0) break;
         length += count;
       }
       if (length > maxBytes) throw new PrivateDocumentFileError("capacity");
       const current2 = statFile(file, maxBytes);
-      if (current2 === null || !same5(original, current2) || !same5(parent, fs20.lstatSync(directory, { bigint: true }))) {
+      if (current2 === null || !same5(original, current2) || !same5(parent, fs21.lstatSync(directory, { bigint: true }))) {
         throw new PrivateDocumentFileError("unavailable");
       }
       return decode(contents.subarray(0, length));
@@ -30726,42 +30888,42 @@ function readPosix(file, maxBytes, strictDirectory) {
     }
   } finally {
     try {
-      if (fd !== void 0) fs20.closeSync(fd);
+      if (fd !== void 0) fs21.closeSync(fd);
     } finally {
-      if (directoryFd !== void 0) fs20.closeSync(directoryFd);
+      if (directoryFd !== void 0) fs21.closeSync(directoryFd);
     }
   }
 }
 function writePosix(file, body, maxBytes, strictDirectory) {
-  const directory = path29.dirname(file);
-  const temporary = path29.join(directory, `.${path29.basename(file)}.${randomUUID20()}.tmp`);
+  const directory = path30.dirname(file);
+  const temporary = path30.join(directory, `.${path30.basename(file)}.${randomUUID20()}.tmp`);
   let directoryFd;
   let fd;
   let created = false;
   let renamed = false;
   try {
-    fs20.mkdirSync(directory, { recursive: true, mode: 448 });
-    const parent = fs20.lstatSync(directory, { bigint: true });
+    fs21.mkdirSync(directory, { recursive: true, mode: 448 });
+    const parent = fs21.lstatSync(directory, { bigint: true });
     if (!trusted3(parent, true, strictDirectory)) throw new PrivateDocumentFileError("unavailable");
-    directoryFd = fs20.openSync(directory, fs20.constants.O_RDONLY | fs20.constants.O_NOFOLLOW);
-    if (!same5(parent, fs20.fstatSync(directoryFd, { bigint: true }))) throw new PrivateDocumentFileError("unavailable");
+    directoryFd = fs21.openSync(directory, fs21.constants.O_RDONLY | fs21.constants.O_NOFOLLOW);
+    if (!same5(parent, fs21.fstatSync(directoryFd, { bigint: true }))) throw new PrivateDocumentFileError("unavailable");
     const original = statFile(file, maxBytes);
-    fd = fs20.openSync(temporary, fs20.constants.O_WRONLY | fs20.constants.O_CREAT | fs20.constants.O_EXCL | fs20.constants.O_NOFOLLOW, 384);
+    fd = fs21.openSync(temporary, fs21.constants.O_WRONLY | fs21.constants.O_CREAT | fs21.constants.O_EXCL | fs21.constants.O_NOFOLLOW, 384);
     created = true;
-    const temporaryIdentity = fs20.fstatSync(fd, { bigint: true });
+    const temporaryIdentity = fs21.fstatSync(fd, { bigint: true });
     if (!trusted3(temporaryIdentity)) throw new PrivateDocumentFileError("unavailable");
-    fs20.writeFileSync(fd, body);
-    fs20.fsyncSync(fd);
-    fs20.closeSync(fd);
+    fs21.writeFileSync(fd, body);
+    fs21.fsyncSync(fd);
+    fs21.closeSync(fd);
     fd = void 0;
     const current2 = statFile(file, maxBytes);
-    if (!same5(parent, fs20.lstatSync(directory, { bigint: true })) || !same5(temporaryIdentity, fs20.lstatSync(temporary, { bigint: true })) || (original === null ? current2 !== null : current2 === null || !same5(original, current2))) {
+    if (!same5(parent, fs21.lstatSync(directory, { bigint: true })) || !same5(temporaryIdentity, fs21.lstatSync(temporary, { bigint: true })) || (original === null ? current2 !== null : current2 === null || !same5(original, current2))) {
       throw new PrivateDocumentFileError("unavailable");
     }
-    fs20.renameSync(temporary, file);
+    fs21.renameSync(temporary, file);
     renamed = true;
     created = false;
-    fs20.fsyncSync(directoryFd);
+    fs21.fsyncSync(directoryFd);
   } catch (error2) {
     if (error2 instanceof PrivateDocumentFileError && !renamed) throw error2;
     throw new PrivateDocumentFileError("write_failed", renamed);
@@ -30769,7 +30931,7 @@ function writePosix(file, body, maxBytes, strictDirectory) {
     try {
       if (fd !== void 0) {
         try {
-          fs20.closeSync(fd);
+          fs21.closeSync(fd);
         } catch {
         }
       }
@@ -30777,14 +30939,14 @@ function writePosix(file, body, maxBytes, strictDirectory) {
       try {
         if (directoryFd !== void 0) {
           try {
-            fs20.closeSync(directoryFd);
+            fs21.closeSync(directoryFd);
           } catch {
           }
         }
       } finally {
         if (created) {
           try {
-            fs20.unlinkSync(temporary);
+            fs21.unlinkSync(temporary);
           } catch {
           }
         }
@@ -30818,7 +30980,7 @@ async function windowsDocument(file, maxBytes, body) {
   return result;
 }
 function serialFile(file, operation) {
-  const absolute = path29.resolve(file);
+  const absolute = path30.resolve(file);
   const key = desktopPlatform().id === "windows" ? absolute.toLowerCase() : absolute;
   const result = (operations.get(key) ?? Promise.resolve()).then(operation);
   const tail = result.then(() => {
@@ -30836,7 +30998,7 @@ function documentFiles(strictDirectory, guard) {
       return serialFile(file, async () => {
         try {
           guard?.();
-          const body = desktopPlatform().id === "windows" ? await windowsDocument(file, maxBytes) : readPosix(path29.resolve(file), maxBytes, strictDirectory);
+          const body = desktopPlatform().id === "windows" ? await windowsDocument(file, maxBytes) : readPosix(path30.resolve(file), maxBytes, strictDirectory);
           guard?.();
           return body;
         } catch (error2) {
@@ -30851,7 +31013,7 @@ function documentFiles(strictDirectory, guard) {
       await serialFile(file, async () => {
         guard?.();
         if (desktopPlatform().id === "windows") await windowsDocument(file, maxBytes, body);
-        else writePosix(path29.resolve(file), body, maxBytes, strictDirectory);
+        else writePosix(path30.resolve(file), body, maxBytes, strictDirectory);
         try {
           guard?.();
         } catch {
@@ -30890,7 +31052,7 @@ var init_private_document_files = __esm({
 });
 
 // apps/desktop/src/local-state/paths.ts
-import path30 from "node:path";
+import path31 from "node:path";
 function applicationStateDirectory() {
   return desktopPlatform().directories.state;
 }
@@ -30898,37 +31060,37 @@ function cliCacheDirectory() {
   return desktopPlatform().directories.cliCache;
 }
 function managedThreadsStatePath() {
-  return path30.join(applicationStateDirectory(), "managed-threads-v1.json");
+  return path31.join(applicationStateDirectory(), "managed-threads-v1.json");
 }
 function threadSettingsStatePath() {
-  return path30.join(applicationStateDirectory(), "thread-settings-cache-v1.json");
+  return path31.join(applicationStateDirectory(), "thread-settings-cache-v1.json");
 }
 function threadListStatePath() {
-  return path30.join(applicationStateDirectory(), "thread-list-cache-v1.json");
+  return path31.join(applicationStateDirectory(), "thread-list-cache-v1.json");
 }
 function daemonMetricsStatePath() {
-  return path30.join(applicationStateDirectory(), "daemon-metrics-v1.json");
+  return path31.join(applicationStateDirectory(), "daemon-metrics-v1.json");
 }
 function desktopIdentityCandidatesStatePath() {
-  return path30.join(applicationStateDirectory(), "desktop-identity-candidates-v1.json");
+  return path31.join(applicationStateDirectory(), "desktop-identity-candidates-v1.json");
 }
 function pendingRequestsCachePath() {
-  return path30.join(cliCacheDirectory(), "pending-requests-v1.json");
+  return path31.join(cliCacheDirectory(), "pending-requests-v1.json");
 }
 function idempotencyCachePath() {
-  return path30.join(cliCacheDirectory(), "idempotency-v1.json");
+  return path31.join(cliCacheDirectory(), "idempotency-v1.json");
 }
 function messageSubmissionsStatePath() {
-  return path30.join(applicationStateDirectory(), "message-submissions-v1.json");
+  return path31.join(applicationStateDirectory(), "message-submissions-v1.json");
 }
 function deviceNameStatePath() {
-  return path30.join(applicationStateDirectory(), "device-name-v1.json");
+  return path31.join(applicationStateDirectory(), "device-name-v1.json");
 }
 function threadReadReceiptsStatePath() {
-  return path30.join(applicationStateDirectory(), "thread-read-receipts-v1.json");
+  return path31.join(applicationStateDirectory(), "thread-read-receipts-v1.json");
 }
 function asyncQuestionFactsStatePath() {
-  return path30.join(applicationStateDirectory(), "async-question-facts", "ledger-v1.json");
+  return path31.join(applicationStateDirectory(), "async-question-facts", "ledger-v1.json");
 }
 var init_paths2 = __esm({
   "apps/desktop/src/local-state/paths.ts"() {
@@ -32534,7 +32696,7 @@ var init_thread_timeline_cache = __esm({
 });
 
 // apps/desktop/src/daemon/thread-state-store.ts
-import path31 from "node:path";
+import path32 from "node:path";
 function projectRecency(entry) {
   return entry.threads.reduce(
     (latest, thread4) => Math.max(latest, thread4.recencyAt ?? thread4.updatedAt),
@@ -32643,8 +32805,8 @@ function normalizePathForCompare(value) {
   if (!value) {
     return "";
   }
-  const normalized = path31.normalize(value);
-  if (normalized.length > 1 && normalized.endsWith(path31.sep)) {
+  const normalized = path32.normalize(value);
+  if (normalized.length > 1 && normalized.endsWith(path32.sep)) {
     return normalized.slice(0, -1);
   }
   return normalized;
@@ -32669,7 +32831,7 @@ function isPathWithinRoot(cwd, root) {
   if (normalizedCwd === normalizedRoot) {
     return true;
   }
-  return normalizedCwd.startsWith(`${normalizedRoot}${path31.sep}`);
+  return normalizedCwd.startsWith(`${normalizedRoot}${path32.sep}`);
 }
 function findLongestMatchingRoot(cwd, roots) {
   let matched = null;
@@ -32692,7 +32854,7 @@ function labelForRoot(root, labels) {
     };
   }
   return {
-    projectName: path31.basename(root) || root,
+    projectName: path32.basename(root) || root,
     projectNameSource: "basename"
   };
 }
@@ -34200,10 +34362,10 @@ var init_bootstrap = __esm({
 });
 
 // apps/desktop/src/platform/private-cache-files.ts
-import fs21 from "node:fs";
-import path32 from "node:path";
+import fs22 from "node:fs";
+import path33 from "node:path";
 function serialize(file, operation) {
-  const key = process.platform === "win32" ? path32.resolve(file).toLowerCase() : path32.resolve(file);
+  const key = process.platform === "win32" ? path33.resolve(file).toLowerCase() : path33.resolve(file);
   const next = (tails.get(key) ?? Promise.resolve()).then(operation);
   const tail = next.catch(() => {
   });
@@ -34218,23 +34380,23 @@ function trusted4(stat3, directory = false) {
   return uid !== void 0 && stat3.uid === BigInt(uid) && (directory ? stat3.isDirectory() && (stat3.mode & 0o777n) === 0o700n : stat3.isFile() && stat3.nlink === 1n && (stat3.mode & 0o777n) === 0o600n);
 }
 async function withMacLock(file, operation) {
-  const directory = path32.dirname(file);
-  const lock = path32.join(directory, `.${path32.basename(file)}.lock`);
-  fs21.mkdirSync(directory, { recursive: true, mode: 448 });
-  const parent = fs21.lstatSync(directory, { bigint: true });
+  const directory = path33.dirname(file);
+  const lock = path33.join(directory, `.${path33.basename(file)}.lock`);
+  fs22.mkdirSync(directory, { recursive: true, mode: 448 });
+  const parent = fs22.lstatSync(directory, { bigint: true });
   if (!trusted4(parent, true)) throw new PrivateDocumentFileError("unavailable");
   const deadline = Date.now() + LOCK_WAIT_MS;
   let fd;
   for (; ; ) {
     let initial = null;
     try {
-      initial = fs21.lstatSync(lock, { bigint: true });
+      initial = fs22.lstatSync(lock, { bigint: true });
     } catch (error2) {
       if (error2.code !== "ENOENT") throw error2;
     }
     if (initial && !trusted4(initial)) throw new PrivateDocumentFileError("unavailable");
     try {
-      fd = fs21.openSync(lock, fs21.constants.O_RDWR | fs21.constants.O_CREAT | fs21.constants.O_NOFOLLOW | fs21.constants.O_NONBLOCK | 32, 384);
+      fd = fs22.openSync(lock, fs22.constants.O_RDWR | fs22.constants.O_CREAT | fs22.constants.O_NOFOLLOW | fs22.constants.O_NONBLOCK | 32, 384);
     } catch (error2) {
       const code = error2.code;
       if (code !== "EAGAIN" && code !== "EWOULDBLOCK" || Date.now() >= deadline) throw error2;
@@ -34242,10 +34404,10 @@ async function withMacLock(file, operation) {
       continue;
     }
     try {
-      const opened = fs21.fstatSync(fd, { bigint: true });
+      const opened = fs22.fstatSync(fd, { bigint: true });
       const verify = () => {
-        const current2 = fs21.lstatSync(lock, { bigint: true });
-        const currentParent = fs21.lstatSync(directory, { bigint: true });
+        const current2 = fs22.lstatSync(lock, { bigint: true });
+        const currentParent = fs22.lstatSync(directory, { bigint: true });
         if (!trusted4(opened) || !trusted4(current2) || !same6(opened, current2) || initial !== null && !same6(initial, opened) || !trusted4(currentParent, true) || !same6(parent, currentParent)) {
           throw new PrivateDocumentFileError("unavailable");
         }
@@ -34255,7 +34417,7 @@ async function withMacLock(file, operation) {
       verify();
       return value;
     } finally {
-      fs21.closeSync(fd);
+      fs22.closeSync(fd);
     }
   }
 }
@@ -34286,7 +34448,7 @@ var init_private_cache_files = __esm({
         return serialize(file, async () => {
           checkLimit2(maxBytes);
           try {
-            fs21.lstatSync(file);
+            fs22.lstatSync(file);
           } catch (error2) {
             if (error2.code === "ENOENT") return null;
             throw error2;
@@ -34299,7 +34461,7 @@ var init_private_cache_files = __esm({
           checkLimit2(maxBytes);
           if (process.platform === "win32") return windowsTransaction(file, maxBytes, transform);
           if (process.platform !== "darwin") throw new PrivateDocumentFileError("unavailable");
-          return withMacLock(path32.resolve(file), async (verify) => {
+          return withMacLock(path33.resolve(file), async (verify) => {
             const result = transform(await privateStateFiles.read(file, maxBytes));
             verify();
             if (result.body !== void 0) await privateStateFiles.write(file, Buffer.from(result.body), maxBytes);
@@ -34583,7 +34745,7 @@ var init_pending_cache = __esm({
 });
 
 // apps/desktop/src/niuma/session-pending.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 function objectRecord7(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -34606,7 +34768,7 @@ function inferPendingRequestFromSession(threadId2, sessionPath, latestTurnId = n
   }
   let lines;
   try {
-    lines = fs22.readFileSync(sessionPath, "utf8").trimEnd().split(/\n/).filter(Boolean);
+    lines = fs23.readFileSync(sessionPath, "utf8").trimEnd().split(/\n/).filter(Boolean);
   } catch {
     return null;
   }
@@ -35349,8 +35511,8 @@ var init_catalog = __esm({
 });
 
 // apps/desktop/src/direct-gateway/v5-binding-store.ts
-import { randomUUID as randomUUID21, createHash as createHash12 } from "node:crypto";
-import path33 from "node:path";
+import { randomUUID as randomUUID21, createHash as createHash13 } from "node:crypto";
+import path34 from "node:path";
 function bindingFileError() {
   return new Error("Desktop V5 Binding \u6587\u4EF6\u65E0\u6548");
 }
@@ -35484,7 +35646,7 @@ function parseResetMarker(value, desktopId) {
   }
 }
 function resolveDefaultDesktopV5BindingFilePath() {
-  return path33.join(desktopPlatform().directories.data, DEFAULT_FILE_NAME);
+  return path34.join(desktopPlatform().directories.data, DEFAULT_FILE_NAME);
 }
 function pushDisplayName(name2) {
   let result = "";
@@ -35551,7 +35713,7 @@ var init_v5_binding_store = __esm({
         for (const wake of this.pushWaiters) wake();
       }
       constructor(options = {}) {
-        this.filePath = path33.resolve(options.file_path ?? resolveDefaultDesktopV5BindingFilePath());
+        this.filePath = path34.resolve(options.file_path ?? resolveDefaultDesktopV5BindingFilePath());
         this.files = options.files ?? privateDocumentFiles;
       }
       async load(desktopId) {
@@ -35614,7 +35776,7 @@ var init_v5_binding_store = __esm({
           revision: this.presence.revision,
           grants: this.presence.grants.map((row) => ({
             grant_id: row.grant.grant_id,
-            token_sha256: createHash12("sha256").update(row.grant.token, "utf8").digest("base64url"),
+            token_sha256: createHash13("sha256").update(row.grant.token, "utf8").digest("base64url"),
             binding_id: row.binding_id,
             generation: row.generation,
             expires_at: row.grant.expires_at
@@ -35801,7 +35963,7 @@ var init_v5_binding_store = __esm({
         await this.writeAtomicFile(this.resetMarkerPath(), serializeResetMarker(desktopId), bindingFileError);
       }
       resetMarkerPath() {
-        return path33.join(path33.dirname(this.filePath), RESET_MARKER_FILE_NAME);
+        return path34.join(path34.dirname(this.filePath), RESET_MARKER_FILE_NAME);
       }
       async writeAtomicFile(targetPath, body, failure) {
         try {
@@ -35932,7 +36094,7 @@ var init_desktop_service = __esm({
 });
 
 // apps/desktop/src/presence/server-client.ts
-import { createHash as createHash13, randomBytes as randomBytes5, randomUUID as randomUUID22 } from "node:crypto";
+import { createHash as createHash14, randomBytes as randomBytes5, randomUUID as randomUUID22 } from "node:crypto";
 var PresenceServerClient;
 var init_server_client2 = __esm({
   "apps/desktop/src/presence/server-client.ts"() {
@@ -35955,14 +36117,14 @@ var init_server_client2 = __esm({
         if (snapshot2.desktop_id !== this.identity.desktop_id || snapshot2.public_key !== encodeBase64Url(this.identity.identity_public_key)) throw new HttpApiError(200, 200004, "\u65E0\u6743\u9650\u8BBF\u95EE");
         const body = JSON.stringify(snapshot2), pathname = "/api/v1/presence/desktops/grants/sync";
         if (Buffer.byteLength(body) > 65536) throw new HttpApiError(200, 900608, "\u8BBE\u5907\u72B6\u6001\u67E5\u8BE2\u9891\u7387\u6216\u5BB9\u91CF\u8D85\u9650");
-        const key_id = createHash13("sha256").update(this.identity.identity_public_key).digest("base64url");
+        const key_id = createHash14("sha256").update(this.identity.identity_public_key).digest("base64url");
         const operation_id = randomUUID22(), nonce = encodeBase64Url(randomBytes5(32)), timestamp = Math.floor(Date.now() / 1e3);
         const bytes3 = createPresenceSigningBytes({
           audience: this.origin,
           method: "POST",
           pathname,
           query: {},
-          body_sha256: createHash13("sha256").update(body).digest("base64url"),
+          body_sha256: createHash14("sha256").update(body).digest("base64url"),
           key_id,
           operation_id,
           timestamp,
@@ -36111,7 +36273,7 @@ var init_binding_sync = __esm({
 });
 
 // apps/desktop/src/notifications/desktop-service.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 var DesktopNotificationService;
 var init_desktop_service2 = __esm({
   "apps/desktop/src/notifications/desktop-service.ts"() {
@@ -36147,7 +36309,7 @@ var init_desktop_service2 = __esm({
         if (remaining <= 0) throw new NotificationTransportError("business_error", 200, 901002);
         const bounded = signal ? AbortSignal.any([signal, AbortSignal.timeout(Math.min(remaining, 12e3))]) : AbortSignal.timeout(Math.min(remaining, 12e3));
         const data = request2.data;
-        const event = parsePushEventInput({ desktop_id: this.identity.desktop_id, event_id: createHash14("sha256").update(JSON.stringify([data.event_type, data.thread_id, data.turn_id ?? data.request_id])).digest("base64url"), notification: request2.notification, data: { ...data, version: 1 }, trace: request2.trace });
+        const event = parsePushEventInput({ desktop_id: this.identity.desktop_id, event_id: createHash15("sha256").update(JSON.stringify([data.event_type, data.thread_id, data.turn_id ?? data.request_id])).digest("base64url"), notification: request2.notification, data: { ...data, version: 1 }, trace: request2.trace });
         do {
           if (Date.now() >= (request2.trace?.deadline_at_ms ?? 0)) throw new NotificationTransportError("business_error", 200, 901002);
           if (bounded.aborted) throw new NotificationTransportError("business_error", 200, 900004);
@@ -37143,7 +37305,7 @@ var init_device_connection_stream2 = __esm({
 });
 
 // apps/desktop/src/remote-session/idempotency.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 var REMOTE_SESSION_MAX_IDEMPOTENT_WRITES_PER_BINDING, REMOTE_SESSION_IDEMPOTENT_WRITE_TTL_MS, RemoteSessionIdempotency;
 var init_idempotency = __esm({
   "apps/desktop/src/remote-session/idempotency.ts"() {
@@ -37162,7 +37324,7 @@ var init_idempotency = __esm({
       }
       run(input) {
         const now = this.nowMs();
-        const fingerprint2 = createHash15("sha256").update(canonicalizeJson(input.payload)).digest("hex");
+        const fingerprint2 = createHash16("sha256").update(canonicalizeJson(input.payload)).digest("hex");
         const cacheKey = input.scope_id === void 0 ? input.request_id : `${input.scope_id}\0${input.request_id}`;
         const bindingEntries = this.entries.get(input.binding_id) ?? /* @__PURE__ */ new Map();
         this.removeExpired(input.binding_id, bindingEntries, now);
@@ -41006,7 +41168,7 @@ var init_candidate_catalog2 = __esm({
 });
 
 // apps/desktop/src/direct-gateway/identity-store.ts
-import path34 from "node:path";
+import path35 from "node:path";
 function copyIdentity(identity6) {
   return {
     desktop_id: identity6.desktop_id,
@@ -41061,7 +41223,7 @@ function deserializeIdentity(value) {
   }
 }
 function resolveDefaultDesktopIdentityFilePath() {
-  return path34.join(desktopPlatform().directories.data, DEFAULT_IDENTITY_FILE_NAME);
+  return path35.join(desktopPlatform().directories.data, DEFAULT_IDENTITY_FILE_NAME);
 }
 var IDENTITY_KEY_BYTES2, DEFAULT_IDENTITY_FILE_NAME, MAX_IDENTITY_BYTES, FileDesktopIdentityStore;
 var init_identity_store = __esm({
@@ -41077,7 +41239,7 @@ var init_identity_store = __esm({
       filePath;
       files;
       constructor(options = {}) {
-        this.filePath = path34.resolve(options.file_path ?? resolveDefaultDesktopIdentityFilePath());
+        this.filePath = path35.resolve(options.file_path ?? resolveDefaultDesktopIdentityFilePath());
         this.files = options.files ?? privateDocumentFiles;
       }
       async load() {
@@ -44431,17 +44593,6 @@ var init_settings = __esm({
   }
 });
 
-// apps/desktop/src/assets.ts
-function desktopAssetUrl(area, file) {
-  const release2 = true;
-  return new URL(release2 ? `./assets/${area}/${file}` : `./${area}/static/${file}`, import.meta.url);
-}
-var init_assets = __esm({
-  "apps/desktop/src/assets.ts"() {
-    "use strict";
-  }
-});
-
 // apps/desktop/src/pairing-web/auth.ts
 function authorizePairingRequest(request2, port, api) {
   const origin3 = `http://127.0.0.1:${port}`;
@@ -44560,7 +44711,7 @@ var init_routes3 = __esm({
 
 // apps/desktop/src/pairing-web/server.ts
 import http3 from "node:http";
-import fs23 from "node:fs/promises";
+import fs24 from "node:fs/promises";
 var ASSETS, PairingWebServer;
 var init_server3 = __esm({
   "apps/desktop/src/pairing-web/server.ts"() {
@@ -44644,7 +44795,7 @@ var init_server3 = __esm({
           }
           const asset = ASSETS[raw];
           if (request2.method !== "GET" || !asset) throw new HttpApiError(404, 900005, "\u63A5\u53E3\u4E0D\u5B58\u5728");
-          const body = await fs23.readFile(desktopAssetUrl("pairing-web", asset[0]));
+          const body = await fs24.readFile(desktopAssetUrl("pairing-web", asset[0]));
           response.writeHead(200, { "Content-Type": asset[1] });
           response.end(body);
         } catch (error2) {
@@ -46427,21 +46578,21 @@ var init_desktop_timeline_events = __esm({
           if (patch.op !== "add" && patch.op !== "replace") {
             continue;
           }
-          const path55 = array2(patch.path);
-          if (path55.length === 4 && path55[0] === "turnHistory" && path55[1] === "history" && path55[2] === "entitiesByKey" && typeof path55[3] === "string") {
+          const path56 = array2(patch.path);
+          if (path56.length === 4 && path56[0] === "turnHistory" && path56[1] === "history" && path56[2] === "entitiesByKey" && typeof path56[3] === "string") {
             const turnId = turnIdFromEntity(record14(patch.value));
             if (turnId) {
-              this.entityTurnIds.set(this.entityKey(threadId2, path55[3]), turnId);
+              this.entityTurnIds.set(this.entityKey(threadId2, path56[3]), turnId);
             }
             continue;
           }
-          if (path55.length !== 6 || path55[0] !== "turnHistory" || path55[1] !== "history" || path55[2] !== "entitiesByKey" || typeof path55[3] !== "string" || path55[4] !== "items" || typeof path55[5] !== "number") {
+          if (path56.length !== 6 || path56[0] !== "turnHistory" || path56[1] !== "history" || path56[2] !== "entitiesByKey" || typeof path56[3] !== "string" || path56[4] !== "items" || typeof path56[5] !== "number") {
             continue;
           }
           const occurredAt4 = Math.floor((this.options.now ?? Date.now)() / 1e3);
           const item = normalizeTimelineItem(patch.value, {
             threadId: threadId2,
-            turnId: this.entityTurnIds.get(this.entityKey(threadId2, path55[3])) ?? null,
+            turnId: this.entityTurnIds.get(this.entityKey(threadId2, path56[3])) ?? null,
             source: "desktop_ipc",
             occurredAt: occurredAt4,
             resolveKnownLocalImage
@@ -46487,8 +46638,8 @@ function assignKnownUnreadFields(target, value) {
     target.unreadMessageCount = value.unreadMessageCount;
   }
 }
-function isUnreadFieldPath(path55, field2) {
-  return path55.length === 1 && path55[0] === field2 || path55.length === 2 && path55[0] === "conversationState" && path55[1] === field2;
+function isUnreadFieldPath(path56, field2) {
+  return path56.length === 1 && path56[0] === field2 || path56.length === 2 && path56[0] === "conversationState" && path56[1] === field2;
 }
 function hasUpdateFields(update) {
   return "hasUnreadTurn" in update || "unreadMessageCount" in update;
@@ -46514,19 +46665,19 @@ function extractDesktopUnreadUpdate(frame) {
   }
   for (const patchValue of change.patches) {
     const patch = record15(patchValue);
-    const path55 = Array.isArray(patch.path) ? patch.path : [];
+    const path56 = Array.isArray(patch.path) ? patch.path : [];
     const op = patch.op;
     if (op !== "add" && op !== "replace" && op !== "remove") {
       continue;
     }
-    if (isUnreadFieldPath(path55, "hasUnreadTurn")) {
+    if (isUnreadFieldPath(path56, "hasUnreadTurn")) {
       if (op === "remove") {
         update.hasUnreadTurn = null;
       } else if (typeof patch.value === "boolean") {
         update.hasUnreadTurn = patch.value;
       }
     }
-    if (isUnreadFieldPath(path55, "unreadMessageCount")) {
+    if (isUnreadFieldPath(path56, "unreadMessageCount")) {
       if (op === "remove") {
         update.unreadMessageCount = null;
       } else if (isMessageCount(patch.value)) {
@@ -47223,15 +47374,15 @@ function revisionOf(value) {
 function occurredAt() {
   return Math.floor(Date.now() / 1e3);
 }
-function itemTarget(path55) {
-  const index = path55[5];
-  if (path55[0] !== "turnHistory" || path55[1] !== "history" || path55[2] !== "entitiesByKey" || typeof path55[3] !== "string" || path55[4] !== "items" || typeof index !== "number" || !Number.isInteger(index) || index < 0) {
+function itemTarget(path56) {
+  const index = path56[5];
+  if (path56[0] !== "turnHistory" || path56[1] !== "history" || path56[2] !== "entitiesByKey" || typeof path56[3] !== "string" || path56[4] !== "items" || typeof index !== "number" || !Number.isInteger(index) || index < 0) {
     return null;
   }
-  return { entityKey: path55[3], index, itemPathLength: 6 };
+  return { entityKey: path56[3], index, itemPathLength: 6 };
 }
-function entityTarget(path55) {
-  return path55[0] === "turnHistory" && path55[1] === "history" && path55[2] === "entitiesByKey" && typeof path55[3] === "string" ? path55[3] : null;
+function entityTarget(path56) {
+  return path56[0] === "turnHistory" && path56[1] === "history" && path56[2] === "entitiesByKey" && typeof path56[3] === "string" ? path56[3] : null;
 }
 function phaseOf(status2) {
   if (status2 === "failed" || status2 === "error") {
@@ -47517,15 +47668,15 @@ var init_desktop_activity_events = __esm({
           if (patch.op !== "add" && patch.op !== "replace") {
             continue;
           }
-          const path55 = array3(patch.path);
-          const targetItem = itemTarget(path55);
+          const path56 = array3(patch.path);
+          const targetItem = itemTarget(path56);
           if (targetItem) {
-            signals.push(...this.consumeItemPatch(threadId2, state, targetItem, path55, patch.value, patch.op));
+            signals.push(...this.consumeItemPatch(threadId2, state, targetItem, path56, patch.value, patch.op));
             continue;
           }
-          const targetEntity = entityTarget(path55);
+          const targetEntity = entityTarget(path56);
           if (targetEntity) {
-            signals.push(...this.consumeEntityPatch(threadId2, state, targetEntity, path55, patch.value));
+            signals.push(...this.consumeEntityPatch(threadId2, state, targetEntity, path56, patch.value));
           }
         }
         return signals;
@@ -47599,12 +47750,12 @@ var init_desktop_activity_events = __esm({
           occurredAt: occurredAt()
         }];
       }
-      consumeItemPatch(threadId2, state, target, path55, value, op) {
+      consumeItemPatch(threadId2, state, target, path56, value, op) {
         const entity = state.entities.get(target.entityKey);
         if (!entity || state.currentActiveEntityKey !== target.entityKey || state.currentActiveTurnId !== entity.turnId) {
           return [];
         }
-        if (path55.length === target.itemPathLength) {
+        if (path56.length === target.itemPathLength) {
           return this.prependLiveTurnStart(threadId2, entity, this.consumeWholeItem(
             threadId2,
             entity,
@@ -47614,13 +47765,13 @@ var init_desktop_activity_events = __esm({
           ));
         }
         const existing = entity.items.get(target.index);
-        if (!existing || path55.length < target.itemPathLength + 1) {
+        if (!existing || path56.length < target.itemPathLength + 1) {
           return [];
         }
-        const field2 = path55[target.itemPathLength];
+        const field2 = path56[target.itemPathLength];
         if (existing.type === "reasoning" && field2 === "summary") {
           const summary = structuredClone(existing.summary ?? []);
-          const suffix = path55.slice(target.itemPathLength + 1);
+          const suffix = path56.slice(target.itemPathLength + 1);
           if (suffix.length === 0) {
             existing.summary = structuredClone(Array.isArray(value) ? value : [value]);
           } else {
@@ -47720,9 +47871,9 @@ var init_desktop_activity_events = __esm({
         });
         return [this.activitySignal(threadId2, entity.turnId, itemId, mapping)];
       }
-      consumeEntityPatch(threadId2, state, entityKey, path55, value) {
-        const wholeEntity = path55.length === 4;
-        const statusField = path55.length === 5 && path55[4] === "status";
+      consumeEntityPatch(threadId2, state, entityKey, path56, value) {
+        const wholeEntity = path56.length === 4;
+        const statusField = path56.length === 5 && path56[4] === "status";
         if (!wholeEntity && !statusField) {
           return [];
         }
@@ -47902,20 +48053,20 @@ var init_desktop_error_events = __esm({
           if (patch.op !== "add" && patch.op !== "replace") {
             continue;
           }
-          const path55 = array4(patch.path);
-          if (path55.length === 4 && path55[0] === "turnHistory" && path55[1] === "history" && path55[2] === "entitiesByKey" && typeof path55[3] === "string") {
+          const path56 = array4(patch.path);
+          if (path56.length === 4 && path56[0] === "turnHistory" && path56[1] === "history" && path56[2] === "entitiesByKey" && typeof path56[3] === "string") {
             const entity = record17(patch.value);
             const turnId2 = turnIdFromEntity2(entity);
             if (turnId2) {
-              this.entityTurnIds.set(this.entityKey(threadId2, path55[3]), turnId2);
+              this.entityTurnIds.set(this.entityKey(threadId2, path56[3]), turnId2);
               events.push(...this.errorEvents(threadId2, array4(entity.items), turnId2));
             }
             continue;
           }
-          if (path55.length !== 6 || path55[0] !== "turnHistory" || path55[1] !== "history" || path55[2] !== "entitiesByKey" || typeof path55[3] !== "string" || path55[4] !== "items" || typeof path55[5] !== "number") {
+          if (path56.length !== 6 || path56[0] !== "turnHistory" || path56[1] !== "history" || path56[2] !== "entitiesByKey" || typeof path56[3] !== "string" || path56[4] !== "items" || typeof path56[5] !== "number") {
             continue;
           }
-          const turnId = this.entityTurnIds.get(this.entityKey(threadId2, path55[3]));
+          const turnId = this.entityTurnIds.get(this.entityKey(threadId2, path56[3]));
           if (!turnId) {
             continue;
           }
@@ -48008,13 +48159,13 @@ function visibleMessage(value, resolveKnownLocalImage) {
 function occurredAt2() {
   return Math.floor(Date.now() / 1e3);
 }
-function itemPath(path55) {
-  const index = path55.lastIndexOf("items");
-  const itemIndex = path55[index + 1];
-  return index >= 0 && typeof itemIndex === "number" && Number.isInteger(itemIndex) && itemIndex >= 0 && path55.length >= index + 2 ? path55.slice(0, index + 2) : null;
+function itemPath(path56) {
+  const index = path56.lastIndexOf("items");
+  const itemIndex = path56[index + 1];
+  return index >= 0 && typeof itemIndex === "number" && Number.isInteger(itemIndex) && itemIndex >= 0 && path56.length >= index + 2 ? path56.slice(0, index + 2) : null;
 }
-function stateKey(threadId2, path55) {
-  return `${threadId2}:${JSON.stringify(path55)}`;
+function stateKey(threadId2, path56) {
+  return `${threadId2}:${JSON.stringify(path56)}`;
 }
 function completedKey(threadId2, itemId) {
   return `${threadId2}:${itemId}`;
@@ -48072,35 +48223,35 @@ var init_desktop_stream_events = __esm({
           if (op !== "add" && op !== "replace" && op !== "remove") {
             continue;
           }
-          const path55 = array5(patch.path);
-          if (path55[0] === "turnHistory" && (path55.length === 1 || path55[1] === "history" && (path55.length === 2 || path55[2] === "entitiesByKey" && path55.length === 3))) {
+          const path56 = array5(patch.path);
+          if (path56[0] === "turnHistory" && (path56.length === 1 || path56[1] === "history" && (path56.length === 2 || path56[2] === "entitiesByKey" && path56.length === 3))) {
             this.resetThread(threadId2);
             continue;
           }
-          if (path55[0] === "turnHistory" && path55[1] === "history" && path55[2] === "entitiesByKey") {
-            const values = path55.length === 4 ? record18(patch.value).items : path55.length === 5 && path55[4] === "items" ? patch.value : void 0;
-            if (path55.length === 4 || path55.length === 5 && path55[4] === "items") {
-              const arrayPath = path55.slice(0, 4).concat("items");
+          if (path56[0] === "turnHistory" && path56[1] === "history" && path56[2] === "entitiesByKey") {
+            const values = path56.length === 4 ? record18(patch.value).items : path56.length === 5 && path56[4] === "items" ? patch.value : void 0;
+            if (path56.length === 4 || path56.length === 5 && path56[4] === "items") {
+              const arrayPath = path56.slice(0, 4).concat("items");
               this.replaceArrayStates(threadId2, arrayPath, array5(values), resolveKnownLocalImage);
               continue;
             }
           }
-          const rawIndex = path55.lastIndexOf("items") + 1;
-          if (op === "add" && path55[rawIndex] === "-" && path55.length === rawIndex + 1) {
-            const length = this.arrayLengths.get(stateKey(threadId2, path55.slice(0, rawIndex)));
+          const rawIndex = path56.lastIndexOf("items") + 1;
+          if (op === "add" && path56[rawIndex] === "-" && path56.length === rawIndex + 1) {
+            const length = this.arrayLengths.get(stateKey(threadId2, path56.slice(0, rawIndex)));
             if (length === void 0) continue;
-            path55[rawIndex] = length;
+            path56[rawIndex] = length;
           }
-          const targetItemPath = itemPath(path55);
+          const targetItemPath = itemPath(path56);
           if (!targetItemPath) {
             continue;
           }
           const key = stateKey(threadId2, targetItemPath);
-          if (path55.length > targetItemPath.length && ["id", "type"].includes(String(path55[targetItemPath.length]))) {
+          if (path56.length > targetItemPath.length && ["id", "type"].includes(String(path56[targetItemPath.length]))) {
             this.states.delete(key);
             continue;
           }
-          if (path55.length === targetItemPath.length) {
+          if (path56.length === targetItemPath.length) {
             const arrayPath = targetItemPath.slice(0, -1);
             const index = targetItemPath.at(-1);
             if (op === "add" || op === "remove") this.shiftArrayStates(threadId2, arrayPath, index, op);
@@ -48115,7 +48266,7 @@ var init_desktop_stream_events = __esm({
             ));
             continue;
           }
-          if (op === "replace" && path55.length === targetItemPath.length + 1 && path55.at(-1) === "text") {
+          if (op === "replace" && path56.length === targetItemPath.length + 1 && path56.at(-1) === "text") {
             events.push(...this.consumeTextPatch(threadId2, key, patch.value, revision4));
           }
         }
@@ -48127,9 +48278,9 @@ var init_desktop_stream_events = __esm({
         const prefix = JSON.stringify(arrayPath);
         for (const [key2, state] of this.states) {
           if (state.threadId !== threadId2) continue;
-          const path55 = JSON.parse(key2.slice(threadId2.length + 1));
-          const at = path55.at(-1);
-          if (JSON.stringify(path55.slice(0, -1)) !== prefix || typeof at !== "number" || at < index) continue;
+          const path56 = JSON.parse(key2.slice(threadId2.length + 1));
+          const at = path56.at(-1);
+          if (JSON.stringify(path56.slice(0, -1)) !== prefix || typeof at !== "number" || at < index) continue;
           this.states.delete(key2);
           if (op === "remove" && at === index) continue;
           moved.push([stateKey(threadId2, [...arrayPath, at + (op === "add" ? 1 : -1)]), state]);
@@ -48140,20 +48291,20 @@ var init_desktop_stream_events = __esm({
         if (length !== void 0) this.arrayLengths.set(key, Math.max(0, length + (op === "add" ? 1 : -1)));
       }
       /** 完整数组只重播种本实体的路径；其他轮的正文和按原生身份记录的完成事实不变。 */
-      replaceArrayStates(threadId2, path55, values, resolveKnownLocalImage) {
-        const prefix = JSON.stringify(path55);
+      replaceArrayStates(threadId2, path56, values, resolveKnownLocalImage) {
+        const prefix = JSON.stringify(path56);
         for (const [key, state] of this.states) {
           if (state.threadId !== threadId2) continue;
           const itemPath2 = JSON.parse(key.slice(threadId2.length + 1));
           if (JSON.stringify(itemPath2.slice(0, -1)) === prefix) this.states.delete(key);
         }
-        this.arrayLengths.set(stateKey(threadId2, path55), values.length);
+        this.arrayLengths.set(stateKey(threadId2, path56), values.length);
         values.forEach((value, index) => {
           const message = visibleMessage(value, resolveKnownLocalImage);
           if (!message) return;
           if (message.role === "user") this.completed.add(completedKey(threadId2, message.itemId));
           else if (!this.completed.has(completedKey(threadId2, message.itemId))) {
-            this.states.set(stateKey(threadId2, [...path55, index]), { threadId: threadId2, ...message, lastText: message.text });
+            this.states.set(stateKey(threadId2, [...path56, index]), { threadId: threadId2, ...message, lastText: message.text });
           }
         });
       }
@@ -48452,7 +48603,7 @@ var init_method_codecs = __esm({
 });
 
 // apps/desktop/src/desktop-ipc/profiles.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 function method(name2, direction, version2, codec = {}, receiveOnly = false) {
   return {
     method: name2,
@@ -48502,7 +48653,7 @@ var init_profiles = __esm({
       id: "current-methods-2026-10-20",
       version: "1.0",
       // codec 修订随方案发布固定，不能从函数源码生成不稳定指纹。
-      fingerprint: createHash16("sha256").update(JSON.stringify({ codecRevision: "1.0", methods: definitions.map((d) => [d.method, d.direction, d.sendVersion, d.acceptedVersions]) })).digest("hex"),
+      fingerprint: createHash17("sha256").update(JSON.stringify({ codecRevision: "1.0", methods: definitions.map((d) => [d.method, d.direction, d.sendVersion, d.acceptedVersions]) })).digest("hex"),
       methods: new Map(definitions.map((value) => [value.method, value])),
       // 当前只有安装包静态核对与回归；实际 Desktop 业务验收完成前不登记 verifiedDesktop。
       verifiedDesktop: []
@@ -49278,8 +49429,8 @@ var init_socket_client = __esm({
         this.diagnosticProfile = diagnosticProfile;
         this.socketPaths = socketPath ? [socketPath] : defaultSocketPaths;
         const reader = new DesktopRuntimeVersionReader();
-        this.runtimeVersion = new RuntimeVersionCache(async (path55, signal) => {
-          const value = versionReader ? await versionReader(path55, signal) : await reader.read(path55, signal);
+        this.runtimeVersion = new RuntimeVersionCache(async (path56, signal) => {
+          const value = versionReader ? await versionReader(path56, signal) : await reader.read(path56, signal);
           return typeof value === "string" ? { version: value, build: null } : value;
         });
       }
@@ -51565,8 +51716,8 @@ var init_desktop_read_refresh_queue = __esm({
 // apps/desktop/src/daemon/desktop-read-state-file.ts
 import { watch } from "node:fs";
 import { open as open4, stat as statPath } from "node:fs/promises";
-import { createHash as createHash17 } from "node:crypto";
-import path35 from "node:path";
+import { createHash as createHash18 } from "node:crypto";
+import path36 from "node:path";
 function record20(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -51608,7 +51759,7 @@ var LOCAL_STDIO_HOST, MAX_BYTES2, DesktopReadStateFile;
 var init_desktop_read_state_file = __esm({
   "apps/desktop/src/daemon/desktop-read-state-file.ts"() {
     "use strict";
-    LOCAL_STDIO_HOST = `local:${createHash17("sha256").update(JSON.stringify(["local", "local", null])).digest("hex")}`;
+    LOCAL_STDIO_HOST = `local:${createHash18("sha256").update(JSON.stringify(["local", "local", null])).digest("hex")}`;
     MAX_BYTES2 = 16 * 1024 * 1024;
     DesktopReadStateFile = class {
       constructor(home, changed2, options = {}) {
@@ -51710,7 +51861,7 @@ var init_desktop_read_state_file = __esm({
       async readOnce() {
         this.checks++;
         try {
-          const filePath = path35.join(this.home, ".codex-global-state.json");
+          const filePath = path36.join(this.home, ".codex-global-state.json");
           const file = await open4(filePath, "r");
           let raw, signature;
           try {
@@ -53556,9 +53707,9 @@ var init_protocol = __esm({
 
 // apps/desktop/src/daemon/server.ts
 import { randomUUID as randomUUID32 } from "node:crypto";
-import fs24 from "node:fs";
+import fs25 from "node:fs";
 import net4 from "node:net";
-import path36 from "node:path";
+import path37 from "node:path";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 function createStatusFile(instanceId, mode, socketPath) {
   return {
@@ -53693,10 +53844,10 @@ var init_server4 = __esm({
     DaemonServer = class {
       constructor(options) {
         this.options = options;
-        this.socketPath = path36.resolve(options.socketPath ?? daemonSocketPath());
-        this.statusPath = path36.resolve(options.statusPath ?? daemonStatusPath());
+        this.socketPath = path37.resolve(options.socketPath ?? daemonSocketPath());
+        this.statusPath = path37.resolve(options.statusPath ?? daemonStatusPath());
         this.usesDefaultRuntimeDir = options.socketPath === void 0 || options.statusPath === void 0;
-        this.lifecycleLockPath = options.socketPath === void 0 ? daemonLifecycleLockPath() : path36.join(path36.dirname(this.socketPath), ".daemon-lifecycle.lock");
+        this.lifecycleLockPath = options.socketPath === void 0 ? daemonLifecycleLockPath() : path37.join(path37.dirname(this.socketPath), ".daemon-lifecycle.lock");
         this.transport = createDaemonTransport(this.socketPath);
         this.listenSocketPath = this.transport.listenPath;
       }
@@ -53808,22 +53959,22 @@ var init_server4 = __esm({
         const temporaryPath = `${this.statusPath}.${this.instanceId}.tmp`;
         let descriptor = null;
         try {
-          descriptor = fs24.openSync(temporaryPath, "wx", 384);
-          fs24.writeFileSync(
+          descriptor = fs25.openSync(temporaryPath, "wx", 384);
+          fs25.writeFileSync(
             descriptor,
             `${JSON.stringify(createStatusFile(this.instanceId, this.options.mode ?? "foreground", this.socketPath), null, 2)}
 `,
             "utf8"
           );
-          fs24.closeSync(descriptor);
+          fs25.closeSync(descriptor);
           descriptor = null;
-          fs24.chmodSync(temporaryPath, 384);
-          fs24.renameSync(temporaryPath, this.statusPath);
+          fs25.chmodSync(temporaryPath, 384);
+          fs25.renameSync(temporaryPath, this.statusPath);
         } catch (error2) {
           if (descriptor !== null) {
-            fs24.closeSync(descriptor);
+            fs25.closeSync(descriptor);
           }
-          fs24.rmSync(temporaryPath, { force: true });
+          fs25.rmSync(temporaryPath, { force: true });
           throw error2;
         }
       }
@@ -53848,9 +53999,9 @@ var init_server4 = __esm({
         this.transport.cleanup(this.socketPath);
         if (this.statusOwned) {
           try {
-            const status2 = JSON.parse(fs24.readFileSync(this.statusPath, "utf8"));
+            const status2 = JSON.parse(fs25.readFileSync(this.statusPath, "utf8"));
             if (status2.instanceId === this.instanceId) {
-              fs24.rmSync(this.statusPath, { force: true });
+              fs25.rmSync(this.statusPath, { force: true });
             }
           } catch {
           }
@@ -54444,7 +54595,7 @@ var init_push_trigger_projection = __esm({
 });
 
 // apps/desktop/src/daemon/turn-push-audit.ts
-import path37 from "node:path";
+import path38 from "node:path";
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -54491,7 +54642,7 @@ function isCoverageReason(value) {
   return value === "realtime_gap" || value === "historical_gap" || value === "source_unavailable" || value === "reader_limit" || value === "write_failed";
 }
 function auditDirectory(runtimeDir) {
-  return path37.join(runtimeDir, AUDIT_DIRECTORY);
+  return path38.join(runtimeDir, AUDIT_DIRECTORY);
 }
 function dateFileName(timestampMs) {
   if (!isFiniteTimestamp(timestampMs)) return null;
@@ -54594,7 +54745,7 @@ function appendRecord(runtimeDir, timestampMs, record26, files) {
     files.checkDirectory(runtimeDir);
     const directory = auditDirectory(runtimeDir);
     files.ensureDirectory(directory);
-    files.append(path37.join(directory, fileName), `${JSON.stringify(record26)}
+    files.append(path38.join(directory, fileName), `${JSON.stringify(record26)}
 `, MAX_FILE_BYTES);
     return true;
   } catch {
@@ -56091,7 +56242,7 @@ var init_events2 = __esm({
 });
 
 // apps/desktop/src/niuma/session-history-items.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function copyTimelineStatus(raw, item) {
   if (!Object.hasOwn(raw, "status")) return;
   if (raw.status === null || raw.status === void 0) return;
@@ -56158,11 +56309,11 @@ function completedHistoryItem(value) {
       break;
     case "fileChange":
       copy(raw, item, { status: "status" });
-      item.changes = Array.isArray(raw.changes) ? structuredClone(raw.changes) : Object.entries(record5(raw.changes)).map(([path55, value2]) => {
+      item.changes = Array.isArray(raw.changes) ? structuredClone(raw.changes) : Object.entries(record5(raw.changes)).map(([path56, value2]) => {
         const change = record5(value2);
         const kind = { type: change.type };
         if (change.type === "update") kind.movePath = change.move_path ?? null;
-        return { path: path55, kind, diff: change.unified_diff ?? change.content ?? "" };
+        return { path: path56, kind, diff: change.unified_diff ?? change.content ?? "" };
       });
       break;
     case "collabAgentToolCall":
@@ -56210,7 +56361,7 @@ function responseHistoryItem(value, location) {
   const type = raw.type;
   if (type === "message") {
     if (raw.role !== "user" && raw.role !== "assistant") return null;
-    const id5 = nonempty(raw.id) ?? `session-${createHash18("sha256").update(location).digest("hex")}`;
+    const id5 = nonempty(raw.id) ?? `session-${createHash19("sha256").update(location).digest("hex")}`;
     return { ...completedHistoryItem({ ...raw, id: id5, type: raw.role === "user" ? "UserMessage" : "AgentMessage" }), historySource: "response_item" };
   }
   if (type === "web_search_call") {
@@ -56299,8 +56450,8 @@ function markdownTargets(text11) {
 function markdownReferences(text11, paths = localResourcePaths) {
   const { tree, references } = markdownTargets(text11);
   return { tree, references: references.flatMap((ref) => {
-    const path55 = paths.parseLink(ref.url);
-    return path55 === null ? [] : [{ ...ref, path: path55 }];
+    const path56 = paths.parseLink(ref.url);
+    return path56 === null ? [] : [{ ...ref, path: path56 }];
   }) };
 }
 function collectAssistantImagePaths(value, resourcePaths2 = localResourcePaths) {
@@ -56331,8 +56482,8 @@ function collectAssistantImagePaths(value, resourcePaths2 = localResourcePaths)
     if (item.entitiesByKey && typeof item.entitiesByKey === "object") pending.push(...Object.values(item.entitiesByKey));
     if (Array.isArray(item.patches)) {
       for (const patch of item.patches) {
-        const path55 = patch?.path;
-        if (Array.isArray(path55) && path55[0] === "turnHistory" && path55[1] === "history" && path55[2] === "entitiesByKey" && (path55.length === 4 || path55[4] === "items")) pending.push(patch.value);
+        const path56 = patch?.path;
+        if (Array.isArray(path56) && path56[0] === "turnHistory" && path56[1] === "history" && path56[2] === "entitiesByKey" && (path56.length === 4 || path56[4] === "items")) pending.push(patch.value);
       }
     }
   }
@@ -56423,7 +56574,7 @@ var init_thread_view_images = __esm({
 });
 
 // apps/desktop/src/niuma/session-history-images.ts
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 import { stat as stat2 } from "node:fs/promises";
 async function historyFingerprint(snapshots2, signal) {
   signal?.throwIfAborted();
@@ -56519,7 +56670,7 @@ async function readHistoryImageValue(locator, signal, filePath) {
   }
   await validateSessionFile(snapshot2);
   const bytes3 = await readBytes(snapshot2.path, offset, length);
-  if (createHash19("sha256").update(bytes3).digest("hex") !== locator.recordSha256) {
+  if (createHash20("sha256").update(bytes3).digest("hex") !== locator.recordSha256) {
     throw new SessionHistoryError("SNAPSHOT_CHANGED", "\u56FE\u7247\u5386\u53F2\u8BB0\u5F55\u5DF2\u53D8\u5316");
   }
   let value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes3));
@@ -56533,11 +56684,11 @@ async function readHistoryImageValue(locator, signal, filePath) {
   signal?.throwIfAborted();
   return value;
 }
-async function assertHistoryImageFileReference(locator, path55, signal) {
-  const value = await readHistoryImageValue(locator, signal, path55);
+async function assertHistoryImageFileReference(locator, path56, signal) {
+  const value = await readHistoryImageValue(locator, signal, path56);
   const last = locator.valuePath.at(-1);
   const text11 = typeof value === "string" ? value : Array.isArray(value) ? value.map((part) => typeof record5(part).text === "string" ? record5(part).text : "").join("") : null;
-  if (text11 === null || !(last === "path" ? text11 === path55 : assistantPaths(text11).includes(path55))) {
+  if (text11 === null || !(last === "path" ? text11 === path56 : assistantPaths(text11).includes(path56))) {
     throw new SessionHistoryError("INVALID_RECORD", "\u56FE\u7247\u6587\u4EF6\u4E0E\u5386\u53F2\u5F15\u7528\u4E0D\u7B26");
   }
 }
@@ -56596,7 +56747,7 @@ var init_session_history_images = __esm({
         const found = [];
         if (formal && item.type === "agentMessage") {
           const references = [];
-          for (const path55 of assistantPaths(String(item.text ?? ""))) {
+          for (const path56 of assistantPaths(String(item.text ?? ""))) {
             references.push({ locator: {
               threadId: threadId2,
               turnId: "",
@@ -56609,7 +56760,7 @@ var init_session_history_images = __esm({
               recordLength: range.length,
               recordSha256: range.sha256,
               valuePath: ["payload", "item", raw.content !== void 0 ? "content" : "text"]
-            }, nativeMessageId: null, path: path55, filePath: path55, callId: null });
+            }, nativeMessageId: null, path: path56, filePath: path56, callId: null });
           }
           this.markdownEvidence.set(item, references);
         }
@@ -56638,7 +56789,7 @@ var init_session_history_images = __esm({
           }
           if (!imageUrl(source2)) return;
           const previous = index > 0 ? record5(parts[index - 1]).text : null;
-          const path55 = typeof previous === "string" ? /^<image(?: name=.*?)? path="([^"]+)">$/.exec(previous)?.[1] ?? null : null;
+          const path56 = typeof previous === "string" ? /^<image(?: name=.*?)? path="([^"]+)">$/.exec(previous)?.[1] ?? null : null;
           found.push({
             locator: {
               threadId: threadId2,
@@ -56658,7 +56809,7 @@ var init_session_history_images = __esm({
               ]
             },
             nativeMessageId: typeof item.clientId === "string" ? item.clientId : null,
-            path: path55,
+            path: path56,
             callId: null
           });
           if (mapped[index]) mapped[index] = { type: "historyImage", resourceKey: null };
@@ -56720,11 +56871,11 @@ var init_session_history_images = __esm({
           }
           if (item.type === "agentMessage" && typeof item.text === "string") {
             const references = [];
-            for (const [referenceIndex, path55] of assistantPaths(item.text).entries()) {
+            for (const [referenceIndex, path56] of assistantPaths(item.text).entries()) {
               const calls = fallback.filter((candidate) => {
                 if (candidate.type !== "functionCall" || !["view_image", "functions.view_image"].includes(String(candidate.name))) return false;
                 try {
-                  return record5(JSON.parse(String(candidate.arguments))).path === path55;
+                  return record5(JSON.parse(String(candidate.arguments))).path === path56;
                 } catch {
                   return false;
                 }
@@ -56732,9 +56883,9 @@ var init_session_history_images = __esm({
               const outputs = fallback.filter((candidate) => candidate.type === "functionCallOutput" && calls.some((call) => candidate.id === call.id));
               const candidates = outputs.flatMap((output) => this.evidence.get(output) ?? []);
               if (candidates.length && (calls.length !== 1 || candidates.length !== 1)) continue;
-              const original = candidates[0] ?? this.markdownEvidence.get(item)?.find((value) => value.filePath === path55);
+              const original = candidates[0] ?? this.markdownEvidence.get(item)?.find((value) => value.filePath === path56);
               if (!original) continue;
-              const evidence = { ...original, path: path55, referenceKind: "markdown", locator: {
+              const evidence = { ...original, path: path56, referenceKind: "markdown", locator: {
                 ...original.locator,
                 turnId,
                 itemId: item.id,
@@ -56742,7 +56893,7 @@ var init_session_history_images = __esm({
               } };
               try {
                 const resourceKey = await callback(evidence);
-                if (resourceKey) references.push({ path: path55, resourceKey });
+                if (resourceKey) references.push({ path: path56, resourceKey });
               } catch {
               }
             }
@@ -56761,7 +56912,7 @@ __export(session_history_reader_exports, {
   SessionHistoryReader: () => SessionHistoryReader
 });
 import { randomUUID as randomUUID33 } from "node:crypto";
-import fs25 from "node:fs/promises";
+import fs26 from "node:fs/promises";
 function resolveHistoryPath(resolvePath, signal) {
   abortIfRequested2(signal);
   if (!signal) return resolvePath();
@@ -57029,7 +57180,7 @@ var init_session_history_reader = __esm({
           try {
             const resolved3 = await resolveHistoryPath(() => this.options.resolveSessionPath(snapshot2.threadId), signal);
             abortIfRequested2(signal);
-            const current2 = await fs25.realpath(resolved3);
+            const current2 = await fs26.realpath(resolved3);
             abortIfRequested2(signal);
             if (current2 !== snapshot2.files[0].path) throw new Error("current path changed");
           } catch (error2) {
@@ -58317,7 +58468,7 @@ var init_thread_view_reducer = __esm({
 });
 
 // apps/desktop/src/daemon/thread-view-store.ts
-import { createHash as createHash20, randomUUID as randomUUID34 } from "node:crypto";
+import { createHash as createHash21, randomUUID as randomUUID34 } from "node:crypto";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "node:util";
 function clone5(value) {
   return structuredClone(value);
@@ -59187,7 +59338,7 @@ var init_thread_view_store = __esm({
           const facts = asyncQuestionFactItems(nextAggregate);
           if (facts.length) {
             const observation = nextEntry.questionObservation ??= { confirmed: null, latest: null, pending: /* @__PURE__ */ new Map() };
-            const fingerprint2 = createHash20("sha256").update(JSON.stringify(facts)).digest("hex");
+            const fingerprint2 = createHash21("sha256").update(JSON.stringify(facts)).digest("hex");
             observation.latest = observation.pending.get(fingerprint2) ?? null;
             if (fingerprint2 !== observation.confirmed && !observation.pending.has(fingerprint2) && observation.pending.size < 32) {
               const token3 = /* @__PURE__ */ Symbol();
@@ -60386,7 +60537,7 @@ var init_async_question_batch_store = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/handlers/interactions.ts
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 function createInteractionsHandlers(ports) {
   const handlers = {
     "thread/async-question-groups": async (params, _socket, options) => ports.interactions.managedQuestionOperation(async () => {
@@ -60426,7 +60577,7 @@ function createInteractionsHandlers(ports) {
           content: [{ type: "text", text: text11 }],
           mode,
           turnId: mode === "steer" ? action2.activeTurnId : null,
-          idempotencyKey: `managed-question:${createHash21("sha256").update(JSON.stringify([principal, batch.thread_id, batch.idempotency_key])).digest("hex")}`,
+          idempotencyKey: `managed-question:${createHash22("sha256").update(JSON.stringify([principal, batch.thread_id, batch.idempotency_key])).digest("hex")}`,
           [MANAGED_QUESTION_BATCH]: true
         }, { ...options, onNativeMessageDispatch: () => {
           ports.interactions.assertManagedQuestionAccess(batch.thread_id, options, generation);
@@ -61876,10 +62027,10 @@ var init_history_snapshot = __esm({
           const patches = objectRecord3(objectRecord3(objectRecord3(frame).params).change).patches;
           const covered = Array.isArray(patches) && patches.every((raw) => {
             const patch = objectRecord3(raw);
-            const path55 = patch.path;
-            if (!Array.isArray(path55)) return false;
-            if (path55[0] === "requests") return ["add", "replace", "remove"].includes(String(patch.op));
-            return path55[0] === "turnHistory" && path55[1] === "history" && path55[2] === "entitiesByKey" && typeof path55[3] === "string" && path55[3].endsWith(`:${recovery.turnId}`) && path55[4] === "items" && (patch.op === "add" && path55.length === 6 || patch.op === "replace" && path55.length === 7 && path55[6] === "text");
+            const path56 = patch.path;
+            if (!Array.isArray(path56)) return false;
+            if (path56[0] === "requests") return ["add", "replace", "remove"].includes(String(patch.op));
+            return path56[0] === "turnHistory" && path56[1] === "history" && path56[2] === "entitiesByKey" && typeof path56[3] === "string" && path56[3].endsWith(`:${recovery.turnId}`) && path56[4] === "items" && (patch.op === "add" && path56.length === 6 || patch.op === "replace" && path56.length === 7 && path56[6] === "text");
           });
           const bytes3 = Buffer.byteLength(JSON.stringify(acceptedEvents));
           if (!covered || recovery.events.length + events.length > 256 || recovery.bytes + bytes3 > 2 * 1024 * 1024) recovery.valid = false;
@@ -62093,7 +62244,7 @@ var init_history_state_reads = __esm({
 });
 
 // apps/desktop/src/daemon/app-server-history-window-reader.ts
-import { createHash as createHash22, randomUUID as randomUUID38 } from "node:crypto";
+import { createHash as createHash23, randomUUID as randomUUID38 } from "node:crypto";
 function awaitResponse(promise, signal) {
   if (!signal) return promise;
   signal.throwIfAborted();
@@ -62248,11 +62399,11 @@ var init_app_server_history_window_reader = __esm({
         const bound = this.turnMetadata.get(turn);
         if (!bound) throw new SessionHistoryError("INVALID_CURSOR", "Turn \u4E0D\u5C5E\u4E8E\u5F53\u524D\u5386\u53F2\u5FEB\u7167");
         this.assertEvidenceCurrent(bound);
-        const { createdAt, cwd, path: path55 } = bound.metadata;
+        const { createdAt, cwd, path: path56 } = bound.metadata;
         return {
           nativeOrder: bound.nativeOrder,
           sourceRevision: bound.revision,
-          contentVersion: createHash22("sha256").update(JSON.stringify([turn, createdAt, cwd, path55])).digest("hex")
+          contentVersion: createHash23("sha256").update(JSON.stringify([turn, createdAt, cwd, path56])).digest("hex")
         };
       }
       /** 撤销正文提交资格，保留逻辑边界供下次原生读取重新证明。 */
@@ -62465,7 +62616,7 @@ var init_app_server_history_window_reader = __esm({
           this.nativeMetrics.peakCandidateBytes = Math.max(this.nativeMetrics.peakCandidateBytes, source2.rawBytes);
           source2.nativeVersions = new Map(source2.rawTurns.map((raw) => {
             const value = raw;
-            return [String(value.id), createHash22("sha256").update(JSON.stringify(raw)).digest("hex")];
+            return [String(value.id), createHash23("sha256").update(JSON.stringify(raw)).digest("hex")];
           }));
           source2.nativeEdges = this.proveNativeEdges([...source2.nativeVersions.keys()], source2.eof === true, !hint);
           const ids = /* @__PURE__ */ new Set();
@@ -62869,7 +63020,7 @@ var init_thread_history_snapshot_cache = __esm({
 });
 
 // apps/desktop/src/daemon/thread-history-window-loader.ts
-import { createHash as createHash23, randomUUID as randomUUID39 } from "node:crypto";
+import { createHash as createHash24, randomUUID as randomUUID39 } from "node:crypto";
 function abortable(promise, signal) {
   signal.throwIfAborted();
   return new Promise((resolve5, reject3) => {
@@ -63165,7 +63316,7 @@ var init_thread_history_window_loader = __esm({
         token3.addTurnIds([turn.id]);
         const identity6 = JSON.stringify([threadId2, turn.id]);
         const description = this.reader.describeTurn?.(turn) ?? {
-          contentVersion: createHash23("sha256").update(JSON.stringify(turn)).digest("hex"),
+          contentVersion: createHash24("sha256").update(JSON.stringify(turn)).digest("hex"),
           nativeOrder: 0,
           sourceRevision: 0
         };
@@ -63247,7 +63398,7 @@ var init_thread_history_window_loader = __esm({
       async measure(turn, signal) {
         const epoch = this.sourceEpoch;
         this.currentProtection.addTurnIds([turn.id]);
-        const description = this.reader.describeTurn?.(turn) ?? { contentVersion: createHash23("sha256").update(JSON.stringify(turn)).digest("hex") };
+        const description = this.reader.describeTurn?.(turn) ?? { contentVersion: createHash24("sha256").update(JSON.stringify(turn)).digest("hex") };
         const timing = await this.timestampVersion(turn, signal);
         this.assertSource(epoch);
         signal.throwIfAborted();
@@ -63373,7 +63524,7 @@ var init_thread_history = __esm({
 });
 
 // apps/desktop/src/daemon/thread-read-checkpoint.ts
-import { createHash as createHash24 } from "node:crypto";
+import { createHash as createHash25 } from "node:crypto";
 function stableContent2(part) {
   if (part.type === "text") return { type: part.type, text: part.text };
   if (part.type === "file") return { type: part.type, name: part.name, attachment_id: part.attachment_id ?? null };
@@ -63388,7 +63539,7 @@ function createContentCheckpoint(input) {
     namespace: input.namespace,
     threadId: input.threadId,
     turnId: input.turnId,
-    fingerprint: createHash24("sha256").update(JSON.stringify(body)).digest("hex")
+    fingerprint: createHash25("sha256").update(JSON.stringify(body)).digest("hex")
   };
 }
 function nativeReadIdentity(input) {
@@ -64760,7 +64911,7 @@ var init_thread_history_window_projection = __esm({
           pending: null,
           activity: null,
           lastError: null,
-          resolveKnownLocalImage: (path55, itemId, partIndex) => this.options.resolveKnownLocalImage?.(path55, itemId, partIndex) ?? (itemId ? knownImages.get(itemId)?.get(path55) ?? null : null),
+          resolveKnownLocalImage: (path56, itemId, partIndex) => this.options.resolveKnownLocalImage?.(path56, itemId, partIndex) ?? (itemId ? knownImages.get(itemId)?.get(path56) ?? null : null),
           onHistoryItemProjected: (item, normalized) => timeline.push({ id: item.id, timeline: normalized })
         }, "history_only");
         const items = [...event.baseline.committed_items, ...event.baseline.active_turn?.items ?? []];
@@ -65581,7 +65732,7 @@ var init_thread_read_state = __esm({
 });
 
 // apps/desktop/src/daemon/thread-read-diagnostics.ts
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 function unreadDiagnosticValues(before, after) {
   return {
     beforeUnread: before?.hasUnreadTurn ?? null,
@@ -65634,8 +65785,8 @@ function unreadFrameDiagnostic(frame) {
   let countValue = values.unreadMessageCount;
   if (kind === "patch") {
     for (const value of Array.isArray(change.patches) ? change.patches : []) {
-      const patch = object10(value), path55 = Array.isArray(patch.path) ? patch.path : [];
-      const name2 = path55.length === 1 ? path55[0] : path55.length === 2 && path55[0] === "conversationState" ? path55[1] : null;
+      const patch = object10(value), path56 = Array.isArray(patch.path) ? patch.path : [];
+      const name2 = path56.length === 1 ? path56[0] : path56.length === 2 && path56[0] === "conversationState" ? path56[1] : null;
       if (name2 !== "hasUnreadTurn" && name2 !== "unreadMessageCount") continue;
       const state = patch.op === "remove" ? "removed" : ["add", "replace"].includes(String(patch.op)) ? field(patch.value, Object.hasOwn(patch, "value"), name2 === "unreadMessageCount") : "invalid";
       if (name2 === "hasUnreadTurn") unread = state;
@@ -65653,7 +65804,7 @@ function unreadFrameDiagnostic(frame) {
     wireCountValue: count === "value" ? countValue : null,
     version: typeof frame.version === "number" && Number.isSafeInteger(frame.version) && frame.version >= 0 ? frame.version : null,
     revision: typeof change.revision === "number" && Number.isSafeInteger(change.revision) && change.revision >= 0 ? change.revision : null,
-    sourceClient: typeof frame.sourceClientId === "string" ? createHash25("sha256").update(frame.sourceClientId).digest("hex").slice(0, 16) : null
+    sourceClient: typeof frame.sourceClientId === "string" ? createHash26("sha256").update(frame.sourceClientId).digest("hex").slice(0, 16) : null
   };
 }
 function safeReadDiagnosticAttribute(key, value) {
@@ -66206,7 +66357,7 @@ var init_async_question_collector = __esm({
 });
 
 // apps/desktop/src/daemon/managed-async-question-groups.ts
-import { createHash as createHash26 } from "node:crypto";
+import { createHash as createHash27 } from "node:crypto";
 import { z as z14 } from "zod";
 function compactNewTurns(turns) {
   const latest = /* @__PURE__ */ new Map();
@@ -66220,7 +66371,7 @@ function unavailable8() {
   throw new HttpApiError(500, 900004, "\u9898\u7EC4\u5B58\u50A8\u6682\u4E0D\u53EF\u7528");
 }
 function groupId(source2) {
-  return "aqg_" + createHash26("sha256").update(source2).digest("base64url");
+  return "aqg_" + createHash27("sha256").update(source2).digest("base64url");
 }
 function project2(t, g) {
   return { thread_id: t.id, group_id: groupId(g.source), revision: g.revision, list: g.list.filter((q) => !q.closed).map(({ id: id5, title, options }) => ({ id: id5, title, options })) };
@@ -66257,8 +66408,8 @@ var init_managed_async_question_groups = __esm({
       trace(phase, batch, extra = {}) {
         try {
           this.diagnostic?.(phase, {
-            batch: createHash26("sha256").update(batch.idempotency_key).digest("hex").slice(0, 16),
-            thread: createHash26("sha256").update(batch.thread_id).digest("hex").slice(0, 16),
+            batch: createHash27("sha256").update(batch.idempotency_key).digest("hex").slice(0, 16),
+            thread: createHash27("sha256").update(batch.thread_id).digest("hex").slice(0, 16),
             revision: batch.revision,
             answerCount: batch.answers.length,
             ...extra
@@ -66565,7 +66716,7 @@ var init_managed_async_question_groups = __esm({
 });
 
 // apps/desktop/src/daemon/async-question-evidence.ts
-import { createHash as createHash27 } from "node:crypto";
+import { createHash as createHash28 } from "node:crypto";
 function projectAsyncQuestionEvidence(input) {
   const collection = input.evidence?.collection;
   if (collection && collection.thread_id !== input.threadId) throw new TypeError("invalid_evidence_thread");
@@ -66582,7 +66733,7 @@ function projectAsyncQuestionEvidence(input) {
     list: (collection?.list ?? []).map((q) => ({ id: q.id, title: q.title, options: [...q.options], source_turn_id: q.source_turn_id, answer: q.answer, answer_turn_id: q.answer_turn_id })),
     total: collection?.list.length ?? 0
   };
-  const evidence_id = createHash27("sha256").update(JSON.stringify([input.runtimeGeneration, full])).digest("base64url");
+  const evidence_id = createHash28("sha256").update(JSON.stringify([input.runtimeGeneration, full])).digest("base64url");
   const offset = (input.page - 1) * input.pageSize;
   return parseAsyncQuestionEvidencePage({ ...full, evidence_id, page: input.page, page_size: input.pageSize, list: full.list.slice(offset, offset + input.pageSize) });
 }
@@ -66594,7 +66745,7 @@ var init_async_question_evidence2 = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/interactions.ts
-import { createHash as createHash28 } from "node:crypto";
+import { createHash as createHash29 } from "node:crypto";
 var RuntimeInteractions;
 var init_interactions2 = __esm({
   "apps/desktop/src/daemon/runtime/interactions.ts"() {
@@ -66621,7 +66772,7 @@ var init_interactions2 = __esm({
       // 与持久通知账本的身份上限一致；不淘汰当前轮次来为重复事件续期。
       liveQuestionDeadlines = /* @__PURE__ */ new Map();
       questionKey(threadId2, turnId, rawId) {
-        return createHash28("sha256").update(JSON.stringify([threadId2, turnId, rawId])).digest("hex");
+        return createHash29("sha256").update(JSON.stringify([threadId2, turnId, rawId])).digest("hex");
       }
       clearWaiting() {
         this.asyncInputWaitingQuestions.clear();
@@ -67628,7 +67779,7 @@ var init_projection_context = __esm({
 });
 
 // apps/desktop/src/attachments/file-resources.ts
-import { createHash as createHash29, randomUUID as randomUUID42 } from "node:crypto";
+import { createHash as createHash30, randomUUID as randomUUID42 } from "node:crypto";
 import { constants as constants4 } from "node:fs";
 import { lstat as lstat4, open as open5, realpath as realpath2 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname2, resolve as resolve3 } from "node:path";
@@ -67639,9 +67790,9 @@ function assertFile(stat3) {
   if (!stat3.isFile() || stat3.nlink !== 1n) throw missing2();
   if (stat3.size > BigInt(MAX_BYTES6)) throw limited();
 }
-async function captureDirectoryChain(snapshot2, path55, signal) {
+async function captureDirectoryChain(snapshot2, path56, signal) {
   const paths = /* @__PURE__ */ new Set();
-  for (const start of [dirname2(path55)]) {
+  for (const start of [dirname2(path56)]) {
     for (let current2 = start; ; current2 = dirname2(current2)) {
       paths.add(current2);
       if (paths.size > MAX_DIRECTORY_ENTRIES2) throw limited();
@@ -67771,9 +67922,9 @@ var init_file_resources = __esm({
       trim() {
         while (this.entries.size > MAX_ENTRIES3 || this.indexBytes > MAX_INDEX_BYTES) this.remove(this.entries.values().next().value);
       }
-      assertTarget(entry, path55, signal, isCurrent) {
+      assertTarget(entry, path56, signal, isCurrent) {
         this.assertVisible(entry, signal, isCurrent);
-        if (entry.targetRealPath !== void 0 && entry.targetRealPath !== path55) {
+        if (entry.targetRealPath !== void 0 && entry.targetRealPath !== path56) {
           this.remove(entry);
           this.options.onReferenceRetired?.({ ...entry.reference, attachmentId: entry.attachmentId });
           throw changed();
@@ -67815,22 +67966,22 @@ var init_file_resources = __esm({
           if (request2 && (!expected || expected.sha256 !== request2.sha256)) throw changed();
           const directories2 = { entries: /* @__PURE__ */ new Map(), bytes: 0 };
           await captureDirectoryChain(directories2, entry.reference.path, combined);
-          const path55 = await realpath2(entry.reference.path);
+          const path56 = await realpath2(entry.reference.path);
           combined.throwIfAborted();
-          this.assertTarget(entry, path55, combined, isCurrent);
-          await captureDirectoryChain(directories2, path55, combined);
-          const pathBefore = await lstat4(path55, { bigint: true });
+          this.assertTarget(entry, path56, combined, isCurrent);
+          await captureDirectoryChain(directories2, path56, combined);
+          const pathBefore = await lstat4(path56, { bigint: true });
           assertFile(pathBefore);
-          handle = await open5(path55, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
+          handle = await open5(path56, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
           const before = await handle.stat({ bigint: true });
           assertFile(before);
           if (identity5(before) !== identity5(pathBefore)) throw changed();
-          const fileIdentity2 = `${path55}\0${identity5(before)}`;
+          const fileIdentity2 = `${path56}\0${identity5(before)}`;
           if (request2 && expected.identity !== fileIdentity2) throw changed();
           const byteSize2 = Number(before.size);
           const chunkCount = Math.ceil(byteSize2 / CHUNK_BYTES);
           if (request2 && request2.index >= chunkCount) throw invalid13();
-          const hash3 = createHash29("sha256");
+          const hash3 = createHash30("sha256");
           const buffer = Buffer.alloc(Math.min(CHUNK_BYTES, byteSize2));
           let chunk;
           for (let offset = 0; offset < byteSize2; ) {
@@ -67851,7 +68002,7 @@ var init_file_resources = __esm({
           const pathAfter = await realpath2(entry.reference.path);
           const current2 = await lstat4(pathAfter, { bigint: true });
           this.assertTarget(entry, pathAfter, combined, isCurrent);
-          if (pathAfter !== path55 || identity5(after) !== identity5(before) || identity5(current2) !== identity5(before)) throw changed();
+          if (pathAfter !== path56 || identity5(after) !== identity5(before) || identity5(current2) !== identity5(before)) throw changed();
           const sha2562 = hash3.digest("hex");
           if (request2 && sha2562 !== request2.sha256) throw changed();
           await handle.close();
@@ -67867,8 +68018,8 @@ var init_file_resources = __esm({
             chunkBytes: CHUNK_BYTES,
             chunkCount
           };
-          this.assertTarget(entry, path55, combined, isCurrent);
-          return { entry, path: path55, info, identity: fileIdentity2, chunk, signal: combined };
+          this.assertTarget(entry, path56, combined, isCurrent);
+          return { entry, path: path56, info, identity: fileIdentity2, chunk, signal: combined };
         } catch (error2) {
           combined.throwIfAborted();
           if (error2 instanceof NiumaError) throw error2;
@@ -67900,16 +68051,16 @@ function revisionOf2(value) {
 function occurredAt3() {
   return Math.floor(Date.now() / 1e3);
 }
-function isThreadSettingsPatch(path55) {
-  const field2 = path55.at(-1);
+function isThreadSettingsPatch(path56) {
+  const field2 = path56.at(-1);
   if (typeof field2 !== "string" || !SETTING_FIELD_ALIASES.has(field2)) {
     return false;
   }
-  return path55.length === 1 || typeof path55.at(-2) === "string" && SETTINGS_CONTAINERS.has(path55.at(-2));
+  return path56.length === 1 || typeof path56.at(-2) === "string" && SETTINGS_CONTAINERS.has(path56.at(-2));
 }
-function isCurrentPermissionsPatch(path55) {
-  const field2 = path55.at(-1);
-  return path55.length === 2 && path55[0] === CURRENT_PERMISSIONS_CONTAINER && typeof field2 === "string" && CURRENT_PERMISSION_FIELD_ALIASES.has(field2);
+function isCurrentPermissionsPatch(path56) {
+  const field2 = path56.at(-1);
+  return path56.length === 2 && path56[0] === CURRENT_PERMISSIONS_CONTAINER && typeof field2 === "string" && CURRENT_PERMISSION_FIELD_ALIASES.has(field2);
 }
 function hasOwn(value, field2) {
   return Object.prototype.hasOwnProperty.call(value, field2);
@@ -67988,20 +68139,20 @@ function currentPermissionsFromRecord(value) {
   return settings;
 }
 function settingsFromPatch(patch) {
-  const path55 = array6(patch.path);
-  if (path55.length === 1 && typeof path55[0] === "string" && SETTINGS_CONTAINERS.has(path55[0])) {
+  const path56 = array6(patch.path);
+  if (path56.length === 1 && typeof path56[0] === "string" && SETTINGS_CONTAINERS.has(path56[0])) {
     return settingsFromRecord(patch.value, BASE_SETTING_FIELDS);
   }
-  if (path55.length === 1 && path55[0] === CURRENT_PERMISSIONS_CONTAINER) {
+  if (path56.length === 1 && path56[0] === CURRENT_PERMISSIONS_CONTAINER) {
     return currentPermissionsFromRecord(patch.value);
   }
-  const field2 = path55.at(-1);
+  const field2 = path56.at(-1);
   const settings = {};
-  if (typeof field2 === "string" && isCurrentPermissionsPatch(path55)) {
+  if (typeof field2 === "string" && isCurrentPermissionsPatch(path56)) {
     assignCurrentPermission(settings, field2, patch.value);
     return settings;
   }
-  if (typeof field2 === "string" && isThreadSettingsPatch(path55)) {
+  if (typeof field2 === "string" && isThreadSettingsPatch(path56)) {
     assignSetting(settings, field2, patch.value);
   }
   return settings;
@@ -71419,8 +71570,8 @@ var init_desktop_ipc_thread_view_adapter = __esm({
         if (change.type !== "patches" || next === null || previous === void 0 || next <= previous) return [];
         const patches = array7(change.patches);
         const unknownMembership = patches.some((value) => {
-          const p = record25(value), path55 = array7(p.path);
-          return path55[0] === "turnHistory" && (path55.length < 3 || path55[1] === "history" && (path55[2] === "entitiesByKey" && (path55.length < 4 || path55.length > 4 && ["id", "turnId", "params"].includes(String(path55[4])))));
+          const p = record25(value), path56 = array7(p.path);
+          return path56[0] === "turnHistory" && (path56.length < 3 || path56[1] === "history" && (path56[2] === "entitiesByKey" && (path56.length < 4 || path56.length > 4 && ["id", "turnId", "params"].includes(String(path56[4])))));
         });
         if (next !== previous + 1 || unknownMembership) {
           this.idleHistoryBaselines.delete(context.threadId);
@@ -71430,9 +71581,9 @@ var init_desktop_ipc_thread_view_adapter = __esm({
         const mapped = new Map(this.entityTurnIdsByThread.get(context.threadId));
         const candidates = /* @__PURE__ */ new Set();
         for (const value of patches) {
-          const p = record25(value), path55 = array7(p.path);
-          if (p.op === "remove" && path55.length === 4 && path55[0] === "turnHistory" && path55[1] === "history" && path55[2] === "entitiesByKey") {
-            const id5 = mapped.get(String(path55[3]));
+          const p = record25(value), path56 = array7(p.path);
+          if (p.op === "remove" && path56.length === 4 && path56[0] === "turnHistory" && path56[1] === "history" && path56[2] === "entitiesByKey") {
+            const id5 = mapped.get(String(path56[3]));
             if (id5) candidates.add(id5);
           }
         }
@@ -71443,9 +71594,9 @@ var init_desktop_ipc_thread_view_adapter = __esm({
         })).value;
         const canDelete = typeof newGeneration === "number" && Number.isSafeInteger(newGeneration) && oldGeneration !== void 0 && newGeneration > oldGeneration;
         for (const value of patches) {
-          const p = record25(value), path55 = array7(p.path), entity = record25(p.value);
-          if (path55.length !== 4 || path55[0] !== "turnHistory" || path55[1] !== "history" || path55[2] !== "entitiesByKey") continue;
-          const key = String(path55[3]);
+          const p = record25(value), path56 = array7(p.path), entity = record25(p.value);
+          if (path56.length !== 4 || path56[0] !== "turnHistory" || path56[1] !== "history" || path56[2] !== "entitiesByKey") continue;
+          const key = String(path56[3]);
           if (p.op === "remove") mapped.delete(key);
           else if (p.op === "add" || p.op === "replace") {
             const id5 = nonEmptyString14(entity.id) ?? nonEmptyString14(entity.turnId) ?? nonEmptyString14(record25(entity.params).turnId);
@@ -71571,8 +71722,8 @@ var init_desktop_ipc_thread_view_adapter = __esm({
         const change = record25(record25(frame.params).change);
         for (const rawPatch of array7(change.patches)) {
           const patch = record25(rawPatch);
-          const path55 = array7(patch.path);
-          if ((patch.op === "add" || patch.op === "replace") && (path55.length === 1 && path55[0] === "recencyAt" || path55.length === 2 && path55[0] === "conversationState" && path55[1] === "recencyAt")) {
+          const path56 = array7(patch.path);
+          if ((patch.op === "add" || patch.op === "replace") && (path56.length === 1 && path56[0] === "recencyAt" || path56.length === 2 && path56[0] === "conversationState" && path56[1] === "recencyAt")) {
             this.rememberSidebarRecency(context.threadId, patch.value);
           }
         }
@@ -71658,12 +71809,12 @@ var init_desktop_ipc_thread_view_adapter = __esm({
           requests = structuredClone(requests);
           for (const value of array7(change.patches)) {
             const patch = record25(value);
-            const path55 = array7(patch.path);
-            if (path55[0] !== "requests") continue;
-            if (path55.length === 1) {
+            const path56 = array7(patch.path);
+            if (path56[0] !== "requests") continue;
+            if (path56.length === 1) {
               requests = patch.op === "remove" ? [] : structuredClone(array7(patch.value));
-            } else if (path55.length === 2) {
-              const index = path55[1] === "-" ? requests.length : Number(path55[1]);
+            } else if (path56.length === 2) {
+              const index = path56[1] === "-" ? requests.length : Number(path56[1]);
               if (!Number.isInteger(index) || index < 0 || index > requests.length) continue;
               if (patch.op === "remove") requests.splice(index, 1);
               else if (patch.op === "add") requests.splice(index, 0, structuredClone(patch.value));
@@ -71742,19 +71893,19 @@ var init_desktop_ipc_thread_view_adapter = __esm({
       }
       /** 深层 content 只有局部形状，须等待完整项/快照重新证明；text 更新不能洗掉未知内容。 */
       invalidateReadPatch(patch, context) {
-        const path55 = array7(patch.path);
-        if (path55[0] !== "turnHistory" || path55[1] !== "history" || path55[2] !== "entitiesByKey") return;
-        const turnId = typeof path55[3] === "string" ? this.entityTurnIdsByThread.get(context.threadId)?.get(path55[3]) : null;
-        if (turnId && turnId === this.readTurnByThread.get(context.threadId) && this.activeTurnByThread.get(context.threadId) !== turnId && (path55[4] === "items" || path55.length === 4 && hasOwn2(record25(patch.value), "items"))) {
+        const path56 = array7(patch.path);
+        if (path56[0] !== "turnHistory" || path56[1] !== "history" || path56[2] !== "entitiesByKey") return;
+        const turnId = typeof path56[3] === "string" ? this.entityTurnIdsByThread.get(context.threadId)?.get(path56[3]) : null;
+        if (turnId && turnId === this.readTurnByThread.get(context.threadId) && this.activeTurnByThread.get(context.threadId) !== turnId && (path56[4] === "items" || path56.length === 4 && hasOwn2(record25(patch.value), "items"))) {
           for (const identity7 of this.nativeReadIdentities.get(context.threadId)?.values() ?? []) {
             if (identity7.turnId === turnId) identity7.complete = false;
           }
           return;
         }
-        if (path55[4] !== "items" || path55[6] !== "content") return;
+        if (path56[4] !== "items" || path56[6] !== "content") return;
         const order = this.itemOrders.get(context.threadId);
-        if (!order || order.entityKey !== path55[3]) return;
-        const id5 = typeof path55[5] === "number" ? order.ids[path55[5]] : null;
+        if (!order || order.entityKey !== path56[3]) return;
+        const id5 = typeof path56[5] === "number" ? order.ids[path56[5]] : null;
         const identity6 = id5 ? this.nativeReadIdentities.get(context.threadId)?.get(id5) : null;
         if (identity6) identity6.complete = false;
         else if (!id5) {
@@ -71778,19 +71929,19 @@ var init_desktop_ipc_thread_view_adapter = __esm({
       /** 在同一 Store 事务内先更新正文，再发布可信顺序，不让 Web 看见暂存的中间帧。 */
       itemOrderEvents(patch, itemEvents, context) {
         if (this.itemOrderGaps.has(context.threadId)) return [];
-        const path55 = array7(patch.path);
-        if (path55[0] !== "turnHistory") return [];
+        const path56 = array7(patch.path);
+        if (path56[0] !== "turnHistory") return [];
         const invalidate = () => {
           this.itemOrders.delete(context.threadId);
           this.itemOrderGaps.add(context.threadId);
           return [];
         };
-        if (path55.length < 3) return invalidate();
-        if (path55[1] !== "history" || path55[2] !== "entitiesByKey") return [];
-        if (path55.length < 4) return invalidate();
+        if (path56.length < 3) return invalidate();
+        if (path56[1] !== "history" || path56[2] !== "entitiesByKey") return [];
+        if (path56.length < 4) return invalidate();
         const activeId = this.activeTurnByThread.get(context.threadId);
         if (!activeId) return [];
-        const entityKey = String(path55[3]);
+        const entityKey = String(path56[3]);
         const events = [];
         const emitItem = (value) => {
           const item = this.orderedRawItem(value, activeId, context);
@@ -71807,8 +71958,8 @@ var init_desktop_ipc_thread_view_adapter = __esm({
           return item?.id ?? null;
         };
         let order = this.itemOrders.get(context.threadId);
-        const wholeEntity = path55.length === 4;
-        const wholeArray = path55.length === 5 && path55[4] === "items";
+        const wholeEntity = path56.length === 4;
+        const wholeArray = path56.length === 5 && path56[4] === "items";
         if (wholeEntity || wholeArray) {
           const entity = record25(patch.value);
           const turnId = wholeEntity ? nonEmptyString14(entity.id) ?? nonEmptyString14(entity.turnId) : this.entityTurnIdsByThread.get(context.threadId)?.get(entityKey);
@@ -71824,12 +71975,12 @@ var init_desktop_ipc_thread_view_adapter = __esm({
           }
           values.forEach(emitItem);
         } else {
-          if (!order || order.turnId !== activeId || order.entityKey !== entityKey || path55[4] !== "items") return [];
-          if (path55.length > 6) {
-            return ["id", "type"].includes(String(path55[6])) ? invalidate() : [];
+          if (!order || order.turnId !== activeId || order.entityKey !== entityKey || path56[4] !== "items") return [];
+          if (path56.length > 6) {
+            return ["id", "type"].includes(String(path56[6])) ? invalidate() : [];
           }
-          if (path55.length !== 6 || !["add", "replace", "remove"].includes(String(patch.op))) return invalidate();
-          const index = path55[5] === "-" && patch.op === "add" ? order.ids.length : path55[5];
+          if (path56.length !== 6 || !["add", "replace", "remove"].includes(String(patch.op))) return invalidate();
+          const index = path56[5] === "-" && patch.op === "add" ? order.ids.length : path56[5];
           if (typeof index !== "number" || !Number.isSafeInteger(index) || index < 0 || index > order.ids.length || patch.op !== "add" && index === order.ids.length) return invalidate();
           if (patch.op === "add" && order.ids.length >= 8192) return invalidate();
           const previousId = order.ids[index];
@@ -72050,12 +72201,12 @@ var init_desktop_ipc_thread_view_adapter = __esm({
         for (const patchValue of patches) {
           const patch = record25(patchValue);
           if (patch.op !== "add" && patch.op !== "replace") continue;
-          const path55 = array7(patch.path);
-          if (path55[0] !== "turnHistory" || path55[1] !== "history" || path55[2] !== "entitiesByKey" || typeof path55[3] !== "string") continue;
-          const entityKey = path55[3];
-          const wholeEntity = path55.length === 4;
-          const statusField = path55.length === 5 && path55[4] === "status";
-          const startField = path55.length === 5 && path55[4] === "turnStartedAtMs";
+          const path56 = array7(patch.path);
+          if (path56[0] !== "turnHistory" || path56[1] !== "history" || path56[2] !== "entitiesByKey" || typeof path56[3] !== "string") continue;
+          const entityKey = path56[3];
+          const wholeEntity = path56.length === 4;
+          const statusField = path56.length === 5 && path56[4] === "status";
+          const startField = path56.length === 5 && path56[4] === "turnStartedAtMs";
           if (!wholeEntity && !statusField && !startField) continue;
           const entity = wholeEntity ? record25(patch.value) : {};
           const turnId = wholeEntity ? nonEmptyString14(entity.id) ?? nonEmptyString14(entity.turnId) ?? entityTurnIds.get(entityKey) ?? null : entityTurnIds.get(entityKey) ?? null;
@@ -72238,7 +72389,7 @@ var init_desktop_ipc_thread_view_adapter = __esm({
 });
 
 // apps/desktop/src/daemon/thread-view-files.ts
-import { createHash as createHash30 } from "node:crypto";
+import { createHash as createHash31 } from "node:crypto";
 function normalizeFileCitations(text11, paths) {
   if (!text11.includes(":codex-file-citation{")) return text11;
   const edits = [];
@@ -72260,12 +72411,12 @@ function normalizeFileCitations(text11, paths) {
     const end = start + match[0].length;
     if (!textRanges.some(([a, b]) => a <= start && start < b) || excluded.some(([a, b]) => a < end && b > start)) continue;
     const slashes = text11.slice(0, start).match(/\\*$/u)?.[0].length ?? 0;
-    const path55 = match[1];
-    if (slashes % 2 || paths.parseLocal(path55) === null) continue;
+    const path56 = match[1];
+    if (slashes % 2 || paths.parseLocal(path56) === null) continue;
     try {
-      const target = paths.toLink(path55);
+      const target = paths.toLink(path56);
       if (target === null) continue;
-      const label = fallbackFileName(path55, paths).replace(/[\\`*_[\]<> &]/gu, (value) => `&#${value.codePointAt(0)};`);
+      const label = fallbackFileName(path56, paths).replace(/[\\`*_[\]<> &]/gu, (value) => `&#${value.codePointAt(0)};`);
       edits.push({ start, end, value: `[${label}](<${target}>)` });
     } catch {
     }
@@ -72283,9 +72434,9 @@ function fileReferences(text11, paths) {
   return markdownTargets(text11).references.filter((ref) => !ref.image).flatMap((ref) => {
     try {
       const target = withoutFileLocation(ref.url);
-      const path55 = paths.parseLink(target);
-      if (path55 === null) return [];
-      return [{ ...ref, path: path55 }];
+      const path56 = paths.parseLink(target);
+      if (path56 === null) return [];
+      return [{ ...ref, path: path56 }];
     } catch {
       return [];
     }
@@ -72295,8 +72446,8 @@ function collectFileLinkPaths(item, paths = localResourcePaths) {
   if (item.type !== "assistant_message") return [];
   return [...new Set(item.content.flatMap((part) => part.type === "text" ? fileReferences(normalizeFileCitations(part.text, paths), paths).map((ref) => ref.path) : []))];
 }
-function fallbackFileName(path55, paths) {
-  const name2 = paths.basename(path55).slice(0, 255);
+function fallbackFileName(path56, paths) {
+  const name2 = paths.basename(path56).slice(0, 255);
   return name2.trim() && !/[\\/\x00-\x1f\x7f-\x9f]/u.test(name2) ? name2 : "\u6587\u4EF6";
 }
 function projectFileLinks(item, register, isRegistered = () => true, paths = localResourcePaths) {
@@ -72306,7 +72457,7 @@ function projectFileLinks(item, register, isRegistered = () => true, paths = loc
   const original = item.content.map((part) => {
     if (part.type !== "file" || !part.attachment_id || isRegistered(part.attachment_id)) return part;
     const { attachment_id: id5, ...unavailable12 } = part;
-    retired.set(`niuma-file:${id5}`, `niuma-file:unavailable_${createHash30("sha256").update(id5).digest("hex")}`);
+    retired.set(`niuma-file:${id5}`, `niuma-file:unavailable_${createHash31("sha256").update(id5).digest("hex")}`);
     return unavailable12;
   });
   const content2 = original.map((part) => {
@@ -72315,7 +72466,7 @@ function projectFileLinks(item, register, isRegistered = () => true, paths = loc
     const targets = new Map(retired);
     for (const ref of fileReferences(text11, paths)) {
       const registered = register(ref.path);
-      const id5 = registered?.attachmentId ?? `unavailable_${createHash30("sha256").update(JSON.stringify([item.id, ref.path])).digest("hex")}`;
+      const id5 = registered?.attachmentId ?? `unavailable_${createHash31("sha256").update(JSON.stringify([item.id, ref.path])).digest("hex")}`;
       targets.set(ref.url, `niuma-file:${id5}`);
       if (!files.has(id5)) files.set(id5, {
         type: "file",
@@ -72359,8 +72510,8 @@ var init_thread_view_files = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/projection.ts
-import { createHash as createHash31 } from "node:crypto";
-import path38 from "node:path";
+import { createHash as createHash32 } from "node:crypto";
+import path39 from "node:path";
 var FILE_REFRESH_MAX_ENTRIES, FILE_REFRESH_MAX_BYTES, FILE_REFRESH_ENTRY_BYTES, FILE_REFRESH_IN_FLIGHT_RESERVE, RuntimeProjection;
 var init_projection2 = __esm({
   "apps/desktop/src/daemon/runtime/projection.ts"() {
@@ -72407,7 +72558,7 @@ var init_projection2 = __esm({
             }
             pendingRetirements.set(threadId2, {
               itemId,
-              fingerprint: createHash31("sha256").update(JSON.stringify(item)).digest("hex"),
+              fingerprint: createHash32("sha256").update(JSON.stringify(item)).digest("hex"),
               isCurrent: this.ports.captureFileResourceSource(threadId2)
             });
             if (alreadyPending) return;
@@ -72416,7 +72567,7 @@ var init_projection2 = __esm({
               pendingRetirements.delete(threadId2);
               if (!retired?.isCurrent()) return;
               const current2 = viewStore2.getProjectionItem(threadId2, retired.itemId);
-              if (!current2 || createHash31("sha256").update(JSON.stringify(current2)).digest("hex") !== retired.fingerprint) return;
+              if (!current2 || createHash32("sha256").update(JSON.stringify(current2)).digest("hex") !== retired.fingerprint) return;
               viewStore2.refreshResourceProjection(threadId2);
             });
           }
@@ -72492,14 +72643,14 @@ var init_projection2 = __esm({
       isFileReferenceVisible(entry) {
         if (this.ports.stopping()) return false;
         const root = this.ports.projectRoot(entry.threadId);
-        if (!root || path38.resolve(root) !== entry.root) return false;
+        if (!root || path39.resolve(root) !== entry.root) return false;
         const item = this.store.getProjectionItem(entry.threadId, entry.itemId);
         if (!item) return false;
         if (item.type === "user_message") {
-          return this.store.nativeFileSources(entry.threadId, entry.itemId).some((source2) => item.content[source2.index]?.type === "file" && path38.resolve(source2.path) === entry.path);
+          return this.store.nativeFileSources(entry.threadId, entry.itemId).some((source2) => item.content[source2.index]?.type === "file" && path39.resolve(source2.path) === entry.path);
         }
         if (item.type !== "assistant_message") return false;
-        if (collectFileLinkPaths(item).some((sourcePath) => path38.resolve(sourcePath) === entry.path)) return true;
+        if (collectFileLinkPaths(item).some((sourcePath) => path39.resolve(sourcePath) === entry.path)) return true;
         return item.content.some((part) => part.type === "file" && part.attachment_id === entry.attachmentId) && hasFileAttachmentLink(item, entry.attachmentId);
       }
       subagentAvatars = new CodexSubagentAvatars();
@@ -73863,7 +74014,7 @@ var init_thread_read_receipts2 = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/read-receipts.ts
-import { createHash as createHash32 } from "node:crypto";
+import { createHash as createHash33 } from "node:crypto";
 function nowSeconds14() {
   return Math.floor(Date.now() / 1e3);
 }
@@ -74037,8 +74188,8 @@ var init_read_receipts = __esm({
             return;
           }
           const statusOnly = change.type === "patches" && Array.isArray(change.patches) && change.patches.length > 0 && change.patches.every((value) => {
-            const patch = objectRecord3(value), path55 = Array.isArray(patch.path) ? patch.path : [];
-            const fields3 = path55[0] === "conversationState" ? path55.slice(1) : path55;
+            const patch = objectRecord3(value), path56 = Array.isArray(patch.path) ? patch.path : [];
+            const fields3 = path56[0] === "conversationState" ? path56.slice(1) : path56;
             if (!["add", "replace", "remove"].includes(String(patch.op)) || fields3.length !== 1) return false;
             if (fields3[0] === "threadRuntimeStatus") return true;
             return patch.op !== "remove" && (fields3[0] === "hasUnreadTurn" && patch.value === raw?.hasUnreadTurn || fields3[0] === "unreadMessageCount" && patch.value === raw?.unreadMessageCount);
@@ -74121,7 +74272,7 @@ var init_read_receipts = __esm({
         this.publishThreadReadChange(threadId2);
       }
       async initialize(codexHome, receiptPath, diagnostics = false) {
-        this.namespace = createHash32("sha256").update(codexHome).digest("hex");
+        this.namespace = createHash33("sha256").update(codexHome).digest("hex");
         this.receipts = new ThreadReadReceipts(
           new ReadReceiptStore(
             this.namespace,
@@ -74583,7 +74734,7 @@ var init_message_submission_attempt = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/submission.ts
-import { createHash as createHash33 } from "node:crypto";
+import { createHash as createHash34 } from "node:crypto";
 var RuntimeSubmission;
 var init_submission2 = __esm({
   "apps/desktop/src/daemon/runtime/submission.ts"() {
@@ -74778,7 +74929,7 @@ var init_submission2 = __esm({
           const reservation = await store.reserve({
             ...key,
             nativeToken: clientMessageId,
-            fingerprint: createHash33("sha256").update(JSON.stringify(content2)).digest("hex")
+            fingerprint: createHash34("sha256").update(JSON.stringify(content2)).digest("hex")
           });
           if (!reservation.dispatch) {
             existingSubmission = true;
@@ -76313,7 +76464,7 @@ var init_image_decoder = __esm({
 });
 
 // apps/desktop/src/attachments/image-assets.ts
-import path39 from "node:path";
+import path40 from "node:path";
 function names(id5) {
   if (!idPattern.test(id5)) throw unavailable9();
   return { metadata: `img_${id5.slice(4)}`, source: `src_${id5.slice(4)}`, preview: `prv_${id5.slice(4)}` };
@@ -76360,7 +76511,7 @@ var init_image_assets = __esm({
       }
       paths(id5) {
         const n = names(id5);
-        return { sourcePath: path39.join(this.root, n.source, "source"), previewPath: path39.join(this.root, n.preview, "source") };
+        return { sourcePath: path40.join(this.root, n.source, "source"), previewPath: path40.join(this.root, n.preview, "source") };
       }
       asset(id5) {
         const value = this.assets.get(id5);
@@ -76492,7 +76643,7 @@ import { constants as constants5 } from "node:fs";
 import { chmod as chmod2, lstat as lstat5, mkdir as mkdir2, open as open6 } from "node:fs/promises";
 import { execFile as execFile11 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import path40 from "node:path";
+import path41 from "node:path";
 async function preparePrivateImageRoot(directory) {
   if (process.platform === "win32") {
     await ensureWindowsPrivateDirectoryAsync(directory);
@@ -76508,7 +76659,7 @@ async function createPrivateImageDirectory(directory) {
     return;
   }
   directory = localWindowsPath(directory);
-  const parent = await openPrivateImageDirectory(path40.dirname(directory));
+  const parent = await openPrivateImageDirectory(path41.dirname(directory));
   try {
     await parent.verify();
     await mkdir2(directory, { mode: 448 });
@@ -76531,7 +76682,7 @@ Check-PrivateDirectory $env:NIUMA_IMAGE_DIRECTORY
 }
 async function openPrivateImageDirectory(requested, openFile2 = open6) {
   const windows2 = process.platform === "win32";
-  const directory = windows2 ? localWindowsPath(requested) : path40.resolve(requested);
+  const directory = windows2 ? localWindowsPath(requested) : path41.resolve(requested);
   const initial = await lstat5(directory, { bigint: true });
   if (!initial.isDirectory() || initial.isSymbolicLink()) throw unavailable10();
   let handle;
@@ -76640,7 +76791,7 @@ var init_private_image_files = __esm({
 // apps/desktop/src/platform/private-image-commit.ts
 import { randomUUID as randomUUID45 } from "node:crypto";
 import { lstat as lstat6, rename as rename2, rm as rm2 } from "node:fs/promises";
-import path41 from "node:path";
+import path42 from "node:path";
 async function snapshot(file, maxBytes) {
   try {
     await lstat6(file);
@@ -76705,7 +76856,7 @@ var init_private_image_commit = __esm({
             await this.writeBinary(file, bytes3, maxBytes);
             return;
           }
-          const directory = await openPrivateImageDirectory(path41.dirname(file));
+          const directory = await openPrivateImageDirectory(path42.dirname(file));
           try {
             const handle = await privateBinaryFiles.open(file, { maxBytes, writable: true, mode: "mutable" });
             try {
@@ -76740,7 +76891,7 @@ var init_private_image_commit = __esm({
         }
       },
       async writeBinary(file, bytes3, maxBytes) {
-        const directory = await openPrivateImageDirectory(path41.dirname(file));
+        const directory = await openPrivateImageDirectory(path42.dirname(file));
         try {
           await directory.verify();
           await writeNew(file, bytes3, maxBytes);
@@ -76753,8 +76904,8 @@ var init_private_image_commit = __esm({
         const bytes3 = Buffer.from(input);
         let published = false, renameAttempted = false;
         let temporaryIdentity;
-        const directory = await openPrivateImageDirectory(path41.dirname(file));
-        const temporary = path41.join(path41.dirname(file), `.manifest-${randomUUID45()}.tmp`);
+        const directory = await openPrivateImageDirectory(path42.dirname(file));
+        const temporary = path42.join(path42.dirname(file), `.manifest-${randomUUID45()}.tmp`);
         try {
           if (bytes3.length > maxBytes) throw new PrivateImageCommitError();
           new TextDecoder("utf-8", { fatal: true }).decode(bytes3);
@@ -76802,14 +76953,14 @@ var init_private_image_commit = __esm({
 });
 
 // apps/desktop/src/platform/private-document-directory.ts
-import fs26 from "node:fs";
-import path42 from "node:path";
+import fs27 from "node:fs";
+import path43 from "node:path";
 async function openPrivateDocumentDirectory(root) {
-  const directory = path42.resolve(root);
+  const directory = path43.resolve(root);
   let identity6;
   try {
     privateLogFiles.ensureDirectory(directory);
-    identity6 = fs26.lstatSync(directory, { bigint: true });
+    identity6 = fs27.lstatSync(directory, { bigint: true });
     privateLogFiles.checkDirectory(directory);
     guard();
   } catch {
@@ -76817,7 +76968,7 @@ async function openPrivateDocumentDirectory(root) {
   }
   function guard() {
     try {
-      const current2 = fs26.lstatSync(directory, { bigint: true });
+      const current2 = fs27.lstatSync(directory, { bigint: true });
       if (!current2.isDirectory() || current2.isSymbolicLink() || current2.dev !== identity6.dev || current2.ino !== identity6.ino) {
         throw new PrivateDocumentFileError("unavailable");
       }
@@ -76830,7 +76981,7 @@ async function openPrivateDocumentDirectory(root) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/u.test(name2) || name2 === "." || name2 === "..") {
       throw new PrivateDocumentFileError("unavailable");
     }
-    return path42.join(directory, name2);
+    return path43.join(directory, name2);
   }
   const files = privateStateFilesWithGuard(guard);
   return {
@@ -76862,7 +77013,7 @@ var init_private_document_directory = __esm({
 });
 
 // apps/desktop/src/attachments/store.ts
-import { createHash as createHash34, randomUUID as randomUUID46 } from "node:crypto";
+import { createHash as createHash35, randomUUID as randomUUID46 } from "node:crypto";
 import { constants as constants6 } from "node:fs";
 import {
   chmod as chmod3,
@@ -76912,38 +77063,38 @@ function decodeBase64(value) {
   return decoded;
 }
 function sha256(value) {
-  return createHash34("sha256").update(value).digest("hex");
+  return createHash35("sha256").update(value).digest("hex");
 }
-async function readJsonManifest(path55, io) {
+async function readJsonManifest(path56, io) {
   try {
     if (io.controlledFiles) {
-      const { data } = await io.controlledFiles.read(path55);
+      const { data } = await io.controlledFiles.read(path56);
       return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(data));
     }
-    const status2 = await lstat7(path55);
+    const status2 = await lstat7(path56);
     if (!status2.isFile() || status2.isSymbolicLink()) {
       return null;
     }
-    return JSON.parse(await readFile2(path55, "utf8"));
+    return JSON.parse(await readFile2(path56, "utf8"));
   } catch {
     return null;
   }
 }
-async function assertRegularControlledFile(directoryPath, path55) {
-  if (dirname3(path55) !== directoryPath) {
+async function assertRegularControlledFile(directoryPath, path56) {
+  if (dirname3(path56) !== directoryPath) {
     throw new Error("ATTACHMENT_PATH_OUTSIDE_ROOT");
   }
-  const status2 = await lstat7(path55).catch(() => null);
+  const status2 = await lstat7(path56).catch(() => null);
   if (!status2?.isFile() || status2.isSymbolicLink()) {
     throw new Error("ATTACHMENT_FILE_NOT_AVAILABLE");
   }
 }
-async function readRegularFileNoFollow(io, directoryPath, path55, expectedIdentity, expectedSize) {
-  if (dirname3(path55) !== directoryPath) {
+async function readRegularFileNoFollow(io, directoryPath, path56, expectedIdentity, expectedSize) {
+  if (dirname3(path56) !== directoryPath) {
     throw new Error("ATTACHMENT_PATH_OUTSIDE_ROOT");
   }
-  if (io.controlledFiles) return io.controlledFiles.read(path55, expectedIdentity, expectedSize);
-  const handle = await io.open(path55, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
+  if (io.controlledFiles) return io.controlledFiles.read(path56, expectedIdentity, expectedSize);
+  const handle = await io.open(path56, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
   if (!handle) {
     throw new Error("ATTACHMENT_FILE_NOT_AVAILABLE");
   }
@@ -76967,8 +77118,8 @@ async function readRegularFileNoFollow(io, directoryPath, path55, expectedIdenti
     await handle.close();
   }
 }
-async function readStableLocalFile(io, path55) {
-  const handle = await io.open(path55, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
+async function readStableLocalFile(io, path56) {
+  const handle = await io.open(path56, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
   if (!handle) {
     throw new Error("LOCAL_IMAGE_NOT_REGULAR_FILE");
   }
@@ -76980,8 +77131,8 @@ async function readStableLocalFile(io, path55) {
     if (openedStatus.size > BigInt(MAX_IMAGE_BYTES)) {
       throw new Error("ATTACHMENT_TOO_LARGE");
     }
-    const canonicalPath = await realpath3(path55).catch(() => null);
-    const currentStatus = await lstat7(path55, { bigint: true }).catch(() => null);
+    const canonicalPath = await realpath3(path56).catch(() => null);
+    const currentStatus = await lstat7(path56, { bigint: true }).catch(() => null);
     if (!canonicalPath || !currentStatus?.isFile() || currentStatus.isSymbolicLink() || currentStatus.dev !== openedStatus.dev || currentStatus.ino !== openedStatus.ino) {
       throw new Error("LOCAL_IMAGE_NOT_REGULAR_FILE");
     }
@@ -76994,17 +77145,17 @@ async function readStableLocalFile(io, path55) {
     await handle.close();
   }
 }
-async function pathIsMissing(path55) {
+async function pathIsMissing(path56) {
   try {
-    await lstat7(path55);
+    await lstat7(path56);
     return false;
   } catch (error2) {
     return error2.code === "ENOENT";
   }
 }
-async function readFileIdentity(io, path55) {
-  if (io.controlledFiles) return io.controlledFiles.identity(path55);
-  const handle = await io.open(path55, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
+async function readFileIdentity(io, path56) {
+  if (io.controlledFiles) return io.controlledFiles.identity(path56);
+  const handle = await io.open(path56, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
   if (!handle) {
     throw new Error("ATTACHMENT_FILE_NOT_AVAILABLE");
   }
@@ -77119,7 +77270,7 @@ var init_store = __esm({
       webp: "image/webp"
     };
     DEFAULT_ATTACHMENT_STORE_IO = {
-      open: (path55, flags) => open7(path55, flags),
+      open: (path56, flags) => open7(path56, flags),
       controlledFiles: privateImageFiles
     };
     AttachmentStore = class _AttachmentStore {
@@ -77332,15 +77483,15 @@ var init_store = __esm({
             const allowed = /* @__PURE__ */ new Set([MANIFEST_RELATIVE_PATH, ...next.chunks.map((chunk) => chunk.relativePath)]);
             if ((await readdir2(upload.directoryPath)).some((name2) => !allowed.has(name2))) throw new Error("UPLOAD_DIRECTORY_NOT_VERIFIED");
             for (let offset = 0; offset < chunks.length; offset++) {
-              const path55 = join2(upload.directoryPath, `chunk-${input.startIndex + offset}`), chunk = chunks[offset];
+              const path56 = join2(upload.directoryPath, `chunk-${input.startIndex + offset}`), chunk = chunks[offset];
               let handle;
               try {
-                handle = await this.#io.open(path55, constants6.O_WRONLY | constants6.O_CREAT | constants6.O_EXCL | constants6.O_NOFOLLOW);
+                handle = await this.#io.open(path56, constants6.O_WRONLY | constants6.O_CREAT | constants6.O_EXCL | constants6.O_NOFOLLOW);
               } catch (error2) {
                 if (error2.code !== "EEXIST") throw error2;
-                const stored = await readRegularFileNoFollow(this.#io, upload.directoryPath, path55, void 0, chunk.length);
+                const stored = await readRegularFileNoFollow(this.#io, upload.directoryPath, path56, void 0, chunk.length);
                 if (!stored.data.equals(chunk)) throw new Error("CHUNK_CONFLICT");
-                handle = await this.#io.open(path55, constants6.O_RDONLY | constants6.O_NOFOLLOW);
+                handle = await this.#io.open(path56, constants6.O_RDONLY | constants6.O_NOFOLLOW);
               }
               try {
                 const status2 = await handle.stat();
@@ -77446,7 +77597,7 @@ var init_store = __esm({
           if (!await this.#isVerifiedUpload(upload)) throw new Error("UPLOAD_DIRECTORY_NOT_VERIFIED");
           const chunks = [...upload.manifest.chunks].sort((a, b) => a.index - b.index);
           if (chunks.length !== Math.ceil(upload.manifest.byteSize / MAX_CHUNK_BYTES) || chunks.some((chunk, i) => chunk.index !== i)) throw new Error("UPLOAD_SIZE_MISMATCH");
-          const hash3 = createHash34("sha256");
+          const hash3 = createHash35("sha256");
           for (const chunk of chunks) {
             hash3.update(await this.#readUploadChunk(upload, chunk));
           }
@@ -77720,9 +77871,9 @@ var init_store = __esm({
                 await this.#imageAssets.removeBytes(record26.id);
                 continue;
               }
-              for (const path55 of [record26.sourcePath, record26.previewPath]) {
-                const status2 = await lstat7(path55).catch(() => null);
-                if (status2?.isFile() && !status2.isSymbolicLink()) await rm3(path55);
+              for (const path56 of [record26.sourcePath, record26.previewPath]) {
+                const status2 = await lstat7(path56).catch(() => null);
+                if (status2?.isFile() && !status2.isSymbolicLink()) await rm3(path56);
               }
             }
           }
@@ -78260,10 +78411,10 @@ var init_store = __esm({
         return bytes3;
       }
       async #loadBindingIndex() {
-        const path55 = join2(this.#rootDir, BINDINGS_RELATIVE_PATH);
-        const manifest = this.#bindingDocuments ? JSON.parse(await this.#bindingDocuments.read(BINDINGS_RELATIVE_PATH, 16 * 1024 * 1024) ?? "null") : await readJsonManifest(path55, this.#io);
+        const path56 = join2(this.#rootDir, BINDINGS_RELATIVE_PATH);
+        const manifest = this.#bindingDocuments ? JSON.parse(await this.#bindingDocuments.read(BINDINGS_RELATIVE_PATH, 16 * 1024 * 1024) ?? "null") : await readJsonManifest(path56, this.#io);
         if (manifest === null) {
-          if (this.#rawCommit && !await pathIsMissing(path55)) this.#bindingUnavailable = true;
+          if (this.#rawCommit && !await pathIsMissing(path56)) this.#bindingUnavailable = true;
           return;
         }
         if (!isBindingIndexManifest(manifest)) {
@@ -78323,14 +78474,14 @@ var init_store = __esm({
           return;
         }
         const temporaryPath = join2(this.#rootDir, `.bindings-${randomUUID46()}.tmp`);
-        const path55 = join2(this.#rootDir, BINDINGS_RELATIVE_PATH);
+        const path56 = join2(this.#rootDir, BINDINGS_RELATIVE_PATH);
         await writeFile(temporaryPath, `${JSON.stringify(manifest)}
 `, {
           flag: "wx",
           mode: 384
         });
-        await rename3(temporaryPath, path55);
-        await chmod3(path55, 384);
+        await rename3(temporaryPath, path56);
+        await chmod3(path56, 384);
       }
       #commitBindings(bindings) {
         this.#bindings.clear();
@@ -78906,7 +79057,7 @@ var init_message_bindings = __esm({
 });
 
 // apps/desktop/src/attachments/managed-store.ts
-import { createHash as createHash35, randomUUID as randomUUID47 } from "node:crypto";
+import { createHash as createHash36, randomUUID as randomUUID47 } from "node:crypto";
 function storedIdentity(identity6) {
   return identity6.kind === "native" ? identity6.file : identity6;
 }
@@ -78965,7 +79116,7 @@ var init_managed_store = __esm({
     refPattern = /^(?:attf_|att_)[0-9a-f-]{36}$/;
     digestPattern = /^[0-9a-f]{64}$/;
     error = (kind) => new Error("MANAGED_ATTACHMENT_" + kind);
-    digest3 = (bytes3) => createHash35("sha256").update(bytes3).digest("hex");
+    digest3 = (bytes3) => createHash36("sha256").update(bytes3).digest("hex");
     ManagedAttachmentStore = class _ManagedAttachmentStore {
       constructor(contents, now, sourceFiles) {
         this.contents = contents;
@@ -79224,7 +79375,7 @@ var init_managed_store = __esm({
         await this.mutate(async () => {
           const entry = this.entryForUpload(threadId2, uploadId), m = entry.manifest;
           if (m.createdAt + HOUR <= this.now() || Object.keys(m.chunks).length !== Math.ceil(m.byteSize / 49152)) throw error("INVALID");
-          const h = await this.sourceHandle(entry), hash3 = createHash35("sha256");
+          const h = await this.sourceHandle(entry), hash3 = createHash36("sha256");
           await withBinaryHandle(h, async () => {
             if ((await h.status()).size !== m.byteSize) throw error("INVALID");
             const block = Buffer.alloc(49152);
@@ -79258,7 +79409,7 @@ var init_managed_store = __esm({
           }
           if (m.createdAt + HOUR <= this.now() || Object.keys(m.chunks).length !== Math.ceil(m.byteSize / 49152)) throw error("INVALID");
           const h = await this.sourceHandle(entry);
-          const hash3 = createHash35("sha256");
+          const hash3 = createHash36("sha256");
           await withBinaryHandle(h, async () => {
             const status2 = await h.status();
             if (status2.size !== m.byteSize) throw error("INVALID");
@@ -79442,7 +79593,7 @@ var init_managed_store = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/attachment-storage.ts
-import path43 from "node:path";
+import path44 from "node:path";
 import { randomUUID as randomUUID48 } from "node:crypto";
 var ATTACHMENT_CLEANUP_INTERVAL_MS, RuntimeAttachmentStorage;
 var init_attachment_storage = __esm({
@@ -79584,7 +79735,7 @@ var init_attachment_storage = __esm({
       requireAttachmentMessageBindings() {
         if (!this.attachmentCodexHome) throw new NiumaError("SYSTEM_ERROR", "\u9644\u4EF6\u5B58\u50A8\u5C1A\u672A\u521D\u59CB\u5316");
         if (!this.attachmentMessageBindingsPromise) {
-          this.attachmentMessageBindingsPromise = AttachmentMessageBindings.open(path43.join(this.ports.dataDirectory(), "attachments", "bindings")).then((store) => {
+          this.attachmentMessageBindingsPromise = AttachmentMessageBindings.open(path44.join(this.ports.dataDirectory(), "attachments", "bindings")).then((store) => {
             this.attachmentMessageBindings = store;
             return store;
           }).catch((error2) => {
@@ -79600,7 +79751,7 @@ var init_attachment_storage = __esm({
         if (!this.attachmentCodexHome) throw new NiumaError("SYSTEM_ERROR", "\u9644\u4EF6\u5B58\u50A8\u5C1A\u672A\u521D\u59CB\u5316");
         if (!this.managedAttachmentStorePromise) {
           const opening = runManagedAttachmentOperation(() => ManagedAttachmentStore.open(
-            path43.join(this.ports.dataDirectory(), "attachments", "managed")
+            path44.join(this.ports.dataDirectory(), "attachments", "managed")
           )).catch((error2) => {
             if (this.managedAttachmentStorePromise === opening) this.managedAttachmentStorePromise = null;
             throw error2;
@@ -80660,7 +80811,7 @@ var init_daemon_metrics_store = __esm({
 });
 
 // apps/desktop/src/daemon/daemon-metrics.ts
-import os3 from "node:os";
+import os4 from "node:os";
 import process7 from "node:process";
 function roundMetric(value) {
   return Math.round(value * 10) / 10;
@@ -80709,7 +80860,7 @@ var init_daemon_metrics = __esm({
         this.nowMs = options.nowMs ?? (() => Date.now());
         this.cpuUsage = options.cpuUsage ?? (() => process7.cpuUsage());
         this.memoryUsage = options.memoryUsage ?? (() => process7.memoryUsage());
-        this.cpuCount = Math.max(1, options.cpuCount ?? os3.cpus().length);
+        this.cpuCount = Math.max(1, options.cpuCount ?? os4.cpus().length);
         this.pid = options.pid ?? process7.pid;
         this.sampleIntervalMs = options.sampleIntervalMs ?? DAEMON_METRICS_SAMPLE_INTERVAL_MS;
         this.retentionMs = Math.min(options.retentionMs ?? DAEMON_METRICS_RETENTION_MS, DAEMON_METRICS_RETENTION_MS);
@@ -80962,7 +81113,7 @@ var init_control_read = __esm({
 });
 
 // apps/desktop/src/attachments/image-resources.ts
-import { createHash as createHash36, randomUUID as randomUUID49 } from "node:crypto";
+import { createHash as createHash37, randomUUID as randomUUID49 } from "node:crypto";
 import { constants as constants7 } from "node:fs";
 import { lstat as lstat8, open as open8, realpath as realpath4 } from "node:fs/promises";
 import { basename as basename4, dirname as dirname4 } from "node:path";
@@ -80997,9 +81148,9 @@ function sameDeferredIdentity(source2, previous) {
   if (source2.kind === "history") return previous.kind === "history" && sameLocator(source2.locator, previous.locator);
   return source2.kind === "deferred-file" && Boolean(source2.visibilityLocator) && previous.kind !== "history" && previous.kind !== "app-server-image" && (previous.kind === "file" || source2.path === previous.path) && sameLocator(source2.visibilityLocator, previous.visibilityLocator);
 }
-async function readSourceFile(path55, signal) {
+async function readSourceFile(path56, signal) {
   signal?.throwIfAborted();
-  const handle = await open8(path55, constants7.O_RDONLY | constants7.O_NOFOLLOW);
+  const handle = await open8(path56, constants7.O_RDONLY | constants7.O_NOFOLLOW);
   try {
     const before = await handle.stat({ bigint: true });
     if (!before.isFile() || before.size <= 0 || before.size > MAX_BYTES9) throw new NiumaError("ATTACHMENT_RESOURCE_LIMIT", "\u56FE\u7247\u8BFB\u53D6\u8D85\u51FA\u8D44\u6E90\u9650\u5236");
@@ -81056,7 +81207,7 @@ var init_image_resources = __esm({
     INDEX_BYTES = 16 * 1024 * 1024;
     CHUNK_BYTES2 = 256 * 1024;
     ID = /^att_[0-9a-f-]{36}$/;
-    digest4 = (bytes3) => createHash36("sha256").update(bytes3).digest("hex");
+    digest4 = (bytes3) => createHash37("sha256").update(bytes3).digest("hex");
     hashSchema = z16.string().regex(/^[0-9a-f]{64}$/);
     natural = z16.number().int().nonnegative();
     absolutePath = z16.string().max(16384).refine((value) => localResourcePaths.parseLocal(value) !== null);
@@ -81228,12 +81379,12 @@ var init_image_resources = __esm({
         }, JSON.stringify(identity6));
       }
       /** 仅供已认证实时消息登记；调用方每次请求仍须验证当前 item/上传暂存资格。 */
-      async registerDeferredFile(threadId2, path55, resourceKey = `live-file:${threadId2}:${path55}`) {
-        return this.register({ resourceKey, name: basename4(path55), source: { kind: "deferred-file", threadId: threadId2, path: path55 } });
+      async registerDeferredFile(threadId2, path56, resourceKey = `live-file:${threadId2}:${path56}`) {
+        return this.register({ resourceKey, name: basename4(path56), source: { kind: "deferred-file", threadId: threadId2, path: path56 } });
       }
-      async registerFile(threadId2, path55, attachmentId, context) {
+      async registerFile(threadId2, path56, attachmentId, context) {
         if (context && context.visibilityLocator.threadId !== threadId2) throw missing3();
-        const canonical = await realpath4(path55);
+        const canonical = await realpath4(path56);
         const file = await readSourceFile(canonical);
         return this.register({ attachmentId, resourceKey: context?.resourceKey ?? `file:${threadId2}:${canonical}`, name: basename4(canonical), source: {
           kind: "file",
@@ -81263,9 +81414,9 @@ var init_image_resources = __esm({
         return sameLocator(this.historyLocator(threadId2, attachmentId) ?? void 0, expectedLocator);
       }
       /** 保留原件换源时只复用相同受控文件；历史别名和旧暂存不能遮蔽新来源。 */
-      matchesFilePath(threadId2, attachmentId, path55) {
+      matchesFilePath(threadId2, attachmentId, path56) {
         const entry = this.entries.get(attachmentId);
-        return !!entry && threadOf(entry.source) === threadId2 && entry.source.kind === "file" && entry.source.path === path55;
+        return !!entry && threadOf(entry.source) === threadId2 && entry.source.kind === "file" && entry.source.path === path56;
       }
       has(threadId2, attachmentId) {
         const entry = this.entries.get(attachmentId);
@@ -81669,9 +81820,9 @@ var init_image_confirmation2 = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/images.ts
-import { createHash as createHash37 } from "node:crypto";
+import { createHash as createHash38 } from "node:crypto";
 import { realpath as realpath5 } from "node:fs/promises";
-import path44 from "node:path";
+import path45 from "node:path";
 function objectRecord12(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -81752,7 +81903,7 @@ var init_images = __esm({
             if (!url?.startsWith("data:image/")) continue;
             const resources = await this.requireImageResources();
             assertCurrent();
-            const sourceHash = createHash37("sha256").update(url).digest("hex");
+            const sourceHash = createHash38("sha256").update(url).digest("hex");
             const registered = await resources.register({
               resourceKey: `app-server:${threadId2}:${turn.id}:${item.id}:${partIndex}:${sourceHash}`,
               name: "\u56FE\u7247",
@@ -81771,7 +81922,7 @@ var init_images = __esm({
       }
       localImageKey(threadId2, sourcePath, itemId, partIndex) {
         const embedded = sourcePath.startsWith("data:image/");
-        const source2 = embedded ? createHash37("sha256").update(sourcePath).digest("hex") : sourcePath;
+        const source2 = embedded ? createHash38("sha256").update(sourcePath).digest("hex") : sourcePath;
         return `${threadId2}\0${itemId ? JSON.stringify(embedded ? [itemId, partIndex, source2] : [itemId, partIndex ?? source2]) : source2}`;
       }
       resolveKnownLocalImage(threadId2, sourcePath, itemId, partIndex) {
@@ -81790,7 +81941,7 @@ var init_images = __esm({
           if (itemId && ["userMessage", "UserMessage", "user_message"].includes(String(item.type))) {
             if (Array.isArray(item.content)) item.content.forEach((part, index) => {
               const input = objectRecord12(part);
-              if (["localImage", "local_image"].includes(String(input.type)) && typeof input.path === "string" && path44.isAbsolute(input.path)) registrations.push(this.importThreadImage(threadId2, input.path, itemId, index));
+              if (["localImage", "local_image"].includes(String(input.type)) && typeof input.path === "string" && path45.isAbsolute(input.path)) registrations.push(this.importThreadImage(threadId2, input.path, itemId, index));
               const url = input.type === "image" ? nonEmptyString19(input.url ?? input.image_url) : null;
               if (url?.startsWith("data:image/")) registrations.push(this.importThreadImage(threadId2, url, itemId, index));
             });
@@ -81814,7 +81965,7 @@ var init_images = __esm({
       requireImageResources() {
         if (!this.ports.attachmentReady()) throw new Error("\u56FE\u7247\u5B58\u50A8\u5C1A\u672A\u521D\u59CB\u5316");
         if (!this.imageResourcesPromise) this.imageResourcesPromise = ImageResources.create({
-          indexPath: path44.join(this.ports.dataDirectory(), "image-resources", "index.json"),
+          indexPath: path45.join(this.ports.dataDirectory(), "image-resources", "index.json"),
           readAppServerImage: (source2, signal) => this.readAppServerImage(source2, signal),
           onDiagnostic: (event) => this.ports.diagnostic(event)
         }).catch((error2) => {
@@ -81851,7 +82002,7 @@ var init_images = __esm({
         const items = source2.turnId !== void 0 && turns.length !== 1 ? [] : turns.flatMap((turn) => Array.isArray(turn.items) ? turn.items.map(objectRecord12).filter((item) => item.id === source2.itemId && item.type === "userMessage") : []);
         const part = objectRecord12(items.length === 1 && Array.isArray(items[0].content) ? items[0].content[source2.partIndex] : null);
         const url = part.type === "image" ? nonEmptyString19(part.url ?? part.image_url) : null;
-        if (!url || url.length > Math.ceil(20 * 1024 * 1024 / 3) * 4 + 64 || createHash37("sha256").update(url).digest("hex") !== source2.sourceHash) {
+        if (!url || url.length > Math.ceil(20 * 1024 * 1024 / 3) * 4 + 64 || createHash38("sha256").update(url).digest("hex") !== source2.sourceHash) {
           throw new NiumaError("ATTACHMENT_VERSION_CHANGED", "\u56FE\u7247\u7248\u672C\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u52A0\u8F7D");
         }
         const match = /^data:image\/(?:png|jpeg|webp|gif);base64,([A-Za-z0-9+/]+={0,2})$/.exec(url);
@@ -81995,7 +82146,7 @@ var init_images = __esm({
       /** 同一消息引用共享轻量登记；整个 Runtime 最多同时处理四个索引写入。 */
       importThreadImage(threadId2, sourcePath, itemId, partIndex, sourceIsCurrent = () => true) {
         const embedded = sourcePath.startsWith("data:image/") && Number.isSafeInteger(partIndex) && partIndex >= 0;
-        if (!itemId || !path44.isAbsolute(sourcePath) && !embedded) return Promise.resolve();
+        if (!itemId || !path45.isAbsolute(sourcePath) && !embedded) return Promise.resolve();
         const generation = this.ports.generation();
         const key = this.localImageKey(threadId2, sourcePath, itemId, partIndex);
         const routeGeneration = this.ports.controlGeneration(threadId2);
@@ -82026,13 +82177,13 @@ var init_images = __esm({
               threadId: threadId2,
               itemId,
               partIndex,
-              sourceHash: createHash37("sha256").update(sourcePath).digest("hex")
+              sourceHash: createHash38("sha256").update(sourcePath).digest("hex")
             } }) : await resources.registerDeferredFile(threadId2, sourcePath, `live:${key}`);
             if (!current2()) return;
             this.knownLocalImages.set(key, {
               type: "image",
               attachmentId: registered.attachmentId,
-              name: embedded ? "\u56FE\u7247" : path44.basename(sourcePath),
+              name: embedded ? "\u56FE\u7247" : path45.basename(sourcePath),
               previewAvailable: false,
               previewState: "deferred"
             });
@@ -84118,18 +84269,18 @@ var init_session_sources = __esm({
         const isCurrent = () => options.isCurrent?.() !== false;
         const paths = /* @__PURE__ */ new Map();
         for (const thread4 of threads) {
-          const path55 = typeof thread4.path === "string" && thread4.path.length > 0 ? thread4.path : null;
-          if (!paths.has(thread4.id)) paths.set(thread4.id, path55);
-          else if (paths.get(thread4.id) !== path55) paths.set(thread4.id, void 0);
+          const path56 = typeof thread4.path === "string" && thread4.path.length > 0 ? thread4.path : null;
+          if (!paths.has(thread4.id)) paths.set(thread4.id, path56);
+          else if (paths.get(thread4.id) !== path56) paths.set(thread4.id, void 0);
         }
-        for (const [id5, path55] of paths) {
+        for (const [id5, path56] of paths) {
           const thread4 = { id: id5 };
           if (!isCurrent()) return;
           const token3 = this.begin(thread4.id);
           let resolution = null;
           if (resolver) {
             try {
-              resolution = await resolver.resolve(thread4.id, path55);
+              resolution = await resolver.resolve(thread4.id, path56);
             } catch {
               resolution = null;
             }
@@ -84194,7 +84345,7 @@ var init_session_sources = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/settings-selection.ts
-import path45 from "node:path";
+import path46 from "node:path";
 var RuntimeSettingsSelection;
 var init_settings_selection = __esm({
   "apps/desktop/src/daemon/runtime/settings-selection.ts"() {
@@ -84210,7 +84361,7 @@ var init_settings_selection = __esm({
       ports;
       targetProjectRoot(cwd) {
         const matched = this.ports.projectRoots().filter((projectRoot) => pathBelongsToProjectRoot(projectRoot, cwd)).sort((left, right) => right.length - left.length)[0];
-        return matched ?? path45.normalize(cwd);
+        return matched ?? path46.normalize(cwd);
       }
       inheritedCreate(threadId2) {
         const empty = { authorization: null, model: null };
@@ -84428,7 +84579,7 @@ var init_thread_routing = __esm({
 });
 
 // apps/desktop/src/platform/computer-name.ts
-import os4 from "node:os";
+import os5 from "node:os";
 import { execFileSync as execFileSync3 } from "node:child_process";
 function systemComputerName() {
   if (desktopPlatform().id === "macos") {
@@ -84443,10 +84594,10 @@ function systemComputerName() {
     } catch {
     }
   }
-  return os4.hostname();
+  return os5.hostname();
 }
 function systemHostname() {
-  return os4.hostname();
+  return os5.hostname();
 }
 var init_computer_name = __esm({
   "apps/desktop/src/platform/computer-name.ts"() {
@@ -84554,7 +84705,7 @@ var init_device_name = __esm({
 });
 
 // apps/desktop/src/daemon/debug-log.ts
-import path46 from "node:path";
+import path47 from "node:path";
 function isNotificationDeliveryReason(value) {
   return NOTIFICATION_DELIVERY_REASON_CODES.has(value) || /^http_[1-5]\d\d$/.test(value) || /^business_\d{1,6}$/.test(value);
 }
@@ -84593,10 +84744,10 @@ function hasDebugFilter(filter) {
   return Boolean(filter?.components || filter?.channels || filter?.events);
 }
 function createSafeFilePath(runtimeDir, files) {
-  const dir = path46.join(runtimeDir, "debug");
+  const dir = path47.join(runtimeDir, "debug");
   files.ensureDirectory(dir);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return path46.join(dir, `${timestamp}-${process.pid}.ndjson`);
+  return path47.join(dir, `${timestamp}-${process.pid}.ndjson`);
 }
 function createFileDebugLogger(filePath, shouldWrite, files) {
   let writer;
@@ -85202,7 +85353,7 @@ function withoutPersistentImageBytes(value, key = "", seen = /* @__PURE__ */ new
 function createFileRawDebugLogger(runtimeDir, filter, policy, files) {
   const now = policy.now ?? (() => /* @__PURE__ */ new Date());
   const manager = new RawDebugFileManager(
-    path46.join(runtimeDir, "debug"),
+    path47.join(runtimeDir, "debug"),
     now,
     policy.maxSegmentBytes ?? RAW_DEBUG_MAX_SEGMENT_BYTES,
     policy.maxSegments ?? RAW_DEBUG_MAX_SEGMENTS,
@@ -86213,7 +86364,7 @@ var init_debug_log = __esm({
         }
         const timestamp = this.now().toISOString().replace(/[:.]/g, "-");
         for (; ; ) {
-          const filePath = path46.join(this.directory, `${timestamp}-${process.pid}-raw-${this.sequence++}.ndjson`);
+          const filePath = path47.join(this.directory, `${timestamp}-${process.pid}-raw-${this.sequence++}.ndjson`);
           try {
             return this.files.create(filePath);
           } catch (error2) {
@@ -86246,7 +86397,7 @@ var init_debug_log = __esm({
 });
 
 // apps/desktop/src/daemon/control-observability.ts
-import path47 from "node:path";
+import path48 from "node:path";
 function isRecentControlTimestamp(timestampMs, nowMs) {
   return timestampMs <= nowMs && isRetainedDaemonLogTimestamp(timestampMs, nowMs);
 }
@@ -86279,7 +86430,7 @@ function page3(values, params) {
   };
 }
 function listControlLogs(input) {
-  const directoryPath = path47.join(input.runtimeDir, input.kind === "error" ? "errors" : "debug");
+  const directoryPath = path48.join(input.runtimeDir, input.kind === "error" ? "errors" : "debug");
   const values = [];
   let totalBytes = 0;
   let processedLines = 0;
@@ -87302,7 +87453,7 @@ var init_composition = __esm({
         refreshFallback: async (id5, token3) => {
           await this.historySnapshot.tryRefreshThreadMessages(id5, false, { kind: "fallback", token: token3 });
         },
-        resolveKnownLocalImage: (id5, path55, itemId, partIndex) => this.images.resolveKnownLocalImage(id5, path55, itemId, partIndex),
+        resolveKnownLocalImage: (id5, path56, itemId, partIndex) => this.images.resolveKnownLocalImage(id5, path56, itemId, partIndex),
         hasDesktopSnapshot: (id5) => this.controlAccess.snapshot(id5).hasCurrentDesktopSnapshot,
         followerPhase: (id5) => this.followerCoordination.activeThreadFollowerCoordinatorValue?.phaseFor(id5) ?? null,
         generation: () => this.lifecycle.runtimeGenerationValue
@@ -88898,7 +89049,7 @@ var init_runtime2 = __esm({
 
 // apps/desktop/src/daemon/follower-open-trace.ts
 import { randomUUID as randomUUID51 } from "node:crypto";
-import path48 from "node:path";
+import path49 from "node:path";
 function isFiniteTimestamp2(value) {
   return typeof value === "number" && Number.isFinite(value) && Number.isSafeInteger(value);
 }
@@ -89036,7 +89187,7 @@ function parseRecord2(line) {
 function listPrivateTraceFiles(runtimeDir, storage) {
   try {
     storage.checkDirectory(runtimeDir);
-    const scan = storage.scan(path48.join(runtimeDir, TRACE_DIRECTORY_NAME), MAX_DIRECTORY_ENTRIES3);
+    const scan = storage.scan(path49.join(runtimeDir, TRACE_DIRECTORY_NAME), MAX_DIRECTORY_ENTRIES3);
     const files = [];
     let incomplete = scan.truncated;
     for (const entry of scan.entries) {
@@ -89050,8 +89201,8 @@ function listPrivateTraceFiles(runtimeDir, storage) {
   }
 }
 function compareTraceFilePaths(left, right) {
-  const a = path48.basename(left);
-  const b = path48.basename(right);
+  const a = path49.basename(left);
+  const b = path49.basename(right);
   return a.slice(0, 10).localeCompare(b.slice(0, 10)) || Number(a.slice(11, -7)) - Number(b.slice(11, -7));
 }
 function readPrivateTraceFile(file, remainingBytes, storage) {
@@ -89568,7 +89719,7 @@ var init_follower_open_trace = __esm({
       }
       clearAll() {
         try {
-          const directoryPath = path48.join(this.runtimeDir, TRACE_DIRECTORY_NAME);
+          const directoryPath = path49.join(this.runtimeDir, TRACE_DIRECTORY_NAME);
           this.files.checkDirectory(this.runtimeDir);
           let scan;
           try {
@@ -89625,7 +89776,7 @@ var init_follower_open_trace = __esm({
         }
       }
       append(record26) {
-        const directoryPath = path48.join(this.runtimeDir, TRACE_DIRECTORY_NAME);
+        const directoryPath = path49.join(this.runtimeDir, TRACE_DIRECTORY_NAME);
         this.ensureTraceDirectory(directoryPath);
         const content2 = `${JSON.stringify(record26)}
 `;
@@ -89635,8 +89786,8 @@ var init_follower_open_trace = __esm({
       selectAppendFile(directoryPath, dateName, bytes3) {
         const date = dateName.slice(0, 10);
         let filePath = this.appendFilePath;
-        if (!filePath || path48.basename(filePath).slice(0, 10) !== date) {
-          filePath = listPrivateTraceFiles(this.runtimeDir, this.files).files.find((candidate) => candidate.name.slice(0, 10) === date)?.path ?? path48.join(directoryPath, dateName);
+        if (!filePath || path49.basename(filePath).slice(0, 10) !== date) {
+          filePath = listPrivateTraceFiles(this.runtimeDir, this.files).files.find((candidate) => candidate.name.slice(0, 10) === date)?.path ?? path49.join(directoryPath, dateName);
         }
         for (let attempt = 0; attempt < MAX_DIRECTORY_ENTRIES3; attempt += 1) {
           let stats;
@@ -89649,9 +89800,9 @@ var init_follower_open_trace = __esm({
             this.appendFilePath = filePath;
             return filePath;
           }
-          const next = Number(path48.basename(filePath).slice(11, -7)) + 1;
+          const next = Number(path49.basename(filePath).slice(11, -7)) + 1;
           if (next > 999999) break;
-          filePath = path48.join(directoryPath, `${date}.${String(next).padStart(6, "0")}.ndjson`);
+          filePath = path49.join(directoryPath, `${date}.${String(next).padStart(6, "0")}.ndjson`);
         }
         throw new Error("trace segment limit reached");
       }
@@ -89823,7 +89974,7 @@ var init_local_gateway_supervisor = __esm({
 });
 
 // apps/desktop/src/daemon/async-input-notification-store.ts
-import { createHash as createHash38 } from "node:crypto";
+import { createHash as createHash39 } from "node:crypto";
 import { z as z17 } from "zod";
 var ASYNC_INPUT_NOTIFICATION_MAX_BYTES, identityText, entrySchema2, documentSchema2, AsyncInputNotificationStore;
 var init_async_input_notification_store = __esm({
@@ -89891,7 +90042,7 @@ var init_async_input_notification_store = __esm({
         const { threadId: threadId2, turnId, rawQuestionId } = identity6;
         return this.run(async () => {
           for (const value of [threadId2, turnId, rawQuestionId]) identityText.parse(value);
-          const key = createHash38("sha256").update(JSON.stringify([threadId2, turnId, rawQuestionId])).digest("hex");
+          const key = createHash39("sha256").update(JSON.stringify([threadId2, turnId, rawQuestionId])).digest("hex");
           if (this.document.entries.some((entry) => entry.key === key)) return null;
           await this.persist({ version: 1, entries: [...this.document.entries, { key, threadId: threadId2, turnId, stage: "admitted" }] });
           return key;
@@ -91026,7 +91177,7 @@ var init_watch = __esm({
 });
 
 // apps/desktop/src/relay/relay-origin-store.ts
-import path49 from "node:path";
+import path50 from "node:path";
 function parseStoredOrigin(value) {
   try {
     const document = JSON.parse(value);
@@ -91040,7 +91191,7 @@ function parseStoredOrigin(value) {
   }
 }
 function resolveDefaultRelayOriginStorePath() {
-  return path49.join(desktopPlatform().directories.data, DEFAULT_FILE_NAME2);
+  return path50.join(desktopPlatform().directories.data, DEFAULT_FILE_NAME2);
 }
 var DEFAULT_FILE_NAME2, MAX_FILE_BYTES3, FileRelayOriginStore;
 var init_relay_origin_store = __esm({
@@ -91056,7 +91207,7 @@ var init_relay_origin_store = __esm({
       files;
       tail = Promise.resolve();
       constructor(options = {}) {
-        this.filePath = path49.resolve(options.file_path ?? resolveDefaultRelayOriginStorePath());
+        this.filePath = path50.resolve(options.file_path ?? resolveDefaultRelayOriginStorePath());
         this.files = options.files ?? privateDocumentFiles;
       }
       async load() {
@@ -91092,7 +91243,7 @@ var init_relay_origin_store = __esm({
 });
 
 // apps/desktop/src/cli/commands/daemon.ts
-import path50 from "node:path";
+import path51 from "node:path";
 function daemonStartFailed3() {
   return new NiumaError("DAEMON_START_FAILED", "niuma daemon \u542F\u52A8\u5931\u8D25");
 }
@@ -91276,7 +91427,7 @@ async function runDaemonCommand(args, options = {}) {
           loggers.rawDebugLogger?.path,
           loggers.errorLogger?.path,
           // 后台 worker 的 stdout/stderr descriptor 无法安全重开，只按 daemon 所有权保护固定路径。
-          ...options.mode === "background" ? [path50.join(runtimeDir, "daemon-worker.log")] : []
+          ...options.mode === "background" ? [path51.join(runtimeDir, "daemon-worker.log")] : []
         ].filter((filePath) => typeof filePath === "string")
       });
     } catch {
@@ -91735,7 +91886,7 @@ var init_auth2 = __esm({
 });
 
 // apps/desktop/src/control/routes.ts
-import fs27 from "node:fs";
+import fs28 from "node:fs";
 function daemonStoppedOverview() {
   return {
     daemon: { state: "stopped" },
@@ -91754,12 +91905,12 @@ function emptyControlPage(page4, pageSize) {
 }
 function isDaemonRuntimeActive(socketPath = daemonSocketPath(), statusPath = daemonStatusPath()) {
   try {
-    const socket = fs27.lstatSync(socketPath);
-    const status2 = fs27.lstatSync(statusPath);
+    const socket = fs28.lstatSync(socketPath);
+    const status2 = fs28.lstatSync(statusPath);
     if (!socket.isSocket() || !status2.isFile() || status2.isSymbolicLink() || status2.size > 4 * 1024) {
       return false;
     }
-    const parsed = JSON.parse(fs27.readFileSync(statusPath, "utf8"));
+    const parsed = JSON.parse(fs28.readFileSync(statusPath, "utf8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed) || parsed.socketPath !== socketPath || !Number.isSafeInteger(parsed.pid) || parsed.pid <= 0) return false;
     process.kill(parsed.pid, 0);
     return true;
@@ -93312,8 +93463,8 @@ var init_lifecycle2 = __esm({
 
 // apps/desktop/src/control/server.ts
 import http4 from "node:http";
-import fs28 from "node:fs";
-import path51 from "node:path";
+import fs29 from "node:fs";
+import path52 from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 function isControlApiPath(pathname) {
   const [, api, version2, control] = pathname.split("/", 4);
@@ -93359,15 +93510,15 @@ function requestHasBody(request2) {
   return Number(contentLength) !== 0;
 }
 function resolveExactControlWritePath(requestTarget) {
-  for (const path55 of [CONTROL_DEVICE_REVOKE_PATH, CONTROL_DAEMON_ACTION_PATH, CONTROL_TRACE_CLEAR_PATH]) {
-    if (requestTarget === path55 || requestTarget.startsWith(`${path55}?`) && !requestTarget.includes("#")) return path55;
+  for (const path56 of [CONTROL_DEVICE_REVOKE_PATH, CONTROL_DAEMON_ACTION_PATH, CONTROL_TRACE_CLEAR_PATH]) {
+    if (requestTarget === path56 || requestTarget.startsWith(`${path56}?`) && !requestTarget.includes("#")) return path56;
   }
   return null;
 }
 function resolveExactControlTraceReadPath(requestTarget) {
-  for (const path55 of [CONTROL_TRACE_LIST_PATH, CONTROL_TRACE_DETAIL_PATH]) {
-    if (requestTarget === path55 || requestTarget.startsWith(`${path55}?`) && !requestTarget.includes("#")) {
-      return path55;
+  for (const path56 of [CONTROL_TRACE_LIST_PATH, CONTROL_TRACE_DETAIL_PATH]) {
+    if (requestTarget === path56 || requestTarget.startsWith(`${path56}?`) && !requestTarget.includes("#")) {
+      return path56;
     }
   }
   return null;
@@ -93388,9 +93539,9 @@ var init_server5 = __esm({
     init_lifecycle2();
     require2 = createRequire2(import.meta.url);
     CONTROL_PAGE_PATHS = ["/", "/connections", "/sessions", "/subscriptions", "/turn-audit", "/logs"];
-    CONTROL_INDEX = fs28.readFileSync(desktopAssetUrl("control", "index.html"));
-    BOOTSTRAP_CSS = fs28.readFileSync(require2.resolve("bootstrap/dist/css/bootstrap.min.css"));
-    BOOTSTRAP_BUNDLE = fs28.readFileSync(require2.resolve("bootstrap/dist/js/bootstrap.bundle.min.js"));
+    CONTROL_INDEX = fs29.readFileSync(desktopAssetUrl("control", "index.html"));
+    BOOTSTRAP_CSS = fs29.readFileSync(require2.resolve("bootstrap/dist/css/bootstrap.min.css"));
+    BOOTSTRAP_BUNDLE = fs29.readFileSync(require2.resolve("bootstrap/dist/js/bootstrap.bundle.min.js"));
     STATIC_ASSETS = Object.freeze({
       ...Object.fromEntries(CONTROL_PAGE_PATHS.map((pathname) => [pathname, {
         contentType: "text/html; charset=utf-8",
@@ -93398,11 +93549,11 @@ var init_server5 = __esm({
       }])),
       "/app.js": {
         contentType: "application/javascript; charset=utf-8",
-        body: fs28.readFileSync(desktopAssetUrl("control", "app.js"))
+        body: fs29.readFileSync(desktopAssetUrl("control", "app.js"))
       },
       "/chart.umd.js": {
         contentType: "application/javascript; charset=utf-8",
-        body: fs28.readFileSync(path51.join(path51.dirname(require2.resolve("chart.js")), "chart.umd.js"))
+        body: fs29.readFileSync(path52.join(path52.dirname(require2.resolve("chart.js")), "chart.umd.js"))
       },
       "/bootstrap.min.css": {
         contentType: "text/css; charset=utf-8",
@@ -93617,42 +93768,42 @@ var init_server5 = __esm({
 });
 
 // apps/desktop/src/control/state.ts
-import { createHash as createHash39, randomUUID as randomUUID55 } from "node:crypto";
-import fs29 from "node:fs";
-import path52 from "node:path";
+import { createHash as createHash40, randomUUID as randomUUID55 } from "node:crypto";
+import fs30 from "node:fs";
+import path53 from "node:path";
 function createControlState(input) {
   return createControlStateUnlocked(input);
 }
 function createControlStateUnlocked(input) {
   const state = toControlState(input);
   const statePath = controlStatePath(input.runtimeDir);
-  const temporaryPath = path52.join(
-    path52.dirname(statePath),
-    `.${path52.basename(statePath)}.${randomUUID55()}.tmp`
+  const temporaryPath = path53.join(
+    path53.dirname(statePath),
+    `.${path53.basename(statePath)}.${randomUUID55()}.tmp`
   );
   let descriptor = null;
   let temporaryIdentity = null;
   let published = null;
   let operationError;
   try {
-    descriptor = fs29.openSync(temporaryPath, "wx", 384);
-    if (process.platform !== "win32") fs29.fchmodSync(descriptor, 384);
-    const stats = fs29.fstatSync(descriptor, { bigint: true });
+    descriptor = fs30.openSync(temporaryPath, "wx", 384);
+    if (process.platform !== "win32") fs30.fchmodSync(descriptor, 384);
+    const stats = fs30.fstatSync(descriptor, { bigint: true });
     assertRegularControlStateDescriptor(stats);
     temporaryIdentity = identityFromStats(stats);
-    fs29.writeFileSync(descriptor, `${JSON.stringify(state)}
+    fs30.writeFileSync(descriptor, `${JSON.stringify(state)}
 `, "utf8");
-    fs29.fsyncSync(descriptor);
-    fs29.closeSync(descriptor);
+    fs30.fsyncSync(descriptor);
+    fs30.closeSync(descriptor);
     descriptor = null;
-    fs29.linkSync(temporaryPath, statePath);
+    fs30.linkSync(temporaryPath, statePath);
     published = persistedControlState(state, statePath, identityFromStats(stats), "canonical");
   } catch (error2) {
     operationError = error2;
   } finally {
     if (descriptor !== null) {
       try {
-        fs29.closeSync(descriptor);
+        fs30.closeSync(descriptor);
       } catch (error2) {
         operationError ??= error2;
       }
@@ -93675,7 +93826,7 @@ function createControlStateUnlocked(input) {
   return published;
 }
 function cleanupControlStateArtifactsForOwnedListener(runtimeDir) {
-  const stateBasename = path52.basename(controlStatePath(runtimeDir));
+  const stateBasename = path53.basename(controlStatePath(runtimeDir));
   const artifactPattern = new RegExp(
     `^\\.${escapeRegExp(stateBasename)}(?:\\.coordination\\.lock)?\\.[0-9a-f-]+\\.(?:tmp|snapshot)$`,
     "u"
@@ -93683,19 +93834,19 @@ function cleanupControlStateArtifactsForOwnedListener(runtimeDir) {
   let removed = 0;
   let entries;
   try {
-    entries = fs29.readdirSync(runtimeDir);
+    entries = fs30.readdirSync(runtimeDir);
   } catch {
     return 0;
   }
   for (const entry of entries) {
     if (entry !== `${stateBasename}.coordination.lock` && !artifactPattern.test(entry)) continue;
-    const artifactPath = path52.join(runtimeDir, entry);
+    const artifactPath = path53.join(runtimeDir, entry);
     try {
-      const stats = fs29.lstatSync(artifactPath, { bigint: true });
+      const stats = fs30.lstatSync(artifactPath, { bigint: true });
       if (!stats.isFile() || stats.isSymbolicLink() || process.platform !== "win32" && (stats.mode & 0o777n) !== 0o600n) {
         continue;
       }
-      fs29.unlinkSync(artifactPath);
+      fs30.unlinkSync(artifactPath);
       removed += 1;
     } catch {
     }
@@ -93733,7 +93884,7 @@ function removeControlStateUnlocked(input) {
   if (input.expected.path !== statePath) return false;
   const snapshotPath = stateSnapshotPath(statePath);
   try {
-    fs29.linkSync(statePath, snapshotPath);
+    fs30.linkSync(statePath, snapshotPath);
   } catch (error2) {
     if (error2.code === "ENOENT") return false;
     return false;
@@ -93752,7 +93903,7 @@ function removeControlStateUnlocked(input) {
       return false;
     }
     if (!canonicalMatchesSnapshot(statePath, snapshotPath, snapshot2)) return false;
-    fs29.unlinkSync(statePath);
+    fs30.unlinkSync(statePath);
     canonicalRemoved = true;
     return true;
   } catch {
@@ -93770,7 +93921,7 @@ function removeControlStateUnlocked(input) {
 function readControlStateAtPath(filePath, logicalPath) {
   const descriptor = openControlStateForRead(filePath);
   try {
-    const stats = fs29.fstatSync(descriptor, { bigint: true });
+    const stats = fs30.fstatSync(descriptor, { bigint: true });
     assertRegularControlStateDescriptor(stats);
     assertPrivateControlStateMode(stats);
     if (stats.size > BigInt(CONTROL_STATE_MAX_BYTES)) {
@@ -93785,14 +93936,14 @@ function readControlStateAtPath(filePath, logicalPath) {
       throw new CorruptControlStateError(logicalPath, identity6, contents);
     }
   } finally {
-    fs29.closeSync(descriptor);
+    fs30.closeSync(descriptor);
   }
 }
 function readBoundedControlState(descriptor) {
   const buffer = Buffer.alloc(CONTROL_STATE_MAX_BYTES + 1);
   let bytesRead = 0;
   while (bytesRead < buffer.length) {
-    const count = fs29.readSync(
+    const count = fs30.readSync(
       descriptor,
       buffer,
       bytesRead,
@@ -93811,12 +93962,12 @@ function removeCorruptControlState(error2) {
   const snapshotPath = stateSnapshotPath(error2.statePath);
   let canonicalRemoved = false;
   try {
-    fs29.linkSync(error2.statePath, snapshotPath);
+    fs30.linkSync(error2.statePath, snapshotPath);
   } catch {
     return false;
   }
   try {
-    const snapshotStats = fs29.lstatSync(snapshotPath, { bigint: true });
+    const snapshotStats = fs30.lstatSync(snapshotPath, { bigint: true });
     if (!snapshotStats.isFile()) return false;
     const snapshotIdentity = identityFromStats(snapshotStats);
     if (hasUsableInode(error2.fileIdentity) && hasUsableInode(snapshotIdentity) && !sameIdentity(error2.fileIdentity, snapshotIdentity)) {
@@ -93827,7 +93978,7 @@ function removeCorruptControlState(error2) {
       if (fingerprint(snapshot2) !== error2.fingerprint) return false;
     }
     if (!canonicalMatchesSnapshotByIdentity(error2.statePath, snapshotPath)) return false;
-    fs29.unlinkSync(error2.statePath);
+    fs30.unlinkSync(error2.statePath);
     canonicalRemoved = true;
     return true;
   } catch {
@@ -93843,7 +93994,7 @@ function removeCorruptControlState(error2) {
 function readRawControlState(filePath) {
   const descriptor = openControlStateForRead(filePath);
   try {
-    const stats = fs29.fstatSync(descriptor, { bigint: true });
+    const stats = fs30.fstatSync(descriptor, { bigint: true });
     assertRegularControlStateDescriptor(stats);
     assertPrivateControlStateMode(stats);
     if (stats.size > BigInt(CONTROL_STATE_MAX_BYTES)) {
@@ -93851,13 +94002,13 @@ function readRawControlState(filePath) {
     }
     return readBoundedControlState(descriptor);
   } finally {
-    fs29.closeSync(descriptor);
+    fs30.closeSync(descriptor);
   }
 }
 function canonicalMatchesSnapshot(statePath, snapshotPath, snapshot2) {
   if (!canonicalMatchesSnapshotByIdentity(statePath, snapshotPath)) return false;
-  const canonicalStats = fs29.lstatSync(statePath, { bigint: true });
-  const snapshotStats = fs29.lstatSync(snapshotPath, { bigint: true });
+  const canonicalStats = fs30.lstatSync(statePath, { bigint: true });
+  const snapshotStats = fs30.lstatSync(snapshotPath, { bigint: true });
   if (hasUsableInode(identityFromStats(canonicalStats)) && hasUsableInode(identityFromStats(snapshotStats))) {
     return true;
   }
@@ -93865,8 +94016,8 @@ function canonicalMatchesSnapshot(statePath, snapshotPath, snapshot2) {
   return current2.pid === snapshot2.pid && current2.ownershipSecret === snapshot2.ownershipSecret;
 }
 function canonicalMatchesSnapshotByIdentity(statePath, snapshotPath) {
-  const canonicalStats = fs29.lstatSync(statePath, { bigint: true });
-  const snapshotStats = fs29.lstatSync(snapshotPath, { bigint: true });
+  const canonicalStats = fs30.lstatSync(statePath, { bigint: true });
+  const snapshotStats = fs30.lstatSync(snapshotPath, { bigint: true });
   if (!canonicalStats.isFile() || !snapshotStats.isFile()) return false;
   const canonicalIdentity = identityFromStats(canonicalStats);
   const snapshotIdentity = identityFromStats(snapshotStats);
@@ -93897,20 +94048,20 @@ function sameIdentity(left, right) {
   return left.device === right.device && left.inode === right.inode;
 }
 function stateSnapshotPath(statePath) {
-  return path52.join(
-    path52.dirname(statePath),
-    `.${path52.basename(statePath)}.${randomUUID55()}.snapshot`
+  return path53.join(
+    path53.dirname(statePath),
+    `.${path53.basename(statePath)}.${randomUUID55()}.snapshot`
   );
 }
 function fingerprint(contents) {
-  return createHash39("sha256").update(contents).digest("hex");
+  return createHash40("sha256").update(contents).digest("hex");
 }
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 function unlinkControlStateTemporary(temporaryPath) {
   try {
-    fs29.unlinkSync(temporaryPath);
+    fs30.unlinkSync(temporaryPath);
     return void 0;
   } catch (error2) {
     return error2.code === "ENOENT" ? void 0 : error2;
@@ -93922,28 +94073,28 @@ function eraseControlStateTemporary(temporaryPath, expectedIdentity) {
   try {
     let beforeIdentity = null;
     if (process.platform === "win32") {
-      const before = fs29.lstatSync(temporaryPath, { bigint: true });
+      const before = fs30.lstatSync(temporaryPath, { bigint: true });
       beforeIdentity = identityFromStats(before);
       if (!before.isFile() || before.isSymbolicLink() || !hasUsableInode(beforeIdentity) || !sameIdentity(beforeIdentity, expectedIdentity)) return;
     }
-    const noFollow = process.platform === "win32" ? 0 : fs29.constants.O_NOFOLLOW;
+    const noFollow = process.platform === "win32" ? 0 : fs30.constants.O_NOFOLLOW;
     if (process.platform !== "win32" && (!noFollow || typeof noFollow !== "number")) return;
-    descriptor = fs29.openSync(temporaryPath, fs29.constants.O_RDWR | noFollow);
-    const stats = fs29.fstatSync(descriptor, { bigint: true });
+    descriptor = fs30.openSync(temporaryPath, fs30.constants.O_RDWR | noFollow);
+    const stats = fs30.fstatSync(descriptor, { bigint: true });
     const identity6 = identityFromStats(stats);
     if (!stats.isFile() || !hasUsableInode(identity6) || !sameIdentity(identity6, expectedIdentity)) return;
     if (process.platform === "win32") {
-      const after = fs29.lstatSync(temporaryPath, { bigint: true });
+      const after = fs30.lstatSync(temporaryPath, { bigint: true });
       const afterIdentity = identityFromStats(after);
       if (!after.isFile() || after.isSymbolicLink() || !beforeIdentity || !hasUsableInode(afterIdentity) || !sameIdentity(beforeIdentity, identity6) || !sameIdentity(identity6, afterIdentity)) return;
     }
-    fs29.ftruncateSync(descriptor, 0);
-    fs29.fsyncSync(descriptor);
+    fs30.ftruncateSync(descriptor, 0);
+    fs30.fsyncSync(descriptor);
   } catch {
   } finally {
     if (descriptor !== null) {
       try {
-        fs29.closeSync(descriptor);
+        fs30.closeSync(descriptor);
       } catch {
       }
     }
@@ -93990,16 +94141,16 @@ function parseControlState(value) {
 }
 function openControlStateForRead(statePath) {
   if (process.platform === "win32") return openControlStateForReadOnWindows(statePath);
-  const noFollow = fs29.constants.O_NOFOLLOW;
+  const noFollow = fs30.constants.O_NOFOLLOW;
   if (typeof noFollow !== "number" || noFollow === 0) {
     throw new Error("\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301 Control \u72B6\u6001\u6587\u4EF6\u7684 O_NOFOLLOW \u5B89\u5168\u8BFB\u53D6");
   }
-  const nonBlock = fs29.constants.O_NONBLOCK;
+  const nonBlock = fs30.constants.O_NONBLOCK;
   if (typeof nonBlock !== "number" || nonBlock === 0) {
     throw new Error("\u5F53\u524D\u5E73\u53F0\u4E0D\u652F\u6301 Control \u72B6\u6001\u6587\u4EF6\u7684 O_NONBLOCK \u5B89\u5168\u8BFB\u53D6");
   }
   try {
-    return fs29.openSync(statePath, fs29.constants.O_RDONLY | noFollow | nonBlock);
+    return fs30.openSync(statePath, fs30.constants.O_RDONLY | noFollow | nonBlock);
   } catch (error2) {
     if (error2.code === "ELOOP") {
       throw new Error("Control \u72B6\u6001\u5FC5\u987B\u662F\u79C1\u6709\u666E\u901A\u6587\u4EF6\uFF0C\u4E0D\u80FD\u662F\u7B26\u53F7\u94FE\u63A5");
@@ -94008,14 +94159,14 @@ function openControlStateForRead(statePath) {
   }
 }
 function openControlStateForReadOnWindows(statePath) {
-  const before = fs29.lstatSync(statePath, { bigint: true });
+  const before = fs30.lstatSync(statePath, { bigint: true });
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("Control \u72B6\u6001\u5FC5\u987B\u662F\u79C1\u6709\u666E\u901A\u6587\u4EF6\uFF0C\u4E0D\u80FD\u662F\u7B26\u53F7\u94FE\u63A5");
   }
-  const descriptor = fs29.openSync(statePath, fs29.constants.O_RDONLY);
+  const descriptor = fs30.openSync(statePath, fs30.constants.O_RDONLY);
   try {
-    const opened = fs29.fstatSync(descriptor, { bigint: true });
-    const after = fs29.lstatSync(statePath, { bigint: true });
+    const opened = fs30.fstatSync(descriptor, { bigint: true });
+    const after = fs30.lstatSync(statePath, { bigint: true });
     const beforeIdentity = identityFromStats(before);
     const openedIdentity = identityFromStats(opened);
     const afterIdentity = identityFromStats(after);
@@ -94024,7 +94175,7 @@ function openControlStateForReadOnWindows(statePath) {
     }
     return descriptor;
   } catch (error2) {
-    fs29.closeSync(descriptor);
+    fs30.closeSync(descriptor);
     throw error2;
   }
 }
@@ -94466,9 +94617,9 @@ var init_direct2 = __esm({
 });
 
 // apps/desktop/src/cli/commands/events.ts
-import path53 from "node:path";
+import path54 from "node:path";
 function normalizedProjectRoot(value) {
-  return typeof value === "string" && value.length > 0 ? path53.resolve(value) : null;
+  return typeof value === "string" && value.length > 0 ? path54.resolve(value) : null;
 }
 function toOutputEvent(event) {
   if (event.ok === true && typeof event.schemaVersion === "number") {
@@ -94852,7 +95003,7 @@ var init_state2 = __esm({
 });
 
 // apps/desktop/src/cli/commands/threads.ts
-import path54 from "node:path";
+import path55 from "node:path";
 function readPositiveInteger2(value, name2, fallback) {
   if (value === void 0) {
     return fallback;
@@ -94870,7 +95021,7 @@ async function runThreadsCommand(args, options = {}) {
   const pageSize = readPositiveInteger2(args.flags.pageSize ?? args.flags.limit, "--page-size", 100);
   const maxPages = readPositiveInteger2(args.flags.maxPages, "--max-pages", 20);
   const cursor = typeof args.flags.cursor === "string" && args.flags.cursor.length > 0 ? args.flags.cursor : null;
-  const projectRoot = typeof args.flags.project === "string" && args.flags.project.length > 0 ? path54.resolve(args.flags.project) : null;
+  const projectRoot = typeof args.flags.project === "string" && args.flags.project.length > 0 ? path55.resolve(args.flags.project) : null;
   const daemon = options.daemonClient ?? new DaemonClient(options.socketPath);
   const result = await daemon.request("threads/list", {
     pageSize,