niuma-codex 0.0.1-beta.23 → 0.0.1-beta.24

package/dist/cli.js

@@ -3562,6 +3562,58 @@ var init_app_validation = __esm({
   }
 });
 
+// apps/desktop/src/lite-install/intent.ts
+import fs19 from "node:fs/promises";
+import path23 from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
+async function prepareInstallIntent(root, home, version2) {
+  if (!/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(version2)) throw Error("\u9700\u8981\u660E\u786E\u7684\u53D1\u5E03\u7248\u672C");
+  const pending = await readMigration(root);
+  if (pending && !["completed", "skipped"].includes(pending.phase) && pending.version !== version2) throw Error("\u8BF7\u5148\u4F7F\u7528\u539F\u7248\u672C install-app \u5B8C\u6210\u8FC1\u79FB");
+  const file = path23.join(root, "install-intent.json");
+  let intent;
+  try {
+    const stat4 = await fs19.lstat(file);
+    if (!stat4.isFile() || stat4.uid !== process.getuid?.() || stat4.mode & 63) throw Error("\u5B89\u88C5\u610F\u56FE\u6587\u4EF6\u4E0D\u53EF\u4FE1");
+    intent = JSON.parse(await fs19.readFile(file, "utf8"));
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+    let firstInstall = false;
+    try {
+      await fs19.lstat(path23.join(root, "current.json"));
+    } catch (e2) {
+      if (e2.code !== "ENOENT") throw e2;
+      firstInstall = true;
+    }
+    intent = { version: version2, firstInstall, selection: await createInstallSelection(home, true) };
+    await fs19.writeFile(file, JSON.stringify(intent), { flag: "wx", mode: 384 });
+  }
+  if (!intent || typeof intent.firstInstall !== "boolean" || typeof intent.version !== "string" || !/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(intent.version)) throw Error("\u5B89\u88C5\u610F\u56FE\u8BB0\u5F55\u65E0\u6548");
+  let changed2 = intent.version !== version2;
+  if (intent.selection === void 0) {
+    intent.selection = await createInstallSelection(home, false);
+    changed2 = true;
+  }
+  if (!intent.selection || typeof intent.selection !== "object" || typeof intent.selection.revision !== "string" || !intent.selection.revision || !Number.isSafeInteger(intent.selection.requestedAt) || intent.selection.requestedAt < 0 || !(intent.selection.previousRevision === null || typeof intent.selection.previousRevision === "string")) throw Error("\u5B89\u88C5\u9009\u62E9\u8BB0\u5F55\u65E0\u6548");
+  if (changed2) {
+    intent.version = version2;
+    const temp = file + "." + randomUUID6();
+    try {
+      await fs19.writeFile(temp, JSON.stringify(intent), { flag: "wx", mode: 384 });
+      await fs19.rename(temp, file);
+    } finally {
+      await fs19.rm(temp, { force: true });
+    }
+  }
+  return { intent, pending };
+}
+var init_intent = __esm({
+  "apps/desktop/src/lite-install/intent.ts"() {
+    "use strict";
+    init_migration();
+  }
+});
+
 // apps/desktop/src/lite-install/lifecycle.ts
 async function switchNpmDaemon(o) {
   const before = await o.read();
@@ -5419,11 +5471,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, path70) {
+function dataUrl(value, path71) {
   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 && (path70 ? u.pathname === path70 : ["/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 && (path71 ? u.pathname === path71 : ["/direct/v1/attachment/data", "/ws/v1/attachment/data"].includes(u.pathname));
   } catch {
     return false;
   }
@@ -10253,7 +10305,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.23";
+  return false ? null : "0.0.1-beta.24";
 }
 function desktopPresenceVersion() {
   return desktopReleaseVersion() ?? sourcePresenceVersion;
@@ -10444,7 +10496,7 @@ var init_sse_client = __esm({
 });
 
 // apps/desktop/src/notifications/server-client.ts
-import { createHash as createHash4, randomBytes as randomBytes2, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes2, randomUUID as randomUUID7 } from "node:crypto";
 function invalidPushServerOrigin() {
   return new NiumaError(
     "INVALID_ARGUMENT",
@@ -10529,11 +10581,11 @@ 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(path70, input, signal, method2 = "POST") {
+      async signedPost(path71, 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/${path70}`;
+        const query2 = method2 === "GET" ? input : {}, body = method2 === "GET" ? "" : JSON.stringify(input), pathname = `/api/v1/push/${path71}`;
         const key_id = createHash4("sha256").update(this.identity.identity_public_key).digest("base64url");
-        const operation_id = randomUUID6(), nonce = encodeBase64Url(randomBytes2(32)), timestamp = Math.floor(Date.now() / 1e3);
+        const operation_id = randomUUID7(), nonce = encodeBase64Url(randomBytes2(32)), timestamp = Math.floor(Date.now() / 1e3);
         const bytes3 = createPushSigningBytes({ audience: this.serverOrigin, method: method2, pathname, query: query2, body_sha256: createHash4("sha256").update(body).digest("base64url"), key_id, operation_id, timestamp, nonce });
         let response;
         try {
@@ -10567,71 +10619,71 @@ var init_managed_owner = __esm({
 });
 
 // apps/desktop/src/platform/posix-runtime-lock.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
-import fs19 from "node:fs";
-import path23 from "node:path";
+import { randomUUID as randomUUID8 } from "node:crypto";
+import fs20 from "node:fs";
+import path24 from "node:path";
 function publishDaemonLock(lockPath) {
-  const token3 = randomUUID7();
-  const temporaryPath = path23.join(
-    path23.dirname(lockPath),
-    `.${path23.basename(lockPath)}.${randomUUID7()}.tmp`
+  const token3 = randomUUID8();
+  const temporaryPath = path24.join(
+    path24.dirname(lockPath),
+    `.${path24.basename(lockPath)}.${randomUUID8()}.tmp`
   );
   let descriptor = null;
   try {
-    descriptor = fs19.openSync(temporaryPath, "wx", 384);
-    const stats = fs19.fstatSync(descriptor);
+    descriptor = fs20.openSync(temporaryPath, "wx", 384);
+    const stats = fs20.fstatSync(descriptor);
     if (!stats.isFile()) {
       throw new Error("daemon \u9501\u4E34\u65F6\u6587\u4EF6\u5FC5\u987B\u662F\u666E\u901A\u6587\u4EF6");
     }
-    fs19.writeFileSync(descriptor, JSON.stringify({ token: token3, pid: process.pid }), "utf8");
-    fs19.fchmodSync(descriptor, 384);
-    fs19.closeSync(descriptor);
+    fs20.writeFileSync(descriptor, JSON.stringify({ token: token3, pid: process.pid }), "utf8");
+    fs20.fchmodSync(descriptor, 384);
+    fs20.closeSync(descriptor);
     descriptor = null;
-    fs19.linkSync(temporaryPath, lockPath);
+    fs20.linkSync(temporaryPath, lockPath);
   } catch (error2) {
     if (descriptor !== null) {
       try {
-        fs19.closeSync(descriptor);
+        fs20.closeSync(descriptor);
       } catch {
       }
     }
     try {
-      fs19.unlinkSync(temporaryPath);
+      fs20.unlinkSync(temporaryPath);
     } catch {
     }
     throw error2;
   }
   try {
-    fs19.unlinkSync(temporaryPath);
+    fs20.unlinkSync(temporaryPath);
   } catch {
   }
   return {
     token: token3,
     release: () => {
-      const snapshotPath = path23.join(
-        path23.dirname(lockPath),
-        `.${path23.basename(lockPath)}.${randomUUID7()}.snapshot`
+      const snapshotPath = path24.join(
+        path24.dirname(lockPath),
+        `.${path24.basename(lockPath)}.${randomUUID8()}.snapshot`
       );
       try {
-        fs19.linkSync(lockPath, snapshotPath);
+        fs20.linkSync(lockPath, snapshotPath);
       } catch {
         return;
       }
       try {
-        const current2 = JSON.parse(fs19.readFileSync(snapshotPath, "utf8"));
+        const current2 = JSON.parse(fs20.readFileSync(snapshotPath, "utf8"));
         if (current2.token !== token3) {
           return;
         }
-        const snapshotStats = fs19.lstatSync(snapshotPath);
-        const canonicalStats = fs19.lstatSync(lockPath);
+        const snapshotStats = fs20.lstatSync(snapshotPath);
+        const canonicalStats = fs20.lstatSync(lockPath);
         if (!snapshotStats.isFile() || !canonicalStats.isFile() || canonicalStats.dev !== snapshotStats.dev || canonicalStats.ino !== snapshotStats.ino) {
           return;
         }
-        fs19.unlinkSync(lockPath);
+        fs20.unlinkSync(lockPath);
       } catch {
       } finally {
         try {
-          fs19.unlinkSync(snapshotPath);
+          fs20.unlinkSync(snapshotPath);
         } catch {
         }
       }
@@ -10646,8 +10698,8 @@ var init_posix_runtime_lock = __esm({
 
 // apps/desktop/src/platform/windows-runtime-lock.ts
 import { spawn } from "node:child_process";
-import { randomUUID as randomUUID8 } from "node:crypto";
-import path24 from "node:path";
+import { randomUUID as randomUUID9 } from "node:crypto";
+import path25 from "node:path";
 async function acquireWindowsRuntimeLease(lockPath, options = {}) {
   const now = options.now ?? Date.now;
   const assertPending = () => {
@@ -10655,9 +10707,9 @@ async function acquireWindowsRuntimeLease(lockPath, options = {}) {
   };
   assertPending();
   const file = localWindowsPath(lockPath);
-  ensureWindowsPrivateDirectory(path24.dirname(file));
+  ensureWindowsPrivateDirectory(path25.dirname(file));
   assertPending();
-  const token3 = randomUUID8();
+  const token3 = randomUUID9();
   const child = spawn(windowsPowerShell(), windowsScriptArgs(WINDOWS_RUNTIME_LOCK_SCRIPT), {
     env: { ...process.env, NIUMA_NATIVE_PATH: file, NIUMA_NATIVE_BODY: JSON.stringify({ token: token3, pid: process.pid }) },
     windowsHide: true,
@@ -10765,11 +10817,11 @@ try {
 });
 
 // apps/desktop/src/platform/runtime-lock.ts
-import fs20 from "node:fs";
-import path25 from "node:path";
+import fs21 from "node:fs";
+import path26 from "node:path";
 function ensureRuntimeLeaseDirectory(lockPath) {
-  if (desktopPlatform().id === "windows") ensureWindowsPrivateDirectory(path25.dirname(lockPath));
-  else fs20.mkdirSync(path25.dirname(lockPath), { recursive: true, mode: 448 });
+  if (desktopPlatform().id === "windows") ensureWindowsPrivateDirectory(path26.dirname(lockPath));
+  else fs21.mkdirSync(path26.dirname(lockPath), { recursive: true, mode: 448 });
 }
 async function acquireRuntimeLease(lockPath, options = {}) {
   if (desktopPlatform().id === "windows") return acquireWindowsRuntimeLease(lockPath, options);
@@ -10989,7 +11041,7 @@ var init_startup_coordinator = __esm({
 
 // apps/desktop/src/daemon/error-log.ts
 import { z } from "zod";
-import path26 from "node:path";
+import path27 from "node:path";
 function writeErrorAuditBestEffort(logger, entry) {
   try {
     logger?.write(entry);
@@ -11188,7 +11240,7 @@ function createLogFile(errorsDir, now, files) {
   const timestamp = now.toISOString().replace(/[:.]/g, "-");
   for (let index = 0; ; index += 1) {
     const suffix = index === 0 ? "" : `-${index}`;
-    const filePath = path26.join(errorsDir, `${timestamp}-${process.pid}${suffix}.ndjson`);
+    const filePath = path27.join(errorsDir, `${timestamp}-${process.pid}${suffix}.ndjson`);
     try {
       return files.create(filePath);
     } catch (error2) {
@@ -11202,7 +11254,7 @@ function createErrorAuditLogger(options = {}) {
   if (!isSafeInteger(maxBytes, 1)) throw new NiumaError("INVALID_ARGUMENT", "\u9519\u8BEF\u5BA1\u8BA1\u65E5\u5FD7\u5BB9\u91CF\u5FC5\u987B\u662F\u6B63\u6574\u6570");
   const runtimeDir = options.runtimeDir ?? ensureDaemonRuntimeDir();
   const files = options.files ?? privateLogFiles;
-  const errorsDir = path26.join(runtimeDir, "errors");
+  const errorsDir = path27.join(runtimeDir, "errors");
   files.ensureDirectory(errorsDir);
   cleanupExpiredDaemonLogs({ runtimeDir, files, now: () => now().getTime() });
   let currentFile = createLogFile(errorsDir, now(), files);
@@ -11655,13 +11707,13 @@ var init_error_log = __esm({
 });
 
 // apps/desktop/src/appserver/startup-failure.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { z as z2 } from "zod";
 function codexStartupFailure(reason, logger) {
   const error2 = new NiumaError(reason === "missing" ? "CODEX_NOT_FOUND" : "APP_SERVER_START_FAILED", MESSAGES[reason], { reason });
   if (logger) writeErrorAuditBestEffort(logger, {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
-    failureId: `fail_${randomUUID9()}`,
+    failureId: `fail_${randomUUID10()}`,
     service: "desktop",
     component: "app_server",
     channel: "internal",
@@ -11675,7 +11727,7 @@ function codexStartupFailure(reason, logger) {
 function auditCodexStartupCleanupFailure(logger) {
   writeErrorAuditBestEffort(logger, {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
-    failureId: `fail_${randomUUID9()}`,
+    failureId: `fail_${randomUUID10()}`,
     service: "desktop",
     component: "app_server",
     channel: "internal",
@@ -11739,9 +11791,9 @@ var init_startup_failure = __esm({
 
 // apps/desktop/src/platform/windows-port-owner.ts
 import { execFile as execFile4 } from "node:child_process";
-import path27 from "node:path";
+import path28 from "node:path";
 function execute(file, args) {
-  const executable = path27.join(process.env.SystemRoot ?? "C:\\Windows", "System32", file);
+  const executable = path28.join(process.env.SystemRoot ?? "C:\\Windows", "System32", file);
   return new Promise((resolve5, reject3) => execFile4(executable, [...args], {
     windowsHide: true,
     encoding: "utf8",
@@ -12227,8 +12279,8 @@ var init_config = __esm({
 
 // apps/desktop/src/daemon/launcher.ts
 import { spawn as spawn2 } from "node:child_process";
-import fs21 from "node:fs";
-import path28 from "node:path";
+import fs22 from "node:fs";
+import path29 from "node:path";
 function daemonStartFailed() {
   return new NiumaError("DAEMON_START_FAILED", "niuma daemon \u542F\u52A8\u5931\u8D25");
 }
@@ -12254,9 +12306,9 @@ function currentCliScriptPath() {
   const scriptPath = process.argv[1];
   if (!scriptPath) return null;
   try {
-    return fs21.realpathSync(scriptPath);
+    return fs22.realpathSync(scriptPath);
   } catch {
-    return path28.resolve(scriptPath);
+    return path29.resolve(scriptPath);
   }
 }
 function isNiumaBackgroundWorkerCommand(commandLine) {
@@ -12330,7 +12382,7 @@ function spawnBackgroundWorker(input) {
   if (!command) {
     throw new Error("daemon worker \u7F3A\u5C11\u542F\u52A8\u547D\u4EE4");
   }
-  const descriptor = fs21.openSync(input.logPath, "a", 384);
+  const descriptor = fs22.openSync(input.logPath, "a", 384);
   try {
     const child = spawn2(command, argv, {
       detached: input.detached,
@@ -12365,7 +12417,7 @@ function spawnBackgroundWorker(input) {
       }
     })() };
   } finally {
-    fs21.closeSync(descriptor);
+    fs22.closeSync(descriptor);
   }
 }
 function consumeBackgroundWorkerCapability(env = process.env, lockPath = daemonLaunchLockPath()) {
@@ -12376,7 +12428,7 @@ function consumeBackgroundWorkerCapability(env = process.env, lockPath = daemonL
   }
   try {
     validateRuntimeOwnedFile(lockPath);
-    const lock = JSON.parse(fs21.readFileSync(lockPath, "utf8"));
+    const lock = JSON.parse(fs22.readFileSync(lockPath, "utf8"));
     return typeof lock.token === "string" && lock.token === capability;
   } catch {
     return false;
@@ -13304,11 +13356,11 @@ var init_runtime_version = __esm({
       retryAt = 0;
       pending = null;
       controller = null;
-      setConnection(path70) {
+      setConnection(path71) {
         this.epoch++;
         this.controller?.abort();
         this.controller = null;
-        this.path = path70;
+        this.path = path71;
         this.value = null;
         this.pending = null;
         this.retryAt = 0;
@@ -13400,8 +13452,8 @@ var init_private_journal_types = __esm({
 
 // apps/desktop/src/platform/windows-private-journal.ts
 import { spawn as spawn3 } from "node:child_process";
-import fs22 from "node:fs";
-import path29 from "node:path";
+import fs23 from "node:fs";
+import path30 from "node:path";
 async function openWindowsPrivateJournal(filePath, maxBytes, options = {}) {
   const maxSupportedBytes = (options.discardPreviousSnapshots ? 32 : 16) * 1024 * 1024;
   const lockWaitMs = options.lockWaitMs ?? 0;
@@ -13412,10 +13464,10 @@ async function openWindowsPrivateJournal(filePath, maxBytes, options = {}) {
   let directory3;
   try {
     file = localWindowsPath(filePath);
-    directory3 = await ensureWindowsPrivateDirectoryAsync(path29.dirname(file));
-    for (const candidate of [file, `${file}-journal`, `${file}-wal`, `${file}-shm`, path29.join(directory3, `.${path29.basename(file)}.lock`)]) {
+    directory3 = await ensureWindowsPrivateDirectoryAsync(path30.dirname(file));
+    for (const candidate of [file, `${file}-journal`, `${file}-wal`, `${file}-shm`, path30.join(directory3, `.${path30.basename(file)}.lock`)]) {
       try {
-        const stats = fs22.lstatSync(candidate, { bigint: true });
+        const stats = fs23.lstatSync(candidate, { bigint: true });
         if (!stats.isFile() || stats.isSymbolicLink() || stats.nlink !== 1n) throw new PrivateJournalError("unavailable");
         if ((candidate === file || candidate === `${file}-journal`) && stats.size > BigInt(3 * maxBytes + 524288)) throw new PrivateJournalError("capacity");
       } catch (error2) {
@@ -13425,7 +13477,7 @@ async function openWindowsPrivateJournal(filePath, maxBytes, options = {}) {
   } catch (error2) {
     throw error2 instanceof PrivateJournalError ? error2 : new PrivateJournalError("unavailable");
   }
-  const directoryIdentity2 = fs22.lstatSync(directory3, { bigint: true });
+  const directoryIdentity2 = fs23.lstatSync(directory3, { bigint: true });
   const child = spawn3(windowsPowerShell(), windowsScriptArgs("& ([ScriptBlock]::Create($env:NIUMA_JOURNAL_SCRIPT))"), {
     env: {
       ...process.env,
@@ -13517,8 +13569,8 @@ async function openWindowsPrivateJournal(filePath, maxBytes, options = {}) {
   let identity6;
   function verify() {
     if (closing || exited || poisoned) throw unavailable12();
-    const dir = fs22.lstatSync(directory3, { bigint: true });
-    const current2 = fs22.lstatSync(file, { bigint: true });
+    const dir = fs23.lstatSync(directory3, { bigint: true });
+    const current2 = fs23.lstatSync(file, { bigint: true });
     if (dir.dev !== directoryIdentity2.dev || dir.ino !== directoryIdentity2.ino || !dir.isDirectory() || dir.isSymbolicLink() || current2.dev !== identity6.dev || current2.ino !== identity6.ino || !current2.isFile() || current2.nlink !== 1n || current2.isSymbolicLink()) {
       poisoned = true;
       throw unavailable12();
@@ -13526,7 +13578,7 @@ async function openWindowsPrivateJournal(filePath, maxBytes, options = {}) {
   }
   try {
     if (await response() !== "ready") throw unavailable12();
-    identity6 = fs22.lstatSync(file, { bigint: true });
+    identity6 = fs23.lstatSync(file, { bigint: true });
     verify();
   } catch (error2) {
     await close();
@@ -13760,9 +13812,9 @@ try {
 });
 
 // apps/desktop/src/platform/private-journal.ts
-import fs23 from "node:fs";
-import path30 from "node:path";
-import { randomUUID as randomUUID10 } from "node:crypto";
+import fs24 from "node:fs";
+import path31 from "node:path";
+import { randomUUID as randomUUID11 } from "node:crypto";
 function openPrivateJournal(filePath, maxBytes, platform2 = desktopPlatform()) {
   const policy = platform2.privateJournal;
   if (platform2.nodePlatform !== process.platform || platform2.capabilities.submissionJournal !== "implemented") {
@@ -13770,9 +13822,9 @@ function openPrivateJournal(filePath, maxBytes, platform2 = desktopPlatform()) {
   }
   if (platform2.id === "windows") return openWindowsPrivateJournal(filePath, maxBytes);
   if (policy.lockFlags === null) throw new PrivateJournalError("unavailable");
-  const file = path30.resolve(filePath);
-  const directory3 = path30.dirname(file);
-  const lockPath = path30.join(directory3, `.${path30.basename(file)}.lock`);
+  const file = path31.resolve(filePath);
+  const directory3 = path31.dirname(file);
+  const lockPath = path31.join(directory3, `.${path31.basename(file)}.lock`);
   let directoryFd;
   let lockFd;
   let fileStat = null;
@@ -13782,11 +13834,11 @@ function openPrivateJournal(filePath, maxBytes, platform2 = desktopPlatform()) {
   const trusted5 = (stats, directory4 = false) => policy.trustedNode(stats, directory4);
   function verifyOwnership() {
     if (closed || poisoned) throw new PrivateJournalError("unavailable");
-    const dir = fs23.lstatSync(directory3);
-    const lock = fs23.lstatSync(lockPath);
-    if (!trusted5(dir, true) || !sameFile(dir, fs23.fstatSync(directoryFd)) || !trusted5(lock) || !sameFile(lock, fs23.fstatSync(lockFd))) throw new PrivateJournalError("unavailable");
+    const dir = fs24.lstatSync(directory3);
+    const lock = fs24.lstatSync(lockPath);
+    if (!trusted5(dir, true) || !sameFile(dir, fs24.fstatSync(directoryFd)) || !trusted5(lock) || !sameFile(lock, fs24.fstatSync(lockFd))) throw new PrivateJournalError("unavailable");
     try {
-      const current2 = fs23.lstatSync(file);
+      const current2 = fs24.lstatSync(file);
       if (!trusted5(current2) || fileStat === null || !sameFile(current2, fileStat)) throw new PrivateJournalError("unavailable");
     } catch (error2) {
       if (error2.code !== "ENOENT" || fileStat !== null) throw error2;
@@ -13795,29 +13847,29 @@ function openPrivateJournal(filePath, maxBytes, platform2 = desktopPlatform()) {
   function close() {
     closed = true;
     try {
-      if (lockFd !== void 0) fs23.closeSync(lockFd);
+      if (lockFd !== void 0) fs24.closeSync(lockFd);
     } finally {
       lockFd = void 0;
       if (directoryFd !== void 0) {
-        fs23.closeSync(directoryFd);
+        fs24.closeSync(directoryFd);
         directoryFd = void 0;
       }
     }
   }
   try {
-    fs23.mkdirSync(directory3, { recursive: true, mode: 448 });
-    if (!trusted5(fs23.lstatSync(directory3), true)) throw new PrivateJournalError("unavailable");
-    directoryFd = fs23.openSync(directory3, fs23.constants.O_RDONLY | fs23.constants.O_NOFOLLOW);
-    if (!trusted5(fs23.fstatSync(directoryFd), true)) throw new PrivateJournalError("unavailable");
+    fs24.mkdirSync(directory3, { recursive: true, mode: 448 });
+    if (!trusted5(fs24.lstatSync(directory3), true)) throw new PrivateJournalError("unavailable");
+    directoryFd = fs24.openSync(directory3, fs24.constants.O_RDONLY | fs24.constants.O_NOFOLLOW);
+    if (!trusted5(fs24.fstatSync(directoryFd), true)) throw new PrivateJournalError("unavailable");
     try {
-      if (!trusted5(fs23.lstatSync(lockPath))) throw new PrivateJournalError("unavailable");
+      if (!trusted5(fs24.lstatSync(lockPath))) throw new PrivateJournalError("unavailable");
     } catch (error2) {
       if (error2.code !== "ENOENT") throw error2;
     }
-    lockFd = fs23.openSync(lockPath, policy.lockFlags, 384);
-    if (!trusted5(fs23.fstatSync(lockFd)) || !sameFile(fs23.fstatSync(lockFd), fs23.lstatSync(lockPath))) throw new PrivateJournalError("unavailable");
+    lockFd = fs24.openSync(lockPath, policy.lockFlags, 384);
+    if (!trusted5(fs24.fstatSync(lockFd)) || !sameFile(fs24.fstatSync(lockFd), fs24.lstatSync(lockPath))) throw new PrivateJournalError("unavailable");
     try {
-      fileStat = fs23.lstatSync(file);
+      fileStat = fs24.lstatSync(file);
       if (!trusted5(fileStat)) throw new PrivateJournalError("unavailable");
       if (fileStat.size > maxBytes) throw new PrivateJournalError("capacity");
     } catch (error2) {
@@ -13833,45 +13885,45 @@ function openPrivateJournal(filePath, maxBytes, platform2 = desktopPlatform()) {
     read() {
       verifyOwnership();
       if (fileStat === null) return null;
-      const fd = fs23.openSync(file, fs23.constants.O_RDONLY | fs23.constants.O_NOFOLLOW);
+      const fd = fs24.openSync(file, fs24.constants.O_RDONLY | fs24.constants.O_NOFOLLOW);
       try {
-        if (!trusted5(fs23.fstatSync(fd)) || !sameFile(fileStat, fs23.fstatSync(fd))) throw new PrivateJournalError("unavailable");
+        if (!trusted5(fs24.fstatSync(fd)) || !sameFile(fileStat, fs24.fstatSync(fd))) throw new PrivateJournalError("unavailable");
         const buffer = Buffer.alloc(maxBytes + 1);
-        const length = fs23.readSync(fd, buffer, 0, buffer.length, 0);
+        const length = fs24.readSync(fd, buffer, 0, buffer.length, 0);
         if (length > maxBytes) throw new PrivateJournalError("capacity");
         verifyOwnership();
         return buffer.subarray(0, length).toString("utf8");
       } finally {
-        fs23.closeSync(fd);
+        fs24.closeSync(fd);
       }
     },
     commit(body) {
       if (Buffer.byteLength(body) > maxBytes) throw new PrivateJournalError("capacity");
-      const temporary = path30.join(directory3, `.${path30.basename(file)}.${randomUUID10()}.tmp`);
+      const temporary = path31.join(directory3, `.${path31.basename(file)}.${randomUUID11()}.tmp`);
       let created = false;
       try {
         verifyOwnership();
-        const fd = fs23.openSync(temporary, fs23.constants.O_WRONLY | fs23.constants.O_CREAT | fs23.constants.O_EXCL | fs23.constants.O_NOFOLLOW, 384);
+        const fd = fs24.openSync(temporary, fs24.constants.O_WRONLY | fs24.constants.O_CREAT | fs24.constants.O_EXCL | fs24.constants.O_NOFOLLOW, 384);
         created = true;
         try {
-          if (!trusted5(fs23.fstatSync(fd))) throw new PrivateJournalError("unavailable");
-          fs23.writeFileSync(fd, body, "utf8");
-          fs23.fsyncSync(fd);
+          if (!trusted5(fs24.fstatSync(fd))) throw new PrivateJournalError("unavailable");
+          fs24.writeFileSync(fd, body, "utf8");
+          fs24.fsyncSync(fd);
         } finally {
-          fs23.closeSync(fd);
+          fs24.closeSync(fd);
         }
         verifyOwnership();
-        fs23.renameSync(temporary, file);
+        fs24.renameSync(temporary, file);
         created = false;
-        fileStat = fs23.lstatSync(file);
-        fs23.fsyncSync(directoryFd);
+        fileStat = fs24.lstatSync(file);
+        fs24.fsyncSync(directoryFd);
       } catch {
         poisoned = true;
         throw new PrivateJournalError("write_failed");
       } finally {
         if (created) {
           try {
-            fs23.unlinkSync(temporary);
+            fs24.unlinkSync(temporary);
           } catch {
           }
         }
@@ -14219,20 +14271,20 @@ function sendJson(response, httpStatus, body) {
 }
 function zodErrorToHttpApiError(error2) {
   const messages = error2.issues.map((issue) => {
-    const path70 = issue.path.join(".") || "\u53C2\u6570";
+    const path71 = issue.path.join(".") || "\u53C2\u6570";
     if (issue.code === "custom") {
       return issue.message;
     }
     if (issue.code === "invalid_type" && issue.received === "undefined") {
-      return `${path70}\u4E0D\u80FD\u4E3A\u7A7A`;
+      return `${path71}\u4E0D\u80FD\u4E3A\u7A7A`;
     }
     if (issue.code === "invalid_type") {
-      return `${path70}\u7C7B\u578B\u9519\u8BEF`;
+      return `${path71}\u7C7B\u578B\u9519\u8BEF`;
     }
     if (issue.code === "unrecognized_keys") {
       return `\u4E0D\u652F\u6301\u7684\u53C2\u6570: ${issue.keys.join(",")}`;
     }
-    return `${path70}\u683C\u5F0F\u9519\u8BEF`;
+    return `${path71}\u683C\u5F0F\u9519\u8BEF`;
   });
   const custom = error2.issues.some((issue) => issue.code === "custom");
   const missing4 = error2.issues.some(
@@ -14535,7 +14587,7 @@ var init_transfer_diagnostics = __esm({
 });
 
 // apps/desktop/src/attachments/transfer-registry.ts
-import { randomBytes as randomBytes3, randomUUID as randomUUID11 } from "node:crypto";
+import { randomBytes as randomBytes3, randomUUID as randomUUID12 } from "node:crypto";
 function fail14(kind) {
   const e = ATTACHMENT_TRANSFER_ERRORS[kind];
   throw new AttachmentTransferError(e.code, e.message);
@@ -14704,7 +14756,7 @@ function createAttachmentTransferRegistry(options) {
           recordAttachmentDiagnostic(options.diagnostic, { phase: "prepare", reason: active2.has(scope.bindingId) ? "active_stream" : "attempt_capacity", code: 400606 });
           fail14("capacity");
         }
-        const expires = Math.min(scope.expiresAtMs, u.owner.expiresAtMs), transferId = randomUUID11(), epochId = randomUUID11();
+        const expires = Math.min(scope.expiresAtMs, u.owner.expiresAtMs), transferId = randomUUID12(), epochId = randomUUID12();
         const secret = randomBytes3(32);
         const encoded = encodeBase64Url(secret);
         secret.fill(0);
@@ -15101,7 +15153,7 @@ var init_connection_handoff_source = __esm({
 });
 
 // apps/desktop/src/daemon/project-list-stream.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 function createProjectListStreamHub(dependencies) {
   const subscriptions = /* @__PURE__ */ new Map();
   const sources = /* @__PURE__ */ new Map();
@@ -15113,7 +15165,7 @@ function createProjectListStreamHub(dependencies) {
     ]);
     const nextIds = visibleIds(next.snapshot);
     const removed = [...visibleIds(state.source.current.snapshot.snapshot)].some((id5) => !nextIds.has(id5));
-    if (state.handoff && removed) state.source.replaceEpoch(randomUUID12(), next);
+    if (state.handoff && removed) state.source.replaceEpoch(randomUUID13(), next);
     else state.source.publish(next);
   };
   const logProjection = (type, revision4, diagnostic) => {
@@ -15138,7 +15190,7 @@ function createProjectListStreamHub(dependencies) {
     }
   };
   const attach = (state, scope, send, kind) => {
-    const subscriptionId = randomUUID12();
+    const subscriptionId = randomUUID13();
     let revision4 = 0;
     let initializing = true;
     const pending = [];
@@ -15342,12 +15394,12 @@ function createProjectListStreamHub(dependencies) {
         processEvent(state, event);
       });
       state.snapshot = readSnapshot(state);
-      const sourceId = randomUUID12();
+      const sourceId = randomUUID13();
       let unregister = () => {
       };
       state.source = new HandoffSource({
         sourceId,
-        epoch: randomUUID12(),
+        epoch: randomUUID13(),
         initial: { snapshot: state.snapshot, windows: {}, update: null },
         onUnused: () => {
           sources.delete(sourceId);
@@ -17681,7 +17733,7 @@ var init_routes = __esm({
 });
 
 // apps/desktop/src/http/sse.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 function encodeSseFrame(frame) {
   return [
     ...frame.id ? [`id: ${frame.id}`] : [],
@@ -18009,7 +18061,7 @@ var init_sse = __esm({
           throw new HttpApiError(200, 400604, "SSE\u4EA4\u63A5\u5BB9\u91CF\u4E0D\u8DB3");
         }
         return Array.from({ length: count }, () => {
-          const id5 = randomUUID13();
+          const id5 = randomUUID14();
           this.reservedSlots.add(id5);
           return { id: id5, release: () => {
             this.reservedSlots.delete(id5);
@@ -18055,7 +18107,7 @@ var init_sse = __esm({
 });
 
 // apps/desktop/src/http/server.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import http from "node:http";
 import { isIP as isIP3 } from "node:net";
 function safeAuditIdentifier(value) {
@@ -18609,7 +18661,7 @@ var init_server = __esm({
         try {
           this.errorLogger?.write({
             ts: (/* @__PURE__ */ new Date()).toISOString(),
-            failureId: diagnostic?.failureId ?? `fail_${randomUUID14()}`,
+            failureId: diagnostic?.failureId ?? `fail_${randomUUID15()}`,
             service: "desktop",
             component: "gateway",
             channel: request2.channel,
@@ -18804,7 +18856,7 @@ var init_args = __esm({
 
 // apps/desktop/src/autostart/production.ts
 import os5 from "node:os";
-import path31 from "node:path";
+import path32 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");
@@ -18813,7 +18865,7 @@ function autostartConfig(args, relayOrigin) {
     releaseVersion: version2,
     nodeExecutable: process.execPath,
     home: os5.homedir(),
-    path: [path31.dirname(process.execPath), process.env.PATH ?? "/usr/bin:/bin"].join(":"),
+    path: [path32.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),
@@ -18878,19 +18930,19 @@ var init_production = __esm({
 });
 
 // apps/desktop/src/lite-install/dmg.mjs
-import fs24 from "node:fs/promises";
+import fs25 from "node:fs/promises";
 import os6 from "node:os";
-import path32 from "node:path";
+import path33 from "node:path";
 import { execFile as execFile7 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 async function prepareDmgApp({ dmg, stage, run = systemRun, verify }) {
-  const root = await fs24.realpath(await fs24.mkdtemp(path32.join(os6.tmpdir(), "niuma-lite-mount-")));
-  const mount = path32.join(root, "volume");
-  await fs24.mkdir(mount, { mode: 448 });
+  const root = await fs25.realpath(await fs25.mkdtemp(path33.join(os6.tmpdir(), "niuma-lite-mount-")));
+  const mount = path33.join(root, "volume");
+  await fs25.mkdir(mount, { mode: 448 });
   let device, attached = false, uncertain = false;
   const parse = async (xml2) => {
-    const file = path32.join(root, "mount.plist");
-    await fs24.writeFile(file, xml2, { mode: 384 });
+    const file = path33.join(root, "mount.plist");
+    await fs25.writeFile(file, xml2, { mode: 384 });
     return JSON.parse(await run("/usr/bin/plutil", ["-convert", "json", "-o", "-", file]));
   };
   const find = (data) => {
@@ -18912,13 +18964,13 @@ async function prepareDmgApp({ dmg, stage, run = systemRun, verify }) {
       }
       throw error2;
     }
-    const app = path32.join(mount, "Niuma Lite.app");
-    if (!(await fs24.lstat(app)).isDirectory() || await fs24.realpath(app) !== path32.join(await fs24.realpath(mount), "Niuma Lite.app")) throw Error("DMG \u5E94\u7528\u8DEF\u5F84\u65E0\u6548");
-    for (const entry of await fs24.readdir(app, { recursive: true, withFileTypes: true })) {
+    const app = path33.join(mount, "Niuma Lite.app");
+    if (!(await fs25.lstat(app)).isDirectory() || await fs25.realpath(app) !== path33.join(await fs25.realpath(mount), "Niuma Lite.app")) throw Error("DMG \u5E94\u7528\u8DEF\u5F84\u65E0\u6548");
+    for (const entry of await fs25.readdir(app, { recursive: true, withFileTypes: true })) {
       if (!entry.isDirectory() && !entry.isFile()) throw Error("DMG \u5E94\u7528\u5305\u542B\u94FE\u63A5\u6216\u7279\u6B8A\u6587\u4EF6");
     }
-    const destination = path32.join(stage, "app");
-    await fs24.cp(app, destination, { recursive: true, errorOnExist: true, force: false });
+    const destination = path33.join(stage, "app");
+    await fs25.cp(app, destination, { recursive: true, errorOnExist: true, force: false });
     await verify(destination);
   } finally {
     if (device) {
@@ -18928,7 +18980,7 @@ async function prepareDmgApp({ dmg, stage, run = systemRun, verify }) {
         throw Error(`\u65E0\u6CD5\u5378\u8F7D\u672C\u6B21 DMG ${device} (${mount})\uFF1A${error2.message}`);
       }
     } else if (uncertain) throw Error(`\u65E0\u6CD5\u786E\u8BA4\u672C\u6B21 DMG \u662F\u5426\u5DF2\u5378\u8F7D\uFF0C\u8BF7\u68C0\u67E5\u6302\u8F7D\u70B9 ${mount}`);
-    await fs24.rm(root, { recursive: true, force: true });
+    await fs25.rm(root, { recursive: true, force: true });
   }
 }
 var exec3, systemRun;
@@ -18941,12 +18993,12 @@ var init_dmg = __esm({
 });
 
 // apps/desktop/src/lite-install/bundled-resources.mjs
-import fs25 from "node:fs/promises";
+import fs26 from "node:fs/promises";
 import { createReadStream } from "node:fs";
-import path33 from "node:path";
+import path34 from "node:path";
 import { createHash as createHash5 } from "node:crypto";
 async function verifyLocalArtifact(file, artifact) {
-  const st = await fs25.lstat(file);
+  const st = await fs26.lstat(file);
   if (!st.isFile() || st.size !== artifact.size) throw Error("\u672C\u5730\u8D44\u6E90\u7C7B\u578B\u6216\u957F\u5EA6\u65E0\u6548");
   let size2 = 0;
   const hash3 = createHash5("sha256");
@@ -18959,14 +19011,14 @@ async function verifyLocalArtifact(file, artifact) {
 }
 async function resolveBundledResources(packageRoot, manifest, arch) {
   if (manifest.schema !== 2) throw Error("\u9700\u8981\u672C\u5730\u8D44\u6E90\u6E05\u5355");
-  const root = await fs25.realpath(packageRoot), result = {};
-  const resources = path33.join(root, "resources");
-  if (!(await fs25.lstat(resources)).isDirectory() || await fs25.realpath(resources) !== resources) throw Error("\u8D44\u6E90\u76EE\u5F55\u4E0D\u80FD\u662F\u94FE\u63A5");
+  const root = await fs26.realpath(packageRoot), result = {};
+  const resources = path34.join(root, "resources");
+  if (!(await fs26.lstat(resources)).isDirectory() || await fs26.realpath(resources) !== resources) throw Error("\u8D44\u6E90\u76EE\u5F55\u4E0D\u80FD\u662F\u94FE\u63A5");
   for (const kind of ["app", "runtime"]) {
-    const a = manifest.artifacts[`darwin-${arch}`][kind], file = path33.resolve(root, a.path);
-    if (path33.dirname(file) !== resources) throw Error("\u672C\u5730\u8D44\u6E90\u8DEF\u5F84\u9003\u9038");
+    const a = manifest.artifacts[`darwin-${arch}`][kind], file = path34.resolve(root, a.path);
+    if (path34.dirname(file) !== resources) throw Error("\u672C\u5730\u8D44\u6E90\u8DEF\u5F84\u9003\u9038");
     await verifyLocalArtifact(file, a);
-    if (await fs25.realpath(file) !== file) throw Error("\u8D44\u6E90\u6587\u4EF6\u4E0D\u80FD\u662F\u94FE\u63A5");
+    if (await fs26.realpath(file) !== file) throw Error("\u8D44\u6E90\u6587\u4EF6\u4E0D\u80FD\u662F\u94FE\u63A5");
     result[kind] = file;
   }
   return result;
@@ -18983,13 +19035,13 @@ var init_bundled_resources = __esm({
 });
 
 // apps/desktop/src/lite-install/installer.ts
-import fs26 from "node:fs/promises";
+import fs27 from "node:fs/promises";
 import sync from "node:fs";
-import path34 from "node:path";
-import { randomUUID as randomUUID15 } from "node:crypto";
+import path35 from "node:path";
+import { randomUUID as randomUUID16 } from "node:crypto";
 async function exists(file) {
   try {
-    await fs26.lstat(file);
+    await fs27.lstat(file);
     return true;
   } catch (e) {
     if (e.code === "ENOENT") return false;
@@ -18998,61 +19050,61 @@ async function exists(file) {
 }
 async function readConfig(file) {
   if (!await exists(file)) return null;
-  const v = JSON.parse(await fs26.readFile(file, "utf8"));
+  const v = JSON.parse(await fs27.readFile(file, "utf8"));
   if (v.schema !== 1 || typeof v.combinationId !== "string" || typeof v.runtimeDir !== "string" || typeof v.nodePath !== "string") throw Error("\u8FD0\u884C\u914D\u7F6E\u635F\u574F\uFF0C\u8BF7\u68C0\u67E5\u5B89\u88C5\u76EE\u5F55");
   return v;
 }
 async function atomic2(file, value) {
-  const temp = file + "." + randomUUID15();
-  await fs26.writeFile(temp, JSON.stringify(value) + "\n", { mode: 384, flag: "wx" });
-  const fd = await fs26.open(temp, "r");
+  const temp = file + "." + randomUUID16();
+  await fs27.writeFile(temp, JSON.stringify(value) + "\n", { mode: 384, flag: "wx" });
+  const fd = await fs27.open(temp, "r");
   try {
     await fd.sync();
   } finally {
     await fd.close();
   }
-  await fs26.rename(temp, file);
+  await fs27.rename(temp, file);
 }
 async function installLite(o) {
   const result = await installLiteLocked(o);
-  await o.open(path34.join(o.installRoot, "Niuma Lite.app"));
+  await o.open(path35.join(o.installRoot, "Niuma Lite.app"));
   return result;
 }
 async function installLiteLocked(o) {
   if (!/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(o.version)) throw Error("\u9700\u8981\u660E\u786E\u7684\u53D1\u5E03\u7248\u672C");
   await privateDirectory(o.runtimeRoot);
   await privateDirectory(o.installRoot);
-  await privateDirectory(path34.join(o.runtimeRoot, "versions"));
-  const lock = sync.openSync(path34.join(o.runtimeRoot, "install.lock"), sync.constants.O_RDWR | sync.constants.O_CREAT | sync.constants.O_NOFOLLOW | sync.constants.O_NONBLOCK | 32, 384);
-  const app = path34.join(o.installRoot, "Niuma Lite.app"), current2 = path34.join(o.runtimeRoot, "current.json"), journal = path34.join(o.runtimeRoot, "transaction.json");
+  await privateDirectory(path35.join(o.runtimeRoot, "versions"));
+  const lock = sync.openSync(path35.join(o.runtimeRoot, "install.lock"), sync.constants.O_RDWR | sync.constants.O_CREAT | sync.constants.O_NOFOLLOW | sync.constants.O_NONBLOCK | 32, 384);
+  const app = path35.join(o.installRoot, "Niuma Lite.app"), current2 = path35.join(o.runtimeRoot, "current.json"), journal = path35.join(o.runtimeRoot, "transaction.json");
   const recover = async () => {
     if (!await exists(journal)) return;
-    const txn = JSON.parse(await fs26.readFile(journal, "utf8"));
-    if (txn.schema !== 1 || path34.dirname(txn.stage) !== o.runtimeRoot || !path34.basename(txn.stage).startsWith(".stage-")) throw Error("\u66F4\u65B0\u8BB0\u5F55\u65E0\u6548\uFF0C\u62D2\u7EDD\u4FEE\u6539\u5E94\u7528");
-    if (path34.dirname(txn.backup) !== o.installRoot || !path34.basename(txn.backup).startsWith(".Niuma Lite.previous-") || path34.dirname(txn.stagedApp) !== o.installRoot || !path34.basename(txn.stagedApp).startsWith(".Niuma Lite.installing-")) throw Error("\u66F4\u65B0\u8BB0\u5F55\u8DEF\u5F84\u65E0\u6548");
+    const txn = JSON.parse(await fs27.readFile(journal, "utf8"));
+    if (txn.schema !== 1 || path35.dirname(txn.stage) !== o.runtimeRoot || !path35.basename(txn.stage).startsWith(".stage-")) throw Error("\u66F4\u65B0\u8BB0\u5F55\u65E0\u6548\uFF0C\u62D2\u7EDD\u4FEE\u6539\u5E94\u7528");
+    if (path35.dirname(txn.backup) !== o.installRoot || !path35.basename(txn.backup).startsWith(".Niuma Lite.previous-") || path35.dirname(txn.stagedApp) !== o.installRoot || !path35.basename(txn.stagedApp).startsWith(".Niuma Lite.installing-")) throw Error("\u66F4\u65B0\u8BB0\u5F55\u8DEF\u5F84\u65E0\u6548");
     if (await exists(app)) await o.assertOwnedApp(app);
     if (await exists(txn.backup)) {
       await o.assertOwnedApp(txn.backup);
-      await fs26.rm(app, { recursive: true, force: true });
-      await fs26.rename(txn.backup, app);
+      await fs27.rm(app, { recursive: true, force: true });
+      await fs27.rename(txn.backup, app);
     } else if (!txn.hadApp) {
-      await fs26.rm(app, { recursive: true, force: true });
+      await fs27.rm(app, { recursive: true, force: true });
     }
     if (txn.oldConfig) await atomic2(current2, txn.oldConfig);
-    else await fs26.rm(current2, { force: true });
-    await fs26.rm(txn.stagedApp, { recursive: true, force: true });
-    await fs26.rm(txn.stage, { recursive: true, force: true });
-    await fs26.rm(journal);
+    else await fs27.rm(current2, { force: true });
+    await fs27.rm(txn.stagedApp, { recursive: true, force: true });
+    await fs27.rm(txn.stage, { recursive: true, force: true });
+    await fs27.rm(journal);
   };
   try {
-    if (await exists(path34.join(o.runtimeRoot, "uninstall.json"))) throw Error("\u5378\u8F7D\u5C1A\u672A\u5B8C\u6210\uFF0C\u8BF7\u5148\u91CD\u65B0\u8FD0\u884C uninstall-app");
+    if (await exists(path35.join(o.runtimeRoot, "uninstall.json"))) throw Error("\u5378\u8F7D\u5C1A\u672A\u5B8C\u6210\uFF0C\u8BF7\u5148\u91CD\u65B0\u8FD0\u884C uninstall-app");
     await recover();
     const previous = await readConfig(current2);
     if (await exists(app)) {
       if (!previous) throw Error("\u540C\u540D\u975E\u6258\u7BA1\u5E94\u7528\u5DF2\u5B58\u5728\uFF0C\u62D2\u7EDD\u8986\u76D6");
       await o.assertOwnedApp(app);
     }
-    if (previous && !path34.resolve(previous.runtimeDir).startsWith(path34.resolve(o.runtimeRoot, "versions") + path34.sep)) throw Error("\u8FD0\u884C\u914D\u7F6E\u8DEF\u5F84\u4E0D\u53EF\u4FE1");
+    if (previous && !path35.resolve(previous.runtimeDir).startsWith(path35.resolve(o.runtimeRoot, "versions") + path35.sep)) throw Error("\u8FD0\u884C\u914D\u7F6E\u8DEF\u5F84\u4E0D\u53EF\u4FE1");
     if (previous && compareVersions(previous.combinationId, o.version) > 0) throw Error("\u5DF2\u5B89\u88C5\u8F83\u65B0\u7248\u672C\uFF0C\u8BF7\u4F7F\u7528 npx niuma-codex@latest install-app");
     if (previous?.combinationId === o.version && previous.nodePath === o.nodePath) {
       let valid = false;
@@ -19065,39 +19117,39 @@ async function installLiteLocked(o) {
         return { installed: false, version: o.version };
       }
     }
-    const stage = path34.join(o.runtimeRoot, ".stage-" + randomUUID15());
+    const stage = path35.join(o.runtimeRoot, ".stage-" + randomUUID16());
     await privateDirectory(stage);
     try {
       await o.prepare(stage);
-      await o.verify(path34.join(stage, "app"), path34.join(stage, "runtime"));
+      await o.verify(path35.join(stage, "app"), path35.join(stage, "runtime"));
       if (previous && !await o.confirm()) throw Error("\u5DF2\u53D6\u6D88\u66F4\u65B0");
       if (await exists(app)) {
         if (!previous) throw Error("\u540C\u540D\u975E\u6258\u7BA1\u5E94\u7528\u5DF2\u5B58\u5728\uFF0C\u62D2\u7EDD\u8986\u76D6");
         await o.assertOwnedApp(app);
       }
       await o.stopHost();
-      const runtime = path34.join(o.runtimeRoot, "versions", o.version + "-" + randomUUID15());
-      const backup = path34.join(o.installRoot, ".Niuma Lite.previous-" + randomUUID15() + ".app");
-      const stagedApp = path34.join(o.installRoot, ".Niuma Lite.installing-" + randomUUID15() + ".app");
+      const runtime = path35.join(o.runtimeRoot, "versions", o.version + "-" + randomUUID16());
+      const backup = path35.join(o.installRoot, ".Niuma Lite.previous-" + randomUUID16() + ".app");
+      const stagedApp = path35.join(o.installRoot, ".Niuma Lite.installing-" + randomUUID16() + ".app");
       const txn = { schema: 1, stage, backup, stagedApp, oldConfig: previous, hadApp: await exists(app) };
       await atomic2(journal, txn);
-      if (txn.hadApp) await fs26.rename(app, backup);
+      if (txn.hadApp) await fs27.rename(app, backup);
       await o.checkpoint?.("app-backed-up");
       if (await exists(stagedApp)) throw Error("\u5E94\u7528\u6682\u5B58\u76EE\u5F55\u5DF2\u5B58\u5728\uFF0C\u8BF7\u68C0\u67E5\u5B89\u88C5\u72B6\u6001");
-      await fs26.cp(path34.join(stage, "app"), stagedApp, { recursive: true, errorOnExist: true, force: false });
-      await fs26.rename(stagedApp, app);
+      await fs27.cp(path35.join(stage, "app"), stagedApp, { recursive: true, errorOnExist: true, force: false });
+      await fs27.rename(stagedApp, app);
       await o.checkpoint?.("app-replaced");
-      await fs26.rename(path34.join(stage, "runtime"), runtime);
+      await fs27.rename(path35.join(stage, "runtime"), runtime);
       const config = { schema: 1, combinationId: o.version, daemonVersion: o.version, runtimeDir: runtime, nodePath: o.nodePath };
       await atomic2(current2, config);
       await o.checkpoint?.("config-replaced");
-      await fs26.rm(journal);
+      await fs27.rm(journal);
       return { installed: true, version: o.version };
     } catch (error2) {
       await recover();
       throw error2;
     } finally {
-      await fs26.rm(stage, { recursive: true, force: true });
+      await fs27.rm(stage, { recursive: true, force: true });
     }
   } finally {
     sync.closeSync(lock);
@@ -19150,15 +19202,15 @@ var init_manifest = __esm({
 });
 
 // apps/desktop/src/lite-install/resources.ts
-import path35 from "node:path";
+import path36 from "node:path";
 import { createHash as createHash6 } from "node:crypto";
 import { createWriteStream } from "node:fs";
-import fs27 from "node:fs/promises";
+import fs28 from "node:fs/promises";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import * as tar from "tar";
 function safeArchiveEntry(name2, type) {
-  return !name2.includes("\\") && !path35.posix.isAbsolute(name2) && !name2.split("/").includes("..") && ["File", "Directory", "OldFile", "ContiguousFile"].includes(type);
+  return !name2.includes("\\") && !path36.posix.isAbsolute(name2) && !name2.split("/").includes("..") && ["File", "Directory", "OldFile", "ContiguousFile"].includes(type);
 }
 async function download(a, file) {
   const signal = AbortSignal.timeout(12e4);
@@ -19200,7 +19252,7 @@ async function extract(file, destination) {
     if (!safeArchiveEntry(entry.path, entry.type) || total > 2 * 1024 * 1024 * 1024 || count > 1e5) invalid14 = true;
   } });
   if (invalid14) throw Error("\u53D1\u884C\u5F52\u6863\u5305\u542B\u4E0D\u5B89\u5168\u8DEF\u5F84\u6216\u94FE\u63A5");
-  await fs27.mkdir(destination, { recursive: true, mode: 448 });
+  await fs28.mkdir(destination, { recursive: true, mode: 448 });
   await tar.x({ file, cwd: destination, strict: true, preservePaths: false, noChmod: true, noMtime: true });
 }
 var init_resources = __esm({
@@ -19211,17 +19263,16 @@ var init_resources = __esm({
 });
 
 // apps/desktop/src/lite-install/production.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import fs28 from "node:fs/promises";
-import path36 from "node:path";
+import fs29 from "node:fs/promises";
+import path37 from "node:path";
 import os7 from "node:os";
 import { createInterface as createInterface3 } from "node:readline/promises";
 async function runLiteInstall() {
   if (process.platform !== "darwin") throw Error("\u8F7B\u91CF\u684C\u9762\u5E94\u7528\u4EC5\u652F\u6301 macOS\uFF0C\u8BF7\u4F7F\u7528 --background");
   const version2 = desktopReleaseVersion();
-  if (!version2 || false || false) throw Error("\u6B64\u7248\u672C\u5C1A\u672A\u914D\u7F6E Tauri \u8F7B\u91CF\u53D1\u884C\u8D44\u6E90\uFF0C\u6682\u4E0D\u80FD\u901A\u8FC7 install-app \u5B89\u88C5\uFF1B\u7EAF\u540E\u53F0\u8BF7\u4F7F\u7528 --background");
-  const manifest = validateManifest(JSON.parse('{\n  "schema": 2,\n  "source": "bundled",\n  "mode": "experimental",\n  "combinationId": "0.0.1-beta.23",\n  "cliVersion": "0.0.1-beta.23",\n  "daemonVersion": "0.0.1-beta.23",\n  "nodeRange": ">=18.20.5",\n  "artifacts": {\n    "darwin-arm64": {\n      "app": {\n        "path": "resources/niuma-lite-arm64.dmg",\n        "size": 8126371,\n        "sha256": "eac9e20cb8180d5e1c5b93e93973bbb956e7897e8552e8b6a3b6fc8922627cc9"\n      },\n      "runtime": {\n        "path": "resources/niuma-daemon-arm64.tgz",\n        "size": 18282144,\n        "sha256": "71e836c6cdd50868fb0bd8394a56a0032a822df63f1ad3b61dcbc98a13d400c9"\n      }\n    }\n  }\n}\n'), version2, process.arch);
+  if (!version2 || false || true) throw Error("\u6B64\u7248\u672C\u5C1A\u672A\u914D\u7F6E Tauri \u8F7B\u91CF\u53D1\u884C\u8D44\u6E90\uFF0C\u6682\u4E0D\u80FD\u901A\u8FC7 install-app \u5B89\u88C5\uFF1B\u7EAF\u540E\u53F0\u8BF7\u4F7F\u7528 --background");
+  const manifest = validateManifest(JSON.parse(""), version2, process.arch);
   if (manifest.schema === 2) await confirmExperimental(manifest.mode, !!process.stdin.isTTY && !!process.stdout.isTTY, async () => {
     const prompt = createInterface3({ input: process.stdin, output: process.stdout });
     try {
@@ -19231,26 +19282,26 @@ async function runLiteInstall() {
     }
   });
   const local = manifest.schema === 2 ? await resolveBundledResources(fileURLToPath(new URL("../", import.meta.url)), manifest, process.arch) : null;
-  const runtimeRoot = path36.join(os7.homedir(), "Library/Application Support/Niuma/lite-runtime");
+  const runtimeRoot = path37.join(os7.homedir(), "Library/Application Support/Niuma/lite-runtime");
   try {
-    await fs28.lstat(path36.join(runtimeRoot, "uninstall.json"));
+    await fs29.lstat(path37.join(runtimeRoot, "uninstall.json"));
     throw Error("\u5378\u8F7D\u5C1A\u672A\u5B8C\u6210\uFF0C\u8BF7\u5148\u91CD\u65B0\u8FD0\u884C uninstall-app");
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
   const assertOwnedApp = async (app) => {
     try {
-      const id5 = await runProcess("/usr/libexec/PlistBuddy", ["-c", "Print :CFBundleIdentifier", path36.join(app, "Contents/Info.plist")]);
+      const id5 = await runProcess("/usr/libexec/PlistBuddy", ["-c", "Print :CFBundleIdentifier", path37.join(app, "Contents/Info.plist")]);
       if (id5.trim() !== "com.niuma.macos.lite") throw Error("different identity");
     } catch {
       throw Error("\u540C\u540D\u5E94\u7528\u5F52\u5C5E\u65E0\u6CD5\u786E\u8BA4\uFF0C\u62D2\u7EDD\u8986\u76D6\uFF1B\u8BF7\u5148\u79FB\u8D70\u8BE5\u5E94\u7528\u540E\u91CD\u8BD5");
     }
   };
   const verifyApp = async (app) => {
-    const id5 = await runProcess("/usr/libexec/PlistBuddy", ["-c", "Print :CFBundleIdentifier", path36.join(app, "Contents/Info.plist")]);
+    const id5 = await runProcess("/usr/libexec/PlistBuddy", ["-c", "Print :CFBundleIdentifier", path37.join(app, "Contents/Info.plist")]);
     if (id5.trim() !== "com.niuma.macos.lite") throw Error("\u5E94\u7528\u6807\u8BC6\u4E0D\u5339\u914D");
-    if (JSON.parse(await fs28.readFile(path36.join(app, "Contents/Resources/niuma-release.json"), "utf8")).combinationId !== version2) throw Error("\u5E94\u7528\u53D1\u884C\u7EC4\u5408\u4E0D\u5339\u914D");
-    const binary = path36.join(app, "Contents/MacOS/niuma-lite");
+    if (JSON.parse(await fs29.readFile(path37.join(app, "Contents/Resources/niuma-release.json"), "utf8")).combinationId !== version2) throw Error("\u5E94\u7528\u53D1\u884C\u7EC4\u5408\u4E0D\u5339\u914D");
+    const binary = path37.join(app, "Contents/MacOS/niuma-lite");
     if ((await runProcess(binary, ["--runtime-version"])).trim() !== version2) throw Error("\u5E94\u7528\u4E8C\u8FDB\u5236\u7248\u672C\u4E0D\u5339\u914D");
     const arch = (await runProcess("/usr/bin/lipo", ["-archs", binary])).trim().split(/\s+/);
     if (!arch.includes(process.arch === "x64" ? "x86_64" : process.arch)) throw Error("\u5E94\u7528\u67B6\u6784\u4E0D\u5339\u914D");
@@ -19258,10 +19309,10 @@ async function runLiteInstall() {
   };
   const verify = async (app, runtime) => {
     await verifyApp(app);
-    const pkg = JSON.parse(await fs28.readFile(path36.join(runtime, "package.json"), "utf8"));
+    const pkg = JSON.parse(await fs29.readFile(path37.join(runtime, "package.json"), "utf8"));
     if (pkg.name !== "niuma-codex" || pkg.version !== version2) throw Error("daemon \u7248\u672C\u4E0D\u5339\u914D");
-    if (!(await fs28.stat(path36.join(runtime, "dist/managed-tauri.js"))).isFile()) throw Error("daemon \u5165\u53E3\u7F3A\u5931");
-    await runProcess(process.execPath, ["--input-type=module", "-e", `await import(${JSON.stringify(pathToFileURL(path36.join(runtime, "node_modules/sharp/lib/index.js")).href)})`]);
+    if (!(await fs29.stat(path37.join(runtime, "dist/managed-tauri.js"))).isFile()) throw Error("daemon \u5165\u53E3\u7F3A\u5931");
+    await runProcess(process.execPath, ["--input-type=module", "-e", `await import(${JSON.stringify(pathToFileURL(path37.join(runtime, "node_modules/sharp/lib/index.js")).href)})`]);
   };
   let confirmed = false;
   const confirm = async () => {
@@ -19276,34 +19327,8 @@ async function runLiteInstall() {
     }
   };
   await withInstallCoordination(runtimeRoot, async () => {
-    const pending = await readMigration(runtimeRoot);
-    if (pending && !["completed", "skipped"].includes(pending.phase) && pending.version !== version2) throw Error("\u8BF7\u5148\u4F7F\u7528\u539F\u7248\u672C install-app \u5B8C\u6210\u8FC1\u79FB");
-    const intentFile = path36.join(runtimeRoot, "install-intent.json");
-    let intent;
-    try {
-      const stat4 = await fs28.lstat(intentFile);
-      if (!stat4.isFile() || stat4.uid !== process.getuid?.() || stat4.mode & 63) throw Error("\u5B89\u88C5\u610F\u56FE\u6587\u4EF6\u4E0D\u53EF\u4FE1");
-      intent = JSON.parse(await fs28.readFile(intentFile, "utf8"));
-      if (typeof intent.firstInstall !== "boolean" || intent.version !== version2) throw Error("\u8BF7\u5148\u4F7F\u7528\u539F\u7248\u672C\u5B8C\u6210\u5B89\u88C5");
-    } catch (e) {
-      if (e.code !== "ENOENT") throw e;
-      let firstInstall = false;
-      try {
-        await fs28.lstat(path36.join(runtimeRoot, "current.json"));
-      } catch (e2) {
-        if (e2.code !== "ENOENT") throw e2;
-        firstInstall = true;
-      }
-      intent = { version: version2, firstInstall, selection: await createInstallSelection(os7.homedir(), true) };
-      await fs28.writeFile(intentFile, JSON.stringify(intent), { flag: "wx", mode: 384 });
-    }
-    if (!intent.selection) {
-      intent.selection = await createInstallSelection(os7.homedir(), false);
-      const temp = intentFile + "." + randomUUID16();
-      await fs28.writeFile(temp, JSON.stringify(intent), { flag: "wx", mode: 384 });
-      await fs28.rename(temp, intentFile);
-    }
-    if (typeof intent.selection.revision !== "string" || !intent.selection.revision || !Number.isSafeInteger(intent.selection.requestedAt) || intent.selection.requestedAt < 0 || !(intent.selection.previousRevision === null || typeof intent.selection.previousRevision === "string")) throw Error("\u5B89\u88C5\u9009\u62E9\u8BB0\u5F55\u65E0\u6548");
+    const intentFile = path37.join(runtimeRoot, "install-intent.json");
+    const { intent, pending } = await prepareInstallIntent(runtimeRoot, os7.homedir(), version2);
     const manager = createAutostartManager({ command: null, positionals: [], flags: {} });
     const needsSource = intent.firstInstall || !!(pending && !["completed", "skipped"].includes(pending.phase));
     const withSource = needsSource ? manager.withMigrationSource.bind(manager) : async (work) => work({ snapshot: async () => ({ fingerprint: "not-migrating", enabled: false }), remove: async () => {
@@ -19336,27 +19361,27 @@ async function runLiteInstall() {
       } });
       const result = await installLite({
         runtimeRoot,
-        installRoot: path36.join(os7.homedir(), "Applications"),
+        installRoot: path37.join(os7.homedir(), "Applications"),
         version: version2,
-        nodePath: await fs28.realpath(process.execPath),
+        nodePath: await fs29.realpath(process.execPath),
         verify,
         assertOwnedApp,
         prepare: async (stage) => {
           if (manifest.schema === 2 && local) {
             const artifacts = manifest.artifacts[`darwin-${process.arch}`];
             for (const kind of ["app", "runtime"]) {
-              const file = path36.join(stage, kind === "app" ? "app.dmg" : "runtime.tgz");
-              await fs28.copyFile(local[kind], file);
+              const file = path37.join(stage, kind === "app" ? "app.dmg" : "runtime.tgz");
+              await fs29.copyFile(local[kind], file);
               await verifyLocalArtifact(file, artifacts[kind]);
             }
-            await prepareDmgApp({ dmg: path36.join(stage, "app.dmg"), stage, verify: verifyApp });
-            await extract(path36.join(stage, "runtime.tgz"), path36.join(stage, "runtime"));
+            await prepareDmgApp({ dmg: path37.join(stage, "app.dmg"), stage, verify: verifyApp });
+            await extract(path37.join(stage, "runtime.tgz"), path37.join(stage, "runtime"));
           } else if (manifest.schema === 1) {
             const artifacts = manifest.artifacts[`darwin-${process.arch}`];
             for (const kind of ["app", "runtime"]) {
-              const file = path36.join(stage, kind + ".tgz");
+              const file = path37.join(stage, kind + ".tgz");
               await download(artifacts[kind], file);
-              await extract(file, path36.join(stage, kind));
+              await extract(file, path37.join(stage, kind));
             }
           }
         },
@@ -19423,7 +19448,7 @@ async function runLiteInstall() {
         });
       }, "login-settings.lock");
       if (migration === "failed") throw Error("\u4E0A\u6B21\u81EA\u542F\u52A8\u8FC1\u79FB\u5931\u8D25\uFF0C\u539F npm \u914D\u7F6E\u4FDD\u7559\uFF1B\u8BF7\u5728 Lite \u8BBE\u7F6E\u4E2D\u660E\u786E\u91CD\u65B0\u5F00\u542F\u540E\u91CD\u8BD5\u5B89\u88C5");
-      if (migration !== "pending" || !historical && sourceBefore.enabled === true) await fs28.rm(intentFile, { force: true });
+      if (migration !== "pending" || !historical && sourceBefore.enabled === true) await fs29.rm(intentFile, { force: true });
       const waiting = historical || sourceBefore.enabled === null ? "\u72B6\u6001\u5F85\u786E\u8BA4\uFF0C\u4FDD\u7559\u539F npm \u914D\u7F6E\uFF1B\u8BF7\u68C0\u67E5\u7CFB\u7EDF\u767B\u5F55\u9879\u540E\u91CD\u8BD5 install-app" : "\u63A5\u7BA1\u5F85\u786E\u8BA4\uFF0C\u4FDD\u7559\u539F npm \u914D\u7F6E\uFF1B\u7CFB\u7EDF\u6279\u51C6\u540E\u7531\u8FD0\u884C\u4E2D\u7684\u5E94\u7528\u6216\u670D\u52A1\u5B8C\u6210\u63A5\u7BA1";
       process.stdout.write(`daemon \u5DF2\u5C31\u7EEA\uFF1B\u81EA\u542F\u52A8${migration === "completed" ? "\u5DF2\u8FC1\u79FB" : migration === "skipped" || migration === "superseded" || migration === "cancelled" ? "\u4FDD\u6301\u6700\u65B0\u8BBE\u7F6E" : waiting}\u3002
 `);
@@ -19437,6 +19462,7 @@ var init_production2 = __esm({
     init_host_control();
     init_lock();
     init_migration();
+    init_intent();
     init_lifecycle();
     init_production();
     init_client();
@@ -19849,15 +19875,15 @@ var init_client_turn_query_context = __esm({
 });
 
 // apps/desktop/src/niuma/session-history-file.ts
-import fs29 from "node:fs/promises";
-import path37 from "node:path";
+import fs30 from "node:fs/promises";
+import path38 from "node:path";
 import { createHash as createHash7 } from "node:crypto";
 function matchesSessionFileIdentity(file, stat4) {
   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(stat4.dev) && exact(file.ino) === String(stat4.ino);
 }
 async function preciseStat(file) {
-  const stat4 = await fs29.stat(file, { bigint: true });
+  const stat4 = await fs30.stat(file, { bigint: true });
   const size2 = Number(stat4.size);
   if (!Number.isSafeInteger(size2)) throw new SessionHistoryError("RESOURCE_LIMIT", "\u4F1A\u8BDD\u6587\u4EF6\u8D85\u51FA\u8BFB\u53D6\u8303\u56F4");
   return { dev: stat4.dev, ino: stat4.ino, size: size2, mtimeMs: Number(stat4.mtimeNs) / 1e6, isFile: () => stat4.isFile() };
@@ -19873,12 +19899,12 @@ function rethrowUnreadableHistoryPath(error2) {
 }
 function fileIdentity(file) {
   const uuid8 = "[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}";
-  const match = path37.basename(file).match(new RegExp(`(${uuid8})(?:_(${uuid8}))?\\.jsonl$`, "i"));
+  const match = path38.basename(file).match(new RegExp(`(${uuid8})(?:_(${uuid8}))?\\.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 fs29.open(file, "r").catch(rethrowUnreadableHistoryPath);
+  const handle = await fs30.open(file, "r").catch(rethrowUnreadableHistoryPath);
   try {
     const buffer = Buffer.allocUnsafe(length);
     let filled = 0;
@@ -19936,7 +19962,7 @@ async function header(file, size2, onRead, signal) {
 }
 async function openSessionFile(file, threadId2, chunkBytes, end, onRead, signal, onCutoffCaptured) {
   abortIfRequested(signal);
-  const resolved3 = await fs29.realpath(file).catch(rethrowUnreadableHistoryPath);
+  const resolved3 = await fs30.realpath(file).catch(rethrowUnreadableHistoryPath);
   const stat4 = await preciseStat(resolved3).catch(rethrowUnreadableHistoryPath);
   abortIfRequested(signal);
   if (!stat4.isFile()) throw new SessionHistoryError("INVALID_METADATA", "\u4F1A\u8BDD\u8DEF\u5F84\u4E0D\u662F\u666E\u901A\u6587\u4EF6");
@@ -22913,10 +22939,10 @@ var init_status = __esm({
 });
 
 // apps/desktop/src/niuma/thread-summary.ts
-import path38 from "node:path";
+import path39 from "node:path";
 function pathBelongsToProjectRoot(projectRoot, candidateRoot) {
-  const relative = path38.relative(path38.resolve(projectRoot), path38.resolve(candidateRoot));
-  return relative === "" || !relative.startsWith("..") && !path38.isAbsolute(relative);
+  const relative = path39.relative(path39.resolve(projectRoot), path39.resolve(candidateRoot));
+  return relative === "" || !relative.startsWith("..") && !path39.isAbsolute(relative);
 }
 function toLatestTurn(turns) {
   const latest = turns.at(-1);
@@ -22984,7 +23010,7 @@ function normalizeThreadSummary(thread4, pending = null, options = {}) {
     id: thread4.id,
     title: thread4.name ?? thread4.preview ?? "",
     projectRoot: thread4.cwd,
-    projectName: path38.basename(thread4.cwd) || thread4.cwd,
+    projectName: path39.basename(thread4.cwd) || thread4.cwd,
     status: status2,
     pending: normalizedPending,
     createdAt: thread4.createdAt,
@@ -26116,9 +26142,9 @@ function resourcePaths(platform2 = process.platform) {
     toLink(value) {
       const parsed = parseLocal(value);
       if (parsed === null) return null;
-      const path70 = windows2 ? parsed.replaceAll("\\", "/") : parsed;
+      const path71 = windows2 ? parsed.replaceAll("\\", "/") : parsed;
       try {
-        return encodeURIComponent(path70).replace(/%2F/gu, "/").replace(/^([a-z])%3A\//iu, "$1:/");
+        return encodeURIComponent(path71).replace(/%2F/gu, "/").replace(/^([a-z])%3A\//iu, "$1:/");
       } catch {
         return null;
       }
@@ -26262,8 +26288,8 @@ var init_response_annotations = __esm({
 
 // apps/desktop/src/attachments/image-identity.ts
 import { createHash as createHash12 } from "node:crypto";
-function unavailableImageId(path70, itemId, partIndex) {
-  const identity6 = itemId ? JSON.stringify([itemId, partIndex ?? null, path70]) : path70;
+function unavailableImageId(path71, itemId, partIndex) {
+  const identity6 = itemId ? JSON.stringify([itemId, partIndex ?? null, path71]) : path71;
   return `unavailable:${createHash12("sha256").update(identity6).digest("hex")}`;
 }
 var init_image_identity = __esm({
@@ -26357,15 +26383,15 @@ function normalizeMessageContent(value, resolveKnownLocalImage, itemId, original
   }
   return content2;
 }
-function userFile(name2, path70) {
+function userFile(name2, path71) {
   const part = { type: "file", name: name2 };
-  userFileSource.set(part, path70);
+  userFileSource.set(part, path71);
   return part;
 }
 function userFileSources(content2 = []) {
   return content2.flatMap((part, index) => {
-    const path70 = userFileSource.get(part);
-    return part.type === "file" && typeof path70 === "string" ? [{ index, path: path70 }] : [];
+    const path71 = userFileSource.get(part);
+    return part.type === "file" && typeof path71 === "string" ? [{ index, path: path71 }] : [];
   });
 }
 function codexImageWrapperFileList(text11) {
@@ -26402,11 +26428,11 @@ function standardCodexImageFileListEntries(fileList) {
       break;
     }
     const name2 = safeCodexFileName(match[1] ?? match[3] ?? "");
-    const path70 = match[2] ?? match[4] ?? "";
-    if (!name2 || !isRecordedResourcePath(path70)) {
+    const path71 = match[2] ?? match[4] ?? "";
+    if (!name2 || !isRecordedResourcePath(path71)) {
       return null;
     }
-    entries.push({ name: name2, path: path70 });
+    entries.push({ name: name2, path: path71 });
     remaining = remaining.slice(match[0].length);
     remaining = remaining.replace(/^Image attachment: true\r?\n/u, "");
   }
@@ -26422,10 +26448,10 @@ function redactCodexImageWrapperPaths(text11) {
   }
   const fileList = wrapper.fileList.replace(
     /(^## [^\r\n]+:[ \t]*\r?\n)[ \t]*([^\r\n]+)/gmu,
-    (all, prefix, path70) => isRecordedResourcePath(path70) ? `${prefix}[\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]` : all
+    (all, prefix, path71) => isRecordedResourcePath(path71) ? `${prefix}[\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]` : all
   ).replace(
     /^(## [^\r\n]+:)[ \t]+([^\r\n]+)$/gmu,
-    (all, prefix, path70) => isRecordedResourcePath(path70) ? `${prefix} [\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]` : all
+    (all, prefix, path71) => isRecordedResourcePath(path71) ? `${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)}`;
@@ -26436,7 +26462,7 @@ function redactKnownCodexWrapperPaths(text11, paths) {
     return text11;
   }
   const fileList = paths.reduce(
-    (result, path70) => result.replaceAll(path70, "[\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]"),
+    (result, path71) => result.replaceAll(path71, "[\u672C\u673A\u56FE\u7247\u8DEF\u5F84\u5DF2\u9690\u85CF]"),
     wrapper.fileList
   );
   const fileListEnd = wrapper.requestIndex === -1 ? text11.length : wrapper.requestIndex;
@@ -26453,8 +26479,8 @@ function normalizeUserFileMessageContent(value, resolveKnownLocalImage, itemId,
     }
     const localImagePaths = value.flatMap((part) => {
       const record26 = asRecord11(part);
-      const path70 = localImagePath(record26);
-      return path70 === null ? [] : [path70];
+      const path71 = localImagePath(record26);
+      return path71 === null ? [] : [path71];
     });
     const text11 = redactKnownCodexWrapperPaths(
       redactCodexImageWrapperPaths(firstPart2.text),
@@ -26488,9 +26514,9 @@ function normalizeUserFileMessageContent(value, resolveKnownLocalImage, itemId,
   const localImages = value.flatMap((part, index) => {
     const partIndex = originalPartIndices?.[index] ?? index;
     const record26 = asRecord11(part);
-    const path70 = localImagePath(record26);
-    return path70 === null ? [] : [{
-      path: path70,
+    const path71 = localImagePath(record26);
+    return path71 === null ? [] : [{
+      path: path71,
       partIndex,
       image: record26.type === "historyImage" ? historyImageContent(record26, itemId, partIndex) : null
     }];
@@ -26619,8 +26645,8 @@ function redactRawLocalImagePaths(rawItem) {
   let containsLocalImage = false;
   let containsRedactedWrapperPath = false;
   const localImagePaths = item.content.map((part) => asRecord11(part)).flatMap((part) => {
-    const path70 = localImagePath(part);
-    return path70 === null ? [] : [path70];
+    const path71 = localImagePath(part);
+    return path71 === null ? [] : [path71];
   });
   const content2 = item.content.map((part) => {
     const record26 = asRecord11(part);
@@ -27588,8 +27614,8 @@ var init_events = __esm({
         const patches = Array.isArray(change.patches) ? change.patches : [];
         for (const patch of patches) {
           const candidate = objectRecord6(patch);
-          const path70 = Array.isArray(candidate.path) ? candidate.path : [];
-          if ((candidate.op === "add" || candidate.op === "replace") && path70.length === 1 && path70[0] === "threadRuntimeStatus") {
+          const path71 = Array.isArray(candidate.path) ? candidate.path : [];
+          if ((candidate.op === "add" || candidate.op === "replace") && path71.length === 1 && path71[0] === "threadRuntimeStatus") {
             runtimeStatusValue = candidate.value;
           }
         }
@@ -29592,13 +29618,13 @@ var init_upload_task_store = __esm({
 import { execFile as execFile9 } from "node:child_process";
 import { constants as constants2 } from "node:fs";
 import { lstat, open } from "node:fs/promises";
-import path39 from "node:path";
+import path40 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) : path39.resolve(file);
+    return windows() ? localWindowsPath(file) : path40.resolve(file);
   } catch {
     throw unavailable2();
   }
@@ -29641,7 +29667,7 @@ async function windowsMode(file, seal = false) {
   return output;
 }
 async function parentIdentity(file) {
-  const directory3 = path39.dirname(file), initial = await lstat(directory3, { bigint: true });
+  const directory3 = path40.dirname(file), initial = await lstat(directory3, { bigint: true });
   if (!initial.isDirectory() || initial.isSymbolicLink()) throw unavailable2();
   if (windows()) {
     try {
@@ -29708,10 +29734,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 }), directory3 = await lstat(path39.dirname(file), { bigint: true });
+      const held = await h.stat({ bigint: true }), current2 = await lstat(file, { bigint: true }), directory3 = await lstat(path40.dirname(file), { bigint: true });
       if (!trusted2(held) || !trusted2(current2) || !same3(held, baseline) || !sameSnapshot(held, current2) || !same3(parent, directory3) || !directory3.isDirectory() || directory3.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(path39.dirname(file));
+      if (!windows()) privateLogFiles.checkDirectory(path40.dirname(file));
     }
     await guard();
     checkExpected(await status(h), options);
@@ -29848,11 +29874,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(path39.dirname(file), { bigint: true }))) throw unavailable2();
+          if (!trusted2(held) || !sameSnapshot(held, current2) || !same3(parent, await lstat(path40.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(path39.dirname(file), { bigint: true }))) throw unavailable2();
+          if (!sameSnapshot(await handle.stat({ bigint: true }), await lstat(file, { bigint: true })) || !same3(parent, await lstat(path40.dirname(file), { bigint: true }))) throw unavailable2();
           await handle.close();
           handle = void 0;
           return result;
@@ -29952,7 +29978,7 @@ import { randomUUID as randomUUID23 } from "node:crypto";
 import { execFile as execFile11 } 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 path40 from "node:path";
+import path41 from "node:path";
 function nameOnly(name2) {
   if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/u.test(name2)) throw unavailable3();
 }
@@ -29961,7 +29987,7 @@ function budget(maxBytes) {
 }
 async function openDirectories(requested, windowsCandidate) {
   const windows2 = process.platform === "win32";
-  const root = windows2 ? localWindowsPath(requested) : path40.resolve(requested);
+  const root = windows2 ? localWindowsPath(requested) : path41.resolve(requested);
   let rootIdentity;
   try {
     if (windows2) await ensureWindowsPrivateDirectoryAsync(root);
@@ -30006,7 +30032,7 @@ async function openDirectories(requested, windowsCandidate) {
   }
   function token3(value) {
     const directory3 = Object.freeze({ get sourcePath() {
-      return path40.join(value.path, "source");
+      return path41.join(value.path, "source");
     } });
     records2.set(directory3, value);
     return directory3;
@@ -30062,7 +30088,7 @@ async function openDirectories(requested, windowsCandidate) {
       return serial(async () => {
         nameOnly(name2);
         await guard();
-        const directory3 = path40.join(root, name2);
+        const directory3 = path41.join(root, name2);
         if (!windows2) privateLogFiles.checkDirectory(directory3);
         const identity6 = await lstat3(directory3, { bigint: true });
         const result = token3({ name: name2, path: directory3, identity: identity6, staged: false, pending: true, ready: true });
@@ -30075,7 +30101,7 @@ async function openDirectories(requested, windowsCandidate) {
         mutable();
         nameOnly(name2);
         await guard();
-        const directory3 = path40.join(root, ".pending-" + name2);
+        const directory3 = path41.join(root, ".pending-" + name2);
         await mkdir(directory3, { mode: 448 });
         const identity6 = await lstat3(directory3, { bigint: true });
         if (windows2) {
@@ -30105,7 +30131,7 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
       return serial(async () => {
         budget(maxBytes);
         await guard(directory3);
-        const handle = await privateBinaryFiles.open(path40.join(record26(directory3).path, "manifest.json"), { maxBytes, mode: "mutable" });
+        const handle = await privateBinaryFiles.open(path41.join(record26(directory3).path, "manifest.json"), { maxBytes, mode: "mutable" });
         let failed = false;
         const bytes3 = Buffer.alloc(maxBytes);
         try {
@@ -30154,7 +30180,7 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
         async function currentManifest() {
           let stats;
           try {
-            stats = await lstat3(path40.join(value.path, "manifest.json"), { bigint: true });
+            stats = await lstat3(path41.join(value.path, "manifest.json"), { bigint: true });
           } catch (error2) {
             if (error2.code === "ENOENT") return null;
             throw error2;
@@ -30162,7 +30188,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(path40.join(value.path, "manifest.json"), {
+            const handle = await privateBinaryFiles.open(path41.join(value.path, "manifest.json"), {
               maxBytes,
               mode: "mutable",
               match: "object",
@@ -30179,13 +30205,13 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
             } finally {
               await handle.close();
             }
-            const after = await lstat3(path40.join(value.path, "manifest.json"), { bigint: true });
+            const after = await lstat3(path41.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 = path40.join(value.path, ".manifest-" + randomUUID23());
+        const temporary = path41.join(value.path, ".manifest-" + randomUUID23());
         let created = false, published = false, identity6;
         try {
           if (windows2) {
@@ -30240,7 +30266,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, path40.join(value.path, "manifest.json"));
+          await rename(temporary, path41.join(value.path, "manifest.json"));
           published = true;
           created = false;
           value.pending = true;
@@ -30277,7 +30303,7 @@ Check-PrivateDirectory $env:NIUMA_UPLOAD_ENTRY
         const value = record26(directory3);
         if (!value.staged || !value.ready) throw unavailable3();
         await finish(directory3);
-        const target = path40.join(root, value.name);
+        const target = path41.join(root, value.name);
         try {
           await lstat3(target);
           throw unavailable3();
@@ -30662,7 +30688,7 @@ var init_legacy_upload_contents = __esm({
 
 // apps/desktop/src/daemon/runtime/attachment-access.ts
 import { createHash as createHash16 } from "node:crypto";
-import path41 from "node:path";
+import path42 from "node:path";
 import process2 from "node:process";
 var RuntimeAttachmentAccess;
 var init_attachment_access = __esm({
@@ -30700,7 +30726,7 @@ var init_attachment_access = __esm({
         const cached = createCachedUploadTaskStore({
           base,
           cache: () => cache2 ??= (async () => {
-            const root = path41.join(this.ports.options().niumaDataDirectory ?? desktopPlatform().directories.data, "attachments", "device-cache");
+            const root = path42.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)
@@ -30844,8 +30870,8 @@ var init_attachment_access = __esm({
 });
 
 // apps/desktop/src/niuma/project-state.ts
-import fs30 from "node:fs/promises";
-import path42 from "node:path";
+import fs31 from "node:fs/promises";
+import path43 from "node:path";
 import { z as z10 } from "zod";
 function emptyProjectState() {
   return {
@@ -30914,9 +30940,9 @@ function isMissingFileError(error2) {
   return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
 }
 async function readProjectState(codexHome) {
-  const statePath = path42.join(codexHome, ".codex-global-state.json");
+  const statePath = path43.join(codexHome, ".codex-global-state.json");
   try {
-    const raw = await fs30.readFile(statePath, "utf8");
+    const raw = await fs31.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]));
@@ -31009,7 +31035,7 @@ var init_project_state = __esm({
 });
 
 // apps/desktop/src/niuma/session-originator.ts
-import fs31 from "node:fs/promises";
+import fs32 from "node:fs/promises";
 function record9(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -31026,7 +31052,7 @@ async function readFirstLine(filePath) {
   let byteCount = 0;
   let position = 0;
   try {
-    handle = await fs31.open(filePath, "r");
+    handle = await fs32.open(filePath, "r");
     while (true) {
       const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
       const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
@@ -31122,7 +31148,7 @@ var init_session_originator = __esm({
 });
 
 // apps/desktop/src/niuma/session-timestamps.ts
-import fs32 from "node:fs/promises";
+import fs33 from "node:fs/promises";
 import { createInterface as createInterface4 } from "node:readline";
 function record10(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -31408,7 +31434,7 @@ var init_session_timestamps = __esm({
         try {
           const sessionPath = explicitPath === void 0 ? await this.resolveSessionPath(threadId2) : explicitPath;
           if (!sessionPath || this.closed) return "unavailable";
-          const stat4 = await fs32.stat(sessionPath);
+          const stat4 = await fs33.stat(sessionPath);
           if (this.closed) return "unavailable";
           return JSON.stringify([stat4.dev, stat4.ino, stat4.size, stat4.mtimeMs, stat4.ctimeMs]);
         } catch {
@@ -31581,7 +31607,7 @@ var init_session_timestamps = __esm({
         }
       }
       async readReplay(sessionPath, threadId2, fingerprint2, empty) {
-        const handle = await fs32.open(sessionPath, "r");
+        const handle = await fs33.open(sessionPath, "r");
         if (this.closed) {
           await handle.close();
           return empty;
@@ -32176,7 +32202,7 @@ var init_app_server_upgrade = __esm({
 
 // apps/desktop/src/daemon/codex-subagent-avatars.ts
 import { open as open3 } from "node:fs/promises";
-import path43 from "node:path";
+import path44 from "node:path";
 import sharp from "sharp";
 function record11(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -32217,7 +32243,7 @@ async function parseCatalog(source2, readAsset) {
   }
   return new CodexSubagentAvatars(images);
 }
-async function loadCodexSubagentAvatars(archivePath = path43.join(path43.dirname(resolveDefaultAppServerExecutablePath()), "app.asar")) {
+async function loadCodexSubagentAvatars(archivePath = path44.join(path44.dirname(resolveDefaultAppServerExecutablePath()), "app.asar")) {
   let file;
   try {
     file = await open3(archivePath, "r");
@@ -32284,8 +32310,8 @@ var init_codex_subagent_avatars = __esm({
 });
 
 // apps/desktop/src/platform/private-document-files.ts
-import fs33 from "node:fs";
-import path44 from "node:path";
+import fs34 from "node:fs";
+import path45 from "node:path";
 import { randomUUID as randomUUID25 } from "node:crypto";
 function checkLimit(maxBytes) {
   if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 32 * 1024 * 1024) throw new PrivateDocumentFileError("capacity");
@@ -32297,7 +32323,7 @@ function trusted3(stats, directory3 = false, strictDirectory = false) {
 }
 function statFile(file, maxBytes) {
   try {
-    const stats = fs33.lstatSync(file, { bigint: true });
+    const stats = fs34.lstatSync(file, { bigint: true });
     if (!trusted3(stats)) throw new PrivateDocumentFileError("unavailable");
     if (stats.size > BigInt(maxBytes)) throw new PrivateDocumentFileError("capacity");
     return stats;
@@ -32317,33 +32343,33 @@ function readPosix(file, maxBytes, strictDirectory) {
   let directoryFd;
   let fd;
   try {
-    const directory3 = path44.dirname(file);
+    const directory3 = path45.dirname(file);
     let parent;
     try {
-      parent = fs33.lstatSync(directory3, { bigint: true });
+      parent = fs34.lstatSync(directory3, { bigint: true });
     } catch (error2) {
       if (missing(error2)) return null;
       throw error2;
     }
     if (!trusted3(parent, true, strictDirectory)) throw new PrivateDocumentFileError("unavailable");
-    directoryFd = fs33.openSync(directory3, fs33.constants.O_RDONLY | fs33.constants.O_NOFOLLOW);
-    if (!same5(parent, fs33.fstatSync(directoryFd, { bigint: true }))) throw new PrivateDocumentFileError("unavailable");
+    directoryFd = fs34.openSync(directory3, fs34.constants.O_RDONLY | fs34.constants.O_NOFOLLOW);
+    if (!same5(parent, fs34.fstatSync(directoryFd, { bigint: true }))) throw new PrivateDocumentFileError("unavailable");
     const original = statFile(file, maxBytes);
     if (original === null) return null;
-    fd = fs33.openSync(file, fs33.constants.O_RDONLY | fs33.constants.O_NOFOLLOW);
-    const opened = fs33.fstatSync(fd, { bigint: true });
+    fd = fs34.openSync(file, fs34.constants.O_RDONLY | fs34.constants.O_NOFOLLOW);
+    const opened = fs34.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 = fs33.readSync(fd, contents, length, contents.length - length, null);
+        const count = fs34.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, fs33.lstatSync(directory3, { bigint: true }))) {
+      if (current2 === null || !same5(original, current2) || !same5(parent, fs34.lstatSync(directory3, { bigint: true }))) {
         throw new PrivateDocumentFileError("unavailable");
       }
       return decode(contents.subarray(0, length));
@@ -32352,42 +32378,42 @@ function readPosix(file, maxBytes, strictDirectory) {
     }
   } finally {
     try {
-      if (fd !== void 0) fs33.closeSync(fd);
+      if (fd !== void 0) fs34.closeSync(fd);
     } finally {
-      if (directoryFd !== void 0) fs33.closeSync(directoryFd);
+      if (directoryFd !== void 0) fs34.closeSync(directoryFd);
     }
   }
 }
 function writePosix(file, body, maxBytes, strictDirectory) {
-  const directory3 = path44.dirname(file);
-  const temporary = path44.join(directory3, `.${path44.basename(file)}.${randomUUID25()}.tmp`);
+  const directory3 = path45.dirname(file);
+  const temporary = path45.join(directory3, `.${path45.basename(file)}.${randomUUID25()}.tmp`);
   let directoryFd;
   let fd;
   let created = false;
   let renamed = false;
   try {
-    fs33.mkdirSync(directory3, { recursive: true, mode: 448 });
-    const parent = fs33.lstatSync(directory3, { bigint: true });
+    fs34.mkdirSync(directory3, { recursive: true, mode: 448 });
+    const parent = fs34.lstatSync(directory3, { bigint: true });
     if (!trusted3(parent, true, strictDirectory)) throw new PrivateDocumentFileError("unavailable");
-    directoryFd = fs33.openSync(directory3, fs33.constants.O_RDONLY | fs33.constants.O_NOFOLLOW);
-    if (!same5(parent, fs33.fstatSync(directoryFd, { bigint: true }))) throw new PrivateDocumentFileError("unavailable");
+    directoryFd = fs34.openSync(directory3, fs34.constants.O_RDONLY | fs34.constants.O_NOFOLLOW);
+    if (!same5(parent, fs34.fstatSync(directoryFd, { bigint: true }))) throw new PrivateDocumentFileError("unavailable");
     const original = statFile(file, maxBytes);
-    fd = fs33.openSync(temporary, fs33.constants.O_WRONLY | fs33.constants.O_CREAT | fs33.constants.O_EXCL | fs33.constants.O_NOFOLLOW, 384);
+    fd = fs34.openSync(temporary, fs34.constants.O_WRONLY | fs34.constants.O_CREAT | fs34.constants.O_EXCL | fs34.constants.O_NOFOLLOW, 384);
     created = true;
-    const temporaryIdentity = fs33.fstatSync(fd, { bigint: true });
+    const temporaryIdentity = fs34.fstatSync(fd, { bigint: true });
     if (!trusted3(temporaryIdentity)) throw new PrivateDocumentFileError("unavailable");
-    fs33.writeFileSync(fd, body);
-    fs33.fsyncSync(fd);
-    fs33.closeSync(fd);
+    fs34.writeFileSync(fd, body);
+    fs34.fsyncSync(fd);
+    fs34.closeSync(fd);
     fd = void 0;
     const current2 = statFile(file, maxBytes);
-    if (!same5(parent, fs33.lstatSync(directory3, { bigint: true })) || !same5(temporaryIdentity, fs33.lstatSync(temporary, { bigint: true })) || (original === null ? current2 !== null : current2 === null || !same5(original, current2))) {
+    if (!same5(parent, fs34.lstatSync(directory3, { bigint: true })) || !same5(temporaryIdentity, fs34.lstatSync(temporary, { bigint: true })) || (original === null ? current2 !== null : current2 === null || !same5(original, current2))) {
       throw new PrivateDocumentFileError("unavailable");
     }
-    fs33.renameSync(temporary, file);
+    fs34.renameSync(temporary, file);
     renamed = true;
     created = false;
-    fs33.fsyncSync(directoryFd);
+    fs34.fsyncSync(directoryFd);
   } catch (error2) {
     if (error2 instanceof PrivateDocumentFileError && !renamed) throw error2;
     throw new PrivateDocumentFileError("write_failed", renamed);
@@ -32395,7 +32421,7 @@ function writePosix(file, body, maxBytes, strictDirectory) {
     try {
       if (fd !== void 0) {
         try {
-          fs33.closeSync(fd);
+          fs34.closeSync(fd);
         } catch {
         }
       }
@@ -32403,14 +32429,14 @@ function writePosix(file, body, maxBytes, strictDirectory) {
       try {
         if (directoryFd !== void 0) {
           try {
-            fs33.closeSync(directoryFd);
+            fs34.closeSync(directoryFd);
           } catch {
           }
         }
       } finally {
         if (created) {
           try {
-            fs33.unlinkSync(temporary);
+            fs34.unlinkSync(temporary);
           } catch {
           }
         }
@@ -32444,7 +32470,7 @@ async function windowsDocument(file, maxBytes, body) {
   return result;
 }
 function serialFile(file, operation) {
-  const absolute = path44.resolve(file);
+  const absolute = path45.resolve(file);
   const key = desktopPlatform().id === "windows" ? absolute.toLowerCase() : absolute;
   const result = (operations.get(key) ?? Promise.resolve()).then(operation);
   const tail = result.then(() => {
@@ -32462,7 +32488,7 @@ function documentFiles(strictDirectory, guard) {
       return serialFile(file, async () => {
         try {
           guard?.();
-          const body = desktopPlatform().id === "windows" ? await windowsDocument(file, maxBytes) : readPosix(path44.resolve(file), maxBytes, strictDirectory);
+          const body = desktopPlatform().id === "windows" ? await windowsDocument(file, maxBytes) : readPosix(path45.resolve(file), maxBytes, strictDirectory);
           guard?.();
           return body;
         } catch (error2) {
@@ -32477,7 +32503,7 @@ function documentFiles(strictDirectory, guard) {
       await serialFile(file, async () => {
         guard?.();
         if (desktopPlatform().id === "windows") await windowsDocument(file, maxBytes, body);
-        else writePosix(path44.resolve(file), body, maxBytes, strictDirectory);
+        else writePosix(path45.resolve(file), body, maxBytes, strictDirectory);
         try {
           guard?.();
         } catch {
@@ -32516,7 +32542,7 @@ var init_private_document_files = __esm({
 });
 
 // apps/desktop/src/local-state/paths.ts
-import path45 from "node:path";
+import path46 from "node:path";
 function applicationStateDirectory() {
   return desktopPlatform().directories.state;
 }
@@ -32524,37 +32550,37 @@ function cliCacheDirectory() {
   return desktopPlatform().directories.cliCache;
 }
 function managedThreadsStatePath() {
-  return path45.join(applicationStateDirectory(), "managed-threads-v1.json");
+  return path46.join(applicationStateDirectory(), "managed-threads-v1.json");
 }
 function threadSettingsStatePath() {
-  return path45.join(applicationStateDirectory(), "thread-settings-cache-v1.json");
+  return path46.join(applicationStateDirectory(), "thread-settings-cache-v1.json");
 }
 function threadListStatePath() {
-  return path45.join(applicationStateDirectory(), "thread-list-cache-v1.json");
+  return path46.join(applicationStateDirectory(), "thread-list-cache-v1.json");
 }
 function daemonMetricsStatePath() {
-  return path45.join(applicationStateDirectory(), "daemon-metrics-v1.json");
+  return path46.join(applicationStateDirectory(), "daemon-metrics-v1.json");
 }
 function desktopIdentityCandidatesStatePath() {
-  return path45.join(applicationStateDirectory(), "desktop-identity-candidates-v1.json");
+  return path46.join(applicationStateDirectory(), "desktop-identity-candidates-v1.json");
 }
 function pendingRequestsCachePath() {
-  return path45.join(cliCacheDirectory(), "pending-requests-v1.json");
+  return path46.join(cliCacheDirectory(), "pending-requests-v1.json");
 }
 function idempotencyCachePath() {
-  return path45.join(cliCacheDirectory(), "idempotency-v1.json");
+  return path46.join(cliCacheDirectory(), "idempotency-v1.json");
 }
 function messageSubmissionsStatePath() {
-  return path45.join(applicationStateDirectory(), "message-submissions-v1.json");
+  return path46.join(applicationStateDirectory(), "message-submissions-v1.json");
 }
 function deviceNameStatePath() {
-  return path45.join(applicationStateDirectory(), "device-name-v1.json");
+  return path46.join(applicationStateDirectory(), "device-name-v1.json");
 }
 function threadReadReceiptsStatePath() {
-  return path45.join(applicationStateDirectory(), "thread-read-receipts-v1.json");
+  return path46.join(applicationStateDirectory(), "thread-read-receipts-v1.json");
 }
 function asyncQuestionFactsStatePath() {
-  return path45.join(applicationStateDirectory(), "async-question-facts", "ledger-v1.json");
+  return path46.join(applicationStateDirectory(), "async-question-facts", "ledger-v1.json");
 }
 var init_paths2 = __esm({
   "apps/desktop/src/local-state/paths.ts"() {
@@ -34160,7 +34186,7 @@ var init_thread_timeline_cache = __esm({
 });
 
 // apps/desktop/src/daemon/thread-state-store.ts
-import path46 from "node:path";
+import path47 from "node:path";
 function projectRecency(entry) {
   return entry.threads.reduce(
     (latest, thread4) => Math.max(latest, thread4.recencyAt ?? thread4.updatedAt),
@@ -34269,8 +34295,8 @@ function normalizePathForCompare(value) {
   if (!value) {
     return "";
   }
-  const normalized = path46.normalize(value);
-  if (normalized.length > 1 && normalized.endsWith(path46.sep)) {
+  const normalized = path47.normalize(value);
+  if (normalized.length > 1 && normalized.endsWith(path47.sep)) {
     return normalized.slice(0, -1);
   }
   return normalized;
@@ -34295,7 +34321,7 @@ function isPathWithinRoot(cwd, root) {
   if (normalizedCwd === normalizedRoot) {
     return true;
   }
-  return normalizedCwd.startsWith(`${normalizedRoot}${path46.sep}`);
+  return normalizedCwd.startsWith(`${normalizedRoot}${path47.sep}`);
 }
 function findLongestMatchingRoot(cwd, roots) {
   let matched = null;
@@ -34318,7 +34344,7 @@ function labelForRoot(root, labels) {
     };
   }
   return {
-    projectName: path46.basename(root) || root,
+    projectName: path47.basename(root) || root,
     projectNameSource: "basename"
   };
 }
@@ -35826,10 +35852,10 @@ var init_bootstrap = __esm({
 });
 
 // apps/desktop/src/platform/private-cache-files.ts
-import fs34 from "node:fs";
-import path47 from "node:path";
+import fs35 from "node:fs";
+import path48 from "node:path";
 function serialize(file, operation) {
-  const key = process.platform === "win32" ? path47.resolve(file).toLowerCase() : path47.resolve(file);
+  const key = process.platform === "win32" ? path48.resolve(file).toLowerCase() : path48.resolve(file);
   const next = (tails.get(key) ?? Promise.resolve()).then(operation);
   const tail = next.catch(() => {
   });
@@ -35844,23 +35870,23 @@ function trusted4(stat4, directory3 = false) {
   return uid !== void 0 && stat4.uid === BigInt(uid) && (directory3 ? stat4.isDirectory() && (stat4.mode & 0o777n) === 0o700n : stat4.isFile() && stat4.nlink === 1n && (stat4.mode & 0o777n) === 0o600n);
 }
 async function withMacLock(file, operation) {
-  const directory3 = path47.dirname(file);
-  const lock = path47.join(directory3, `.${path47.basename(file)}.lock`);
-  fs34.mkdirSync(directory3, { recursive: true, mode: 448 });
-  const parent = fs34.lstatSync(directory3, { bigint: true });
+  const directory3 = path48.dirname(file);
+  const lock = path48.join(directory3, `.${path48.basename(file)}.lock`);
+  fs35.mkdirSync(directory3, { recursive: true, mode: 448 });
+  const parent = fs35.lstatSync(directory3, { 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 = fs34.lstatSync(lock, { bigint: true });
+      initial = fs35.lstatSync(lock, { bigint: true });
     } catch (error2) {
       if (error2.code !== "ENOENT") throw error2;
     }
     if (initial && !trusted4(initial)) throw new PrivateDocumentFileError("unavailable");
     try {
-      fd = fs34.openSync(lock, fs34.constants.O_RDWR | fs34.constants.O_CREAT | fs34.constants.O_NOFOLLOW | fs34.constants.O_NONBLOCK | 32, 384);
+      fd = fs35.openSync(lock, fs35.constants.O_RDWR | fs35.constants.O_CREAT | fs35.constants.O_NOFOLLOW | fs35.constants.O_NONBLOCK | 32, 384);
     } catch (error2) {
       const code = error2.code;
       if (code !== "EAGAIN" && code !== "EWOULDBLOCK" || Date.now() >= deadline) throw error2;
@@ -35868,10 +35894,10 @@ async function withMacLock(file, operation) {
       continue;
     }
     try {
-      const opened = fs34.fstatSync(fd, { bigint: true });
+      const opened = fs35.fstatSync(fd, { bigint: true });
       const verify = () => {
-        const current2 = fs34.lstatSync(lock, { bigint: true });
-        const currentParent = fs34.lstatSync(directory3, { bigint: true });
+        const current2 = fs35.lstatSync(lock, { bigint: true });
+        const currentParent = fs35.lstatSync(directory3, { 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");
         }
@@ -35881,7 +35907,7 @@ async function withMacLock(file, operation) {
       verify();
       return value;
     } finally {
-      fs34.closeSync(fd);
+      fs35.closeSync(fd);
     }
   }
 }
@@ -35912,7 +35938,7 @@ var init_private_cache_files = __esm({
         return serialize(file, async () => {
           checkLimit2(maxBytes);
           try {
-            fs34.lstatSync(file);
+            fs35.lstatSync(file);
           } catch (error2) {
             if (error2.code === "ENOENT") return null;
             throw error2;
@@ -35925,7 +35951,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(path47.resolve(file), async (verify) => {
+          return withMacLock(path48.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);
@@ -36209,7 +36235,7 @@ var init_pending_cache = __esm({
 });
 
 // apps/desktop/src/niuma/session-pending.ts
-import fs35 from "node:fs";
+import fs36 from "node:fs";
 function objectRecord7(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -36232,7 +36258,7 @@ function inferPendingRequestFromSession(threadId2, sessionPath, latestTurnId = n
   }
   let lines;
   try {
-    lines = fs35.readFileSync(sessionPath, "utf8").trimEnd().split(/\n/).filter(Boolean);
+    lines = fs36.readFileSync(sessionPath, "utf8").trimEnd().split(/\n/).filter(Boolean);
   } catch {
     return null;
   }
@@ -37044,7 +37070,7 @@ var init_settings = __esm({
 
 // apps/desktop/src/direct-gateway/v5-binding-store.ts
 import { randomUUID as randomUUID26, createHash as createHash17 } from "node:crypto";
-import path48 from "node:path";
+import path49 from "node:path";
 function bindingFileError() {
   return new Error("Desktop V5 Binding \u6587\u4EF6\u65E0\u6548");
 }
@@ -37178,7 +37204,7 @@ function parseResetMarker(value, desktopId) {
   }
 }
 function resolveDefaultDesktopV5BindingFilePath() {
-  return path48.join(desktopPlatform().directories.data, DEFAULT_FILE_NAME);
+  return path49.join(desktopPlatform().directories.data, DEFAULT_FILE_NAME);
 }
 function pushDisplayName(name2) {
   let result = "";
@@ -37245,7 +37271,7 @@ var init_v5_binding_store = __esm({
         for (const wake of this.pushWaiters) wake();
       }
       constructor(options = {}) {
-        this.filePath = path48.resolve(options.file_path ?? resolveDefaultDesktopV5BindingFilePath());
+        this.filePath = path49.resolve(options.file_path ?? resolveDefaultDesktopV5BindingFilePath());
         this.files = options.files ?? privateDocumentFiles;
       }
       async load(desktopId) {
@@ -37495,7 +37521,7 @@ var init_v5_binding_store = __esm({
         await this.writeAtomicFile(this.resetMarkerPath(), serializeResetMarker(desktopId), bindingFileError);
       }
       resetMarkerPath() {
-        return path48.join(path48.dirname(this.filePath), RESET_MARKER_FILE_NAME);
+        return path49.join(path49.dirname(this.filePath), RESET_MARKER_FILE_NAME);
       }
       async writeAtomicFile(targetPath2, body, failure) {
         try {
@@ -42700,7 +42726,7 @@ var init_candidate_catalog2 = __esm({
 });
 
 // apps/desktop/src/direct-gateway/identity-store.ts
-import path49 from "node:path";
+import path50 from "node:path";
 function copyIdentity(identity6) {
   return {
     desktop_id: identity6.desktop_id,
@@ -42755,7 +42781,7 @@ function deserializeIdentity(value) {
   }
 }
 function resolveDefaultDesktopIdentityFilePath() {
-  return path49.join(desktopPlatform().directories.data, DEFAULT_IDENTITY_FILE_NAME);
+  return path50.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({
@@ -42771,7 +42797,7 @@ var init_identity_store = __esm({
       filePath;
       files;
       constructor(options = {}) {
-        this.filePath = path49.resolve(options.file_path ?? resolveDefaultDesktopIdentityFilePath());
+        this.filePath = path50.resolve(options.file_path ?? resolveDefaultDesktopIdentityFilePath());
         this.files = options.files ?? privateDocumentFiles;
       }
       async load() {
@@ -46184,7 +46210,7 @@ var init_routes3 = __esm({
 
 // apps/desktop/src/pairing-web/server.ts
 import http3 from "node:http";
-import fs36 from "node:fs/promises";
+import fs37 from "node:fs/promises";
 var ASSETS, PairingWebServer;
 var init_server3 = __esm({
   "apps/desktop/src/pairing-web/server.ts"() {
@@ -46268,7 +46294,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 fs36.readFile(desktopAssetUrl("pairing-web", asset[0]));
+          const body = await fs37.readFile(desktopAssetUrl("pairing-web", asset[0]));
           response.writeHead(200, { "Content-Type": asset[1] });
           response.end(body);
         } catch (error2) {
@@ -48052,21 +48078,21 @@ var init_desktop_timeline_events = __esm({
           if (patch.op !== "add" && patch.op !== "replace") {
             continue;
           }
-          const path70 = array2(patch.path);
-          if (path70.length === 4 && path70[0] === "turnHistory" && path70[1] === "history" && path70[2] === "entitiesByKey" && typeof path70[3] === "string") {
+          const path71 = array2(patch.path);
+          if (path71.length === 4 && path71[0] === "turnHistory" && path71[1] === "history" && path71[2] === "entitiesByKey" && typeof path71[3] === "string") {
             const turnId = turnIdFromEntity(record14(patch.value));
             if (turnId) {
-              this.entityTurnIds.set(this.entityKey(threadId2, path70[3]), turnId);
+              this.entityTurnIds.set(this.entityKey(threadId2, path71[3]), turnId);
             }
             continue;
           }
-          if (path70.length !== 6 || path70[0] !== "turnHistory" || path70[1] !== "history" || path70[2] !== "entitiesByKey" || typeof path70[3] !== "string" || path70[4] !== "items" || typeof path70[5] !== "number") {
+          if (path71.length !== 6 || path71[0] !== "turnHistory" || path71[1] !== "history" || path71[2] !== "entitiesByKey" || typeof path71[3] !== "string" || path71[4] !== "items" || typeof path71[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, path70[3])) ?? null,
+            turnId: this.entityTurnIds.get(this.entityKey(threadId2, path71[3])) ?? null,
             source: "desktop_ipc",
             occurredAt: occurredAt4,
             resolveKnownLocalImage
@@ -48112,8 +48138,8 @@ function assignKnownUnreadFields(target, value) {
     target.unreadMessageCount = value.unreadMessageCount;
   }
 }
-function isUnreadFieldPath(path70, field2) {
-  return path70.length === 1 && path70[0] === field2 || path70.length === 2 && path70[0] === "conversationState" && path70[1] === field2;
+function isUnreadFieldPath(path71, field2) {
+  return path71.length === 1 && path71[0] === field2 || path71.length === 2 && path71[0] === "conversationState" && path71[1] === field2;
 }
 function hasUpdateFields(update) {
   return "hasUnreadTurn" in update || "unreadMessageCount" in update;
@@ -48139,19 +48165,19 @@ function extractDesktopUnreadUpdate(frame) {
   }
   for (const patchValue of change.patches) {
     const patch = record15(patchValue);
-    const path70 = Array.isArray(patch.path) ? patch.path : [];
+    const path71 = Array.isArray(patch.path) ? patch.path : [];
     const op = patch.op;
     if (op !== "add" && op !== "replace" && op !== "remove") {
       continue;
     }
-    if (isUnreadFieldPath(path70, "hasUnreadTurn")) {
+    if (isUnreadFieldPath(path71, "hasUnreadTurn")) {
       if (op === "remove") {
         update.hasUnreadTurn = null;
       } else if (typeof patch.value === "boolean") {
         update.hasUnreadTurn = patch.value;
       }
     }
-    if (isUnreadFieldPath(path70, "unreadMessageCount")) {
+    if (isUnreadFieldPath(path71, "unreadMessageCount")) {
       if (op === "remove") {
         update.unreadMessageCount = null;
       } else if (isMessageCount(patch.value)) {
@@ -48848,15 +48874,15 @@ function revisionOf(value) {
 function occurredAt() {
   return Math.floor(Date.now() / 1e3);
 }
-function itemTarget(path70) {
-  const index = path70[5];
-  if (path70[0] !== "turnHistory" || path70[1] !== "history" || path70[2] !== "entitiesByKey" || typeof path70[3] !== "string" || path70[4] !== "items" || typeof index !== "number" || !Number.isInteger(index) || index < 0) {
+function itemTarget(path71) {
+  const index = path71[5];
+  if (path71[0] !== "turnHistory" || path71[1] !== "history" || path71[2] !== "entitiesByKey" || typeof path71[3] !== "string" || path71[4] !== "items" || typeof index !== "number" || !Number.isInteger(index) || index < 0) {
     return null;
   }
-  return { entityKey: path70[3], index, itemPathLength: 6 };
+  return { entityKey: path71[3], index, itemPathLength: 6 };
 }
-function entityTarget(path70) {
-  return path70[0] === "turnHistory" && path70[1] === "history" && path70[2] === "entitiesByKey" && typeof path70[3] === "string" ? path70[3] : null;
+function entityTarget(path71) {
+  return path71[0] === "turnHistory" && path71[1] === "history" && path71[2] === "entitiesByKey" && typeof path71[3] === "string" ? path71[3] : null;
 }
 function phaseOf(status2) {
   if (status2 === "failed" || status2 === "error") {
@@ -49142,15 +49168,15 @@ var init_desktop_activity_events = __esm({
           if (patch.op !== "add" && patch.op !== "replace") {
             continue;
           }
-          const path70 = array3(patch.path);
-          const targetItem = itemTarget(path70);
+          const path71 = array3(patch.path);
+          const targetItem = itemTarget(path71);
           if (targetItem) {
-            signals.push(...this.consumeItemPatch(threadId2, state, targetItem, path70, patch.value, patch.op));
+            signals.push(...this.consumeItemPatch(threadId2, state, targetItem, path71, patch.value, patch.op));
             continue;
           }
-          const targetEntity = entityTarget(path70);
+          const targetEntity = entityTarget(path71);
           if (targetEntity) {
-            signals.push(...this.consumeEntityPatch(threadId2, state, targetEntity, path70, patch.value));
+            signals.push(...this.consumeEntityPatch(threadId2, state, targetEntity, path71, patch.value));
           }
         }
         return signals;
@@ -49224,12 +49250,12 @@ var init_desktop_activity_events = __esm({
           occurredAt: occurredAt()
         }];
       }
-      consumeItemPatch(threadId2, state, target, path70, value, op) {
+      consumeItemPatch(threadId2, state, target, path71, value, op) {
         const entity = state.entities.get(target.entityKey);
         if (!entity || state.currentActiveEntityKey !== target.entityKey || state.currentActiveTurnId !== entity.turnId) {
           return [];
         }
-        if (path70.length === target.itemPathLength) {
+        if (path71.length === target.itemPathLength) {
           return this.prependLiveTurnStart(threadId2, entity, this.consumeWholeItem(
             threadId2,
             entity,
@@ -49239,13 +49265,13 @@ var init_desktop_activity_events = __esm({
           ));
         }
         const existing = entity.items.get(target.index);
-        if (!existing || path70.length < target.itemPathLength + 1) {
+        if (!existing || path71.length < target.itemPathLength + 1) {
           return [];
         }
-        const field2 = path70[target.itemPathLength];
+        const field2 = path71[target.itemPathLength];
         if (existing.type === "reasoning" && field2 === "summary") {
           const summary = structuredClone(existing.summary ?? []);
-          const suffix = path70.slice(target.itemPathLength + 1);
+          const suffix = path71.slice(target.itemPathLength + 1);
           if (suffix.length === 0) {
             existing.summary = structuredClone(Array.isArray(value) ? value : [value]);
           } else {
@@ -49345,9 +49371,9 @@ var init_desktop_activity_events = __esm({
         });
         return [this.activitySignal(threadId2, entity.turnId, itemId, mapping)];
       }
-      consumeEntityPatch(threadId2, state, entityKey, path70, value) {
-        const wholeEntity = path70.length === 4;
-        const statusField = path70.length === 5 && path70[4] === "status";
+      consumeEntityPatch(threadId2, state, entityKey, path71, value) {
+        const wholeEntity = path71.length === 4;
+        const statusField = path71.length === 5 && path71[4] === "status";
         if (!wholeEntity && !statusField) {
           return [];
         }
@@ -49527,20 +49553,20 @@ var init_desktop_error_events = __esm({
           if (patch.op !== "add" && patch.op !== "replace") {
             continue;
           }
-          const path70 = array4(patch.path);
-          if (path70.length === 4 && path70[0] === "turnHistory" && path70[1] === "history" && path70[2] === "entitiesByKey" && typeof path70[3] === "string") {
+          const path71 = array4(patch.path);
+          if (path71.length === 4 && path71[0] === "turnHistory" && path71[1] === "history" && path71[2] === "entitiesByKey" && typeof path71[3] === "string") {
             const entity = record17(patch.value);
             const turnId2 = turnIdFromEntity2(entity);
             if (turnId2) {
-              this.entityTurnIds.set(this.entityKey(threadId2, path70[3]), turnId2);
+              this.entityTurnIds.set(this.entityKey(threadId2, path71[3]), turnId2);
               events.push(...this.errorEvents(threadId2, array4(entity.items), turnId2));
             }
             continue;
           }
-          if (path70.length !== 6 || path70[0] !== "turnHistory" || path70[1] !== "history" || path70[2] !== "entitiesByKey" || typeof path70[3] !== "string" || path70[4] !== "items" || typeof path70[5] !== "number") {
+          if (path71.length !== 6 || path71[0] !== "turnHistory" || path71[1] !== "history" || path71[2] !== "entitiesByKey" || typeof path71[3] !== "string" || path71[4] !== "items" || typeof path71[5] !== "number") {
             continue;
           }
-          const turnId = this.entityTurnIds.get(this.entityKey(threadId2, path70[3]));
+          const turnId = this.entityTurnIds.get(this.entityKey(threadId2, path71[3]));
           if (!turnId) {
             continue;
           }
@@ -49633,13 +49659,13 @@ function visibleMessage(value, resolveKnownLocalImage) {
 function occurredAt2() {
   return Math.floor(Date.now() / 1e3);
 }
-function itemPath(path70) {
-  const index = path70.lastIndexOf("items");
-  const itemIndex = path70[index + 1];
-  return index >= 0 && typeof itemIndex === "number" && Number.isInteger(itemIndex) && itemIndex >= 0 && path70.length >= index + 2 ? path70.slice(0, index + 2) : null;
+function itemPath(path71) {
+  const index = path71.lastIndexOf("items");
+  const itemIndex = path71[index + 1];
+  return index >= 0 && typeof itemIndex === "number" && Number.isInteger(itemIndex) && itemIndex >= 0 && path71.length >= index + 2 ? path71.slice(0, index + 2) : null;
 }
-function stateKey(threadId2, path70) {
-  return `${threadId2}:${JSON.stringify(path70)}`;
+function stateKey(threadId2, path71) {
+  return `${threadId2}:${JSON.stringify(path71)}`;
 }
 function completedKey(threadId2, itemId) {
   return `${threadId2}:${itemId}`;
@@ -49697,35 +49723,35 @@ var init_desktop_stream_events = __esm({
           if (op !== "add" && op !== "replace" && op !== "remove") {
             continue;
           }
-          const path70 = array5(patch.path);
-          if (path70[0] === "turnHistory" && (path70.length === 1 || path70[1] === "history" && (path70.length === 2 || path70[2] === "entitiesByKey" && path70.length === 3))) {
+          const path71 = array5(patch.path);
+          if (path71[0] === "turnHistory" && (path71.length === 1 || path71[1] === "history" && (path71.length === 2 || path71[2] === "entitiesByKey" && path71.length === 3))) {
             this.resetThread(threadId2);
             continue;
           }
-          if (path70[0] === "turnHistory" && path70[1] === "history" && path70[2] === "entitiesByKey") {
-            const values = path70.length === 4 ? record18(patch.value).items : path70.length === 5 && path70[4] === "items" ? patch.value : void 0;
-            if (path70.length === 4 || path70.length === 5 && path70[4] === "items") {
-              const arrayPath = path70.slice(0, 4).concat("items");
+          if (path71[0] === "turnHistory" && path71[1] === "history" && path71[2] === "entitiesByKey") {
+            const values = path71.length === 4 ? record18(patch.value).items : path71.length === 5 && path71[4] === "items" ? patch.value : void 0;
+            if (path71.length === 4 || path71.length === 5 && path71[4] === "items") {
+              const arrayPath = path71.slice(0, 4).concat("items");
               this.replaceArrayStates(threadId2, arrayPath, array5(values), resolveKnownLocalImage);
               continue;
             }
           }
-          const rawIndex = path70.lastIndexOf("items") + 1;
-          if (op === "add" && path70[rawIndex] === "-" && path70.length === rawIndex + 1) {
-            const length = this.arrayLengths.get(stateKey(threadId2, path70.slice(0, rawIndex)));
+          const rawIndex = path71.lastIndexOf("items") + 1;
+          if (op === "add" && path71[rawIndex] === "-" && path71.length === rawIndex + 1) {
+            const length = this.arrayLengths.get(stateKey(threadId2, path71.slice(0, rawIndex)));
             if (length === void 0) continue;
-            path70[rawIndex] = length;
+            path71[rawIndex] = length;
           }
-          const targetItemPath = itemPath(path70);
+          const targetItemPath = itemPath(path71);
           if (!targetItemPath) {
             continue;
           }
           const key = stateKey(threadId2, targetItemPath);
-          if (path70.length > targetItemPath.length && ["id", "type"].includes(String(path70[targetItemPath.length]))) {
+          if (path71.length > targetItemPath.length && ["id", "type"].includes(String(path71[targetItemPath.length]))) {
             this.states.delete(key);
             continue;
           }
-          if (path70.length === targetItemPath.length) {
+          if (path71.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);
@@ -49740,7 +49766,7 @@ var init_desktop_stream_events = __esm({
             ));
             continue;
           }
-          if (op === "replace" && path70.length === targetItemPath.length + 1 && path70.at(-1) === "text") {
+          if (op === "replace" && path71.length === targetItemPath.length + 1 && path71.at(-1) === "text") {
             events.push(...this.consumeTextPatch(threadId2, key, patch.value, revision4));
           }
         }
@@ -49752,9 +49778,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 path70 = JSON.parse(key2.slice(threadId2.length + 1));
-          const at = path70.at(-1);
-          if (JSON.stringify(path70.slice(0, -1)) !== prefix || typeof at !== "number" || at < index) continue;
+          const path71 = JSON.parse(key2.slice(threadId2.length + 1));
+          const at = path71.at(-1);
+          if (JSON.stringify(path71.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]);
@@ -49765,20 +49791,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, path70, values, resolveKnownLocalImage) {
-        const prefix = JSON.stringify(path70);
+      replaceArrayStates(threadId2, path71, values, resolveKnownLocalImage) {
+        const prefix = JSON.stringify(path71);
         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, path70), values.length);
+        this.arrayLengths.set(stateKey(threadId2, path71), 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, [...path70, index]), { threadId: threadId2, ...message, lastText: message.text });
+            this.states.set(stateKey(threadId2, [...path71, index]), { threadId: threadId2, ...message, lastText: message.text });
           }
         });
       }
@@ -50903,8 +50929,8 @@ var init_socket_client = __esm({
         this.diagnosticProfile = diagnosticProfile;
         this.socketPaths = socketPath ? [socketPath] : defaultSocketPaths;
         const reader = new DesktopRuntimeVersionReader();
-        this.runtimeVersion = new RuntimeVersionCache(async (path70, signal) => {
-          const value = versionReader ? await versionReader(path70, signal) : await reader.read(path70, signal);
+        this.runtimeVersion = new RuntimeVersionCache(async (path71, signal) => {
+          const value = versionReader ? await versionReader(path71, signal) : await reader.read(path71, signal);
           return typeof value === "string" ? { version: value, build: null } : value;
         });
       }
@@ -53191,7 +53217,7 @@ var init_desktop_read_refresh_queue = __esm({
 import { watch } from "node:fs";
 import { open as open4, stat as statPath } from "node:fs/promises";
 import { createHash as createHash22 } from "node:crypto";
-import path50 from "node:path";
+import path51 from "node:path";
 function record20(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -53335,7 +53361,7 @@ var init_desktop_read_state_file = __esm({
       async readOnce() {
         this.checks++;
         try {
-          const filePath = path50.join(this.home, ".codex-global-state.json");
+          const filePath = path51.join(this.home, ".codex-global-state.json");
           const file = await open4(filePath, "r");
           let raw, signature;
           try {
@@ -55181,9 +55207,9 @@ var init_protocol = __esm({
 
 // apps/desktop/src/daemon/server.ts
 import { randomUUID as randomUUID37 } from "node:crypto";
-import fs37 from "node:fs";
+import fs38 from "node:fs";
 import net5 from "node:net";
-import path51 from "node:path";
+import path52 from "node:path";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 function createStatusFile(instanceId, mode, socketPath) {
   return {
@@ -55318,10 +55344,10 @@ var init_server4 = __esm({
     DaemonServer = class {
       constructor(options) {
         this.options = options;
-        this.socketPath = path51.resolve(options.socketPath ?? daemonSocketPath());
-        this.statusPath = path51.resolve(options.statusPath ?? daemonStatusPath());
+        this.socketPath = path52.resolve(options.socketPath ?? daemonSocketPath());
+        this.statusPath = path52.resolve(options.statusPath ?? daemonStatusPath());
         this.usesDefaultRuntimeDir = options.socketPath === void 0 || options.statusPath === void 0;
-        this.lifecycleLockPath = options.socketPath === void 0 ? daemonLifecycleLockPath() : path51.join(path51.dirname(this.socketPath), ".daemon-lifecycle.lock");
+        this.lifecycleLockPath = options.socketPath === void 0 ? daemonLifecycleLockPath() : path52.join(path52.dirname(this.socketPath), ".daemon-lifecycle.lock");
         this.transport = createDaemonTransport(this.socketPath);
         this.listenSocketPath = this.transport.listenPath;
       }
@@ -55433,22 +55459,22 @@ var init_server4 = __esm({
         const temporaryPath = `${this.statusPath}.${this.instanceId}.tmp`;
         let descriptor = null;
         try {
-          descriptor = fs37.openSync(temporaryPath, "wx", 384);
-          fs37.writeFileSync(
+          descriptor = fs38.openSync(temporaryPath, "wx", 384);
+          fs38.writeFileSync(
             descriptor,
             `${JSON.stringify(createStatusFile(this.instanceId, this.options.mode ?? "foreground", this.socketPath), null, 2)}
 `,
             "utf8"
           );
-          fs37.closeSync(descriptor);
+          fs38.closeSync(descriptor);
           descriptor = null;
-          fs37.chmodSync(temporaryPath, 384);
-          fs37.renameSync(temporaryPath, this.statusPath);
+          fs38.chmodSync(temporaryPath, 384);
+          fs38.renameSync(temporaryPath, this.statusPath);
         } catch (error2) {
           if (descriptor !== null) {
-            fs37.closeSync(descriptor);
+            fs38.closeSync(descriptor);
           }
-          fs37.rmSync(temporaryPath, { force: true });
+          fs38.rmSync(temporaryPath, { force: true });
           throw error2;
         }
       }
@@ -55473,9 +55499,9 @@ var init_server4 = __esm({
         this.transport.cleanup(this.socketPath);
         if (this.statusOwned) {
           try {
-            const status2 = JSON.parse(fs37.readFileSync(this.statusPath, "utf8"));
+            const status2 = JSON.parse(fs38.readFileSync(this.statusPath, "utf8"));
             if (status2.instanceId === this.instanceId) {
-              fs37.rmSync(this.statusPath, { force: true });
+              fs38.rmSync(this.statusPath, { force: true });
             }
           } catch {
           }
@@ -56069,7 +56095,7 @@ var init_push_trigger_projection = __esm({
 });
 
 // apps/desktop/src/daemon/turn-push-audit.ts
-import path52 from "node:path";
+import path53 from "node:path";
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -56116,7 +56142,7 @@ function isCoverageReason(value) {
   return value === "realtime_gap" || value === "historical_gap" || value === "source_unavailable" || value === "reader_limit" || value === "write_failed";
 }
 function auditDirectory(runtimeDir) {
-  return path52.join(runtimeDir, AUDIT_DIRECTORY);
+  return path53.join(runtimeDir, AUDIT_DIRECTORY);
 }
 function dateFileName(timestampMs) {
   if (!isFiniteTimestamp(timestampMs)) return null;
@@ -56219,7 +56245,7 @@ function appendRecord(runtimeDir, timestampMs, record26, files) {
     files.checkDirectory(runtimeDir);
     const directory3 = auditDirectory(runtimeDir);
     files.ensureDirectory(directory3);
-    files.append(path52.join(directory3, fileName), `${JSON.stringify(record26)}
+    files.append(path53.join(directory3, fileName), `${JSON.stringify(record26)}
 `, MAX_FILE_BYTES);
     return true;
   } catch {
@@ -57784,11 +57810,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(([path70, value2]) => {
+      item.changes = Array.isArray(raw.changes) ? structuredClone(raw.changes) : Object.entries(record5(raw.changes)).map(([path71, value2]) => {
         const change = record5(value2);
         const kind = { type: change.type };
         if (change.type === "update") kind.movePath = change.move_path ?? null;
-        return { path: path70, kind, diff: change.unified_diff ?? change.content ?? "" };
+        return { path: path71, kind, diff: change.unified_diff ?? change.content ?? "" };
       });
       break;
     case "collabAgentToolCall":
@@ -57925,8 +57951,8 @@ function markdownTargets(text11) {
 function markdownReferences(text11, paths = localResourcePaths) {
   const { tree, references } = markdownTargets(text11);
   return { tree, references: references.flatMap((ref) => {
-    const path70 = paths.parseLink(ref.url);
-    return path70 === null ? [] : [{ ...ref, path: path70 }];
+    const path71 = paths.parseLink(ref.url);
+    return path71 === null ? [] : [{ ...ref, path: path71 }];
   }) };
 }
 function collectAssistantImagePaths(value, resourcePaths2 = localResourcePaths) {
@@ -57957,8 +57983,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 path70 = patch?.path;
-        if (Array.isArray(path70) && path70[0] === "turnHistory" && path70[1] === "history" && path70[2] === "entitiesByKey" && (path70.length === 4 || path70[4] === "items")) pending.push(patch.value);
+        const path71 = patch?.path;
+        if (Array.isArray(path71) && path71[0] === "turnHistory" && path71[1] === "history" && path71[2] === "entitiesByKey" && (path71.length === 4 || path71[4] === "items")) pending.push(patch.value);
       }
     }
   }
@@ -58159,11 +58185,11 @@ async function readHistoryImageValue(locator, signal, filePath) {
   signal?.throwIfAborted();
   return value;
 }
-async function assertHistoryImageFileReference(locator, path70, signal) {
-  const value = await readHistoryImageValue(locator, signal, path70);
+async function assertHistoryImageFileReference(locator, path71, signal) {
+  const value = await readHistoryImageValue(locator, signal, path71);
   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 === path70 : assistantPaths(text11).includes(path70))) {
+  if (text11 === null || !(last === "path" ? text11 === path71 : assistantPaths(text11).includes(path71))) {
     throw new SessionHistoryError("INVALID_RECORD", "\u56FE\u7247\u6587\u4EF6\u4E0E\u5386\u53F2\u5F15\u7528\u4E0D\u7B26");
   }
 }
@@ -58222,7 +58248,7 @@ var init_session_history_images = __esm({
         const found = [];
         if (formal && item.type === "agentMessage") {
           const references = [];
-          for (const path70 of assistantPaths(String(item.text ?? ""))) {
+          for (const path71 of assistantPaths(String(item.text ?? ""))) {
             references.push({ locator: {
               threadId: threadId2,
               turnId: "",
@@ -58235,7 +58261,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: path70, filePath: path70, callId: null });
+            }, nativeMessageId: null, path: path71, filePath: path71, callId: null });
           }
           this.markdownEvidence.set(item, references);
         }
@@ -58264,7 +58290,7 @@ var init_session_history_images = __esm({
           }
           if (!imageUrl(source2)) return;
           const previous = index > 0 ? record5(parts[index - 1]).text : null;
-          const path70 = typeof previous === "string" ? /^<image(?: name=.*?)? path="([^"]+)">$/.exec(previous)?.[1] ?? null : null;
+          const path71 = typeof previous === "string" ? /^<image(?: name=.*?)? path="([^"]+)">$/.exec(previous)?.[1] ?? null : null;
           found.push({
             locator: {
               threadId: threadId2,
@@ -58284,7 +58310,7 @@ var init_session_history_images = __esm({
               ]
             },
             nativeMessageId: typeof item.clientId === "string" ? item.clientId : null,
-            path: path70,
+            path: path71,
             callId: null
           });
           if (mapped[index]) mapped[index] = { type: "historyImage", resourceKey: null };
@@ -58346,11 +58372,11 @@ var init_session_history_images = __esm({
           }
           if (item.type === "agentMessage" && typeof item.text === "string") {
             const references = [];
-            for (const [referenceIndex, path70] of assistantPaths(item.text).entries()) {
+            for (const [referenceIndex, path71] 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 === path70;
+                  return record5(JSON.parse(String(candidate.arguments))).path === path71;
                 } catch {
                   return false;
                 }
@@ -58358,9 +58384,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 === path70);
+              const original = candidates[0] ?? this.markdownEvidence.get(item)?.find((value) => value.filePath === path71);
               if (!original) continue;
-              const evidence = { ...original, path: path70, referenceKind: "markdown", locator: {
+              const evidence = { ...original, path: path71, referenceKind: "markdown", locator: {
                 ...original.locator,
                 turnId,
                 itemId: item.id,
@@ -58368,7 +58394,7 @@ var init_session_history_images = __esm({
               } };
               try {
                 const resourceKey = await callback(evidence);
-                if (resourceKey) references.push({ path: path70, resourceKey });
+                if (resourceKey) references.push({ path: path71, resourceKey });
               } catch {
               }
             }
@@ -58387,7 +58413,7 @@ __export(session_history_reader_exports, {
   SessionHistoryReader: () => SessionHistoryReader
 });
 import { randomUUID as randomUUID38 } from "node:crypto";
-import fs38 from "node:fs/promises";
+import fs39 from "node:fs/promises";
 function resolveHistoryPath(resolvePath, signal) {
   abortIfRequested2(signal);
   if (!signal) return resolvePath();
@@ -58655,7 +58681,7 @@ var init_session_history_reader = __esm({
           try {
             const resolved3 = await resolveHistoryPath(() => this.options.resolveSessionPath(snapshot2.threadId), signal);
             abortIfRequested2(signal);
-            const current2 = await fs38.realpath(resolved3);
+            const current2 = await fs39.realpath(resolved3);
             abortIfRequested2(signal);
             if (current2 !== snapshot2.files[0].path) throw new Error("current path changed");
           } catch (error2) {
@@ -63502,10 +63528,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 path70 = patch.path;
-            if (!Array.isArray(path70)) return false;
-            if (path70[0] === "requests") return ["add", "replace", "remove"].includes(String(patch.op));
-            return path70[0] === "turnHistory" && path70[1] === "history" && path70[2] === "entitiesByKey" && typeof path70[3] === "string" && path70[3].endsWith(`:${recovery.turnId}`) && path70[4] === "items" && (patch.op === "add" && path70.length === 6 || patch.op === "replace" && path70.length === 7 && path70[6] === "text");
+            const path71 = patch.path;
+            if (!Array.isArray(path71)) return false;
+            if (path71[0] === "requests") return ["add", "replace", "remove"].includes(String(patch.op));
+            return path71[0] === "turnHistory" && path71[1] === "history" && path71[2] === "entitiesByKey" && typeof path71[3] === "string" && path71[3].endsWith(`:${recovery.turnId}`) && path71[4] === "items" && (patch.op === "add" && path71.length === 6 || patch.op === "replace" && path71.length === 7 && path71[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;
@@ -63874,11 +63900,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: path70 } = bound.metadata;
+        const { createdAt, cwd, path: path71 } = bound.metadata;
         return {
           nativeOrder: bound.nativeOrder,
           sourceRevision: bound.revision,
-          contentVersion: createHash27("sha256").update(JSON.stringify([turn, createdAt, cwd, path70])).digest("hex")
+          contentVersion: createHash27("sha256").update(JSON.stringify([turn, createdAt, cwd, path71])).digest("hex")
         };
       }
       /** 撤销正文提交资格，保留逻辑边界供下次原生读取重新证明。 */
@@ -66386,7 +66412,7 @@ var init_thread_history_window_projection = __esm({
           pending: null,
           activity: null,
           lastError: null,
-          resolveKnownLocalImage: (path70, itemId, partIndex) => this.options.resolveKnownLocalImage?.(path70, itemId, partIndex) ?? (itemId ? knownImages.get(itemId)?.get(path70) ?? null : null),
+          resolveKnownLocalImage: (path71, itemId, partIndex) => this.options.resolveKnownLocalImage?.(path71, itemId, partIndex) ?? (itemId ? knownImages.get(itemId)?.get(path71) ?? 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 ?? []];
@@ -67260,8 +67286,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), path70 = Array.isArray(patch.path) ? patch.path : [];
-      const name2 = path70.length === 1 ? path70[0] : path70.length === 2 && path70[0] === "conversationState" ? path70[1] : null;
+      const patch = object10(value), path71 = Array.isArray(patch.path) ? patch.path : [];
+      const name2 = path71.length === 1 ? path71[0] : path71.length === 2 && path71[0] === "conversationState" ? path71[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;
@@ -69265,9 +69291,9 @@ function assertFile(stat4) {
   if (!stat4.isFile() || stat4.nlink !== 1n) throw missing2();
   if (stat4.size > BigInt(MAX_BYTES6)) throw limited();
 }
-async function captureDirectoryChain(snapshot2, path70, signal) {
+async function captureDirectoryChain(snapshot2, path71, signal) {
   const paths = /* @__PURE__ */ new Set();
-  for (const start of [dirname2(path70)]) {
+  for (const start of [dirname2(path71)]) {
     for (let current2 = start; ; current2 = dirname2(current2)) {
       paths.add(current2);
       if (paths.size > MAX_DIRECTORY_ENTRIES2) throw limited();
@@ -69397,9 +69423,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, path70, signal, isCurrent) {
+      assertTarget(entry, path71, signal, isCurrent) {
         this.assertVisible(entry, signal, isCurrent);
-        if (entry.targetRealPath !== void 0 && entry.targetRealPath !== path70) {
+        if (entry.targetRealPath !== void 0 && entry.targetRealPath !== path71) {
           this.remove(entry);
           this.options.onReferenceRetired?.({ ...entry.reference, attachmentId: entry.attachmentId });
           throw changed();
@@ -69441,17 +69467,17 @@ 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 path70 = await realpath2(entry.reference.path);
+          const path71 = await realpath2(entry.reference.path);
           combined.throwIfAborted();
-          this.assertTarget(entry, path70, combined, isCurrent);
-          await captureDirectoryChain(directories2, path70, combined);
-          const pathBefore = await lstat4(path70, { bigint: true });
+          this.assertTarget(entry, path71, combined, isCurrent);
+          await captureDirectoryChain(directories2, path71, combined);
+          const pathBefore = await lstat4(path71, { bigint: true });
           assertFile(pathBefore);
-          handle = await open5(path70, constants4.O_RDONLY | constants4.O_NOFOLLOW | constants4.O_NONBLOCK);
+          handle = await open5(path71, 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 = `${path70}\0${identity5(before)}`;
+          const fileIdentity2 = `${path71}\0${identity5(before)}`;
           if (request2 && expected.identity !== fileIdentity2) throw changed();
           const byteSize2 = Number(before.size);
           const chunkCount = Math.ceil(byteSize2 / CHUNK_BYTES);
@@ -69477,7 +69503,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 !== path70 || identity5(after) !== identity5(before) || identity5(current2) !== identity5(before)) throw changed();
+          if (pathAfter !== path71 || 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();
@@ -69493,8 +69519,8 @@ var init_file_resources = __esm({
             chunkBytes: CHUNK_BYTES,
             chunkCount
           };
-          this.assertTarget(entry, path70, combined, isCurrent);
-          return { entry, path: path70, info, identity: fileIdentity2, chunk, signal: combined };
+          this.assertTarget(entry, path71, combined, isCurrent);
+          return { entry, path: path71, info, identity: fileIdentity2, chunk, signal: combined };
         } catch (error2) {
           combined.throwIfAborted();
           if (error2 instanceof NiumaError) throw error2;
@@ -69526,16 +69552,16 @@ function revisionOf2(value) {
 function occurredAt3() {
   return Math.floor(Date.now() / 1e3);
 }
-function isThreadSettingsPatch(path70) {
-  const field2 = path70.at(-1);
+function isThreadSettingsPatch(path71) {
+  const field2 = path71.at(-1);
   if (typeof field2 !== "string" || !SETTING_FIELD_ALIASES.has(field2)) {
     return false;
   }
-  return path70.length === 1 || typeof path70.at(-2) === "string" && SETTINGS_CONTAINERS.has(path70.at(-2));
+  return path71.length === 1 || typeof path71.at(-2) === "string" && SETTINGS_CONTAINERS.has(path71.at(-2));
 }
-function isCurrentPermissionsPatch(path70) {
-  const field2 = path70.at(-1);
-  return path70.length === 2 && path70[0] === CURRENT_PERMISSIONS_CONTAINER && typeof field2 === "string" && CURRENT_PERMISSION_FIELD_ALIASES.has(field2);
+function isCurrentPermissionsPatch(path71) {
+  const field2 = path71.at(-1);
+  return path71.length === 2 && path71[0] === CURRENT_PERMISSIONS_CONTAINER && typeof field2 === "string" && CURRENT_PERMISSION_FIELD_ALIASES.has(field2);
 }
 function hasOwn(value, field2) {
   return Object.prototype.hasOwnProperty.call(value, field2);
@@ -69614,20 +69640,20 @@ function currentPermissionsFromRecord(value) {
   return settings;
 }
 function settingsFromPatch(patch) {
-  const path70 = array6(patch.path);
-  if (path70.length === 1 && typeof path70[0] === "string" && SETTINGS_CONTAINERS.has(path70[0])) {
+  const path71 = array6(patch.path);
+  if (path71.length === 1 && typeof path71[0] === "string" && SETTINGS_CONTAINERS.has(path71[0])) {
     return settingsFromRecord(patch.value, BASE_SETTING_FIELDS);
   }
-  if (path70.length === 1 && path70[0] === CURRENT_PERMISSIONS_CONTAINER) {
+  if (path71.length === 1 && path71[0] === CURRENT_PERMISSIONS_CONTAINER) {
     return currentPermissionsFromRecord(patch.value);
   }
-  const field2 = path70.at(-1);
+  const field2 = path71.at(-1);
   const settings = {};
-  if (typeof field2 === "string" && isCurrentPermissionsPatch(path70)) {
+  if (typeof field2 === "string" && isCurrentPermissionsPatch(path71)) {
     assignCurrentPermission(settings, field2, patch.value);
     return settings;
   }
-  if (typeof field2 === "string" && isThreadSettingsPatch(path70)) {
+  if (typeof field2 === "string" && isThreadSettingsPatch(path71)) {
     assignSetting(settings, field2, patch.value);
   }
   return settings;
@@ -73045,8 +73071,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), path70 = array7(p.path);
-          return path70[0] === "turnHistory" && (path70.length < 3 || path70[1] === "history" && (path70[2] === "entitiesByKey" && (path70.length < 4 || path70.length > 4 && ["id", "turnId", "params"].includes(String(path70[4])))));
+          const p = record25(value), path71 = array7(p.path);
+          return path71[0] === "turnHistory" && (path71.length < 3 || path71[1] === "history" && (path71[2] === "entitiesByKey" && (path71.length < 4 || path71.length > 4 && ["id", "turnId", "params"].includes(String(path71[4])))));
         });
         if (next !== previous + 1 || unknownMembership) {
           this.idleHistoryBaselines.delete(context.threadId);
@@ -73056,9 +73082,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), path70 = array7(p.path);
-          if (p.op === "remove" && path70.length === 4 && path70[0] === "turnHistory" && path70[1] === "history" && path70[2] === "entitiesByKey") {
-            const id5 = mapped.get(String(path70[3]));
+          const p = record25(value), path71 = array7(p.path);
+          if (p.op === "remove" && path71.length === 4 && path71[0] === "turnHistory" && path71[1] === "history" && path71[2] === "entitiesByKey") {
+            const id5 = mapped.get(String(path71[3]));
             if (id5) candidates.add(id5);
           }
         }
@@ -73069,9 +73095,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), path70 = array7(p.path), entity = record25(p.value);
-          if (path70.length !== 4 || path70[0] !== "turnHistory" || path70[1] !== "history" || path70[2] !== "entitiesByKey") continue;
-          const key = String(path70[3]);
+          const p = record25(value), path71 = array7(p.path), entity = record25(p.value);
+          if (path71.length !== 4 || path71[0] !== "turnHistory" || path71[1] !== "history" || path71[2] !== "entitiesByKey") continue;
+          const key = String(path71[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);
@@ -73197,8 +73223,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 path70 = array7(patch.path);
-          if ((patch.op === "add" || patch.op === "replace") && (path70.length === 1 && path70[0] === "recencyAt" || path70.length === 2 && path70[0] === "conversationState" && path70[1] === "recencyAt")) {
+          const path71 = array7(patch.path);
+          if ((patch.op === "add" || patch.op === "replace") && (path71.length === 1 && path71[0] === "recencyAt" || path71.length === 2 && path71[0] === "conversationState" && path71[1] === "recencyAt")) {
             this.rememberSidebarRecency(context.threadId, patch.value);
           }
         }
@@ -73284,12 +73310,12 @@ var init_desktop_ipc_thread_view_adapter = __esm({
           requests = structuredClone(requests);
           for (const value of array7(change.patches)) {
             const patch = record25(value);
-            const path70 = array7(patch.path);
-            if (path70[0] !== "requests") continue;
-            if (path70.length === 1) {
+            const path71 = array7(patch.path);
+            if (path71[0] !== "requests") continue;
+            if (path71.length === 1) {
               requests = patch.op === "remove" ? [] : structuredClone(array7(patch.value));
-            } else if (path70.length === 2) {
-              const index = path70[1] === "-" ? requests.length : Number(path70[1]);
+            } else if (path71.length === 2) {
+              const index = path71[1] === "-" ? requests.length : Number(path71[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));
@@ -73368,19 +73394,19 @@ var init_desktop_ipc_thread_view_adapter = __esm({
       }
       /** 深层 content 只有局部形状，须等待完整项/快照重新证明；text 更新不能洗掉未知内容。 */
       invalidateReadPatch(patch, context) {
-        const path70 = array7(patch.path);
-        if (path70[0] !== "turnHistory" || path70[1] !== "history" || path70[2] !== "entitiesByKey") return;
-        const turnId = typeof path70[3] === "string" ? this.entityTurnIdsByThread.get(context.threadId)?.get(path70[3]) : null;
-        if (turnId && turnId === this.readTurnByThread.get(context.threadId) && this.activeTurnByThread.get(context.threadId) !== turnId && (path70[4] === "items" || path70.length === 4 && hasOwn2(record25(patch.value), "items"))) {
+        const path71 = array7(patch.path);
+        if (path71[0] !== "turnHistory" || path71[1] !== "history" || path71[2] !== "entitiesByKey") return;
+        const turnId = typeof path71[3] === "string" ? this.entityTurnIdsByThread.get(context.threadId)?.get(path71[3]) : null;
+        if (turnId && turnId === this.readTurnByThread.get(context.threadId) && this.activeTurnByThread.get(context.threadId) !== turnId && (path71[4] === "items" || path71.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 (path70[4] !== "items" || path70[6] !== "content") return;
+        if (path71[4] !== "items" || path71[6] !== "content") return;
         const order = this.itemOrders.get(context.threadId);
-        if (!order || order.entityKey !== path70[3]) return;
-        const id5 = typeof path70[5] === "number" ? order.ids[path70[5]] : null;
+        if (!order || order.entityKey !== path71[3]) return;
+        const id5 = typeof path71[5] === "number" ? order.ids[path71[5]] : null;
         const identity6 = id5 ? this.nativeReadIdentities.get(context.threadId)?.get(id5) : null;
         if (identity6) identity6.complete = false;
         else if (!id5) {
@@ -73404,19 +73430,19 @@ var init_desktop_ipc_thread_view_adapter = __esm({
       /** 在同一 Store 事务内先更新正文，再发布可信顺序，不让 Web 看见暂存的中间帧。 */
       itemOrderEvents(patch, itemEvents, context) {
         if (this.itemOrderGaps.has(context.threadId)) return [];
-        const path70 = array7(patch.path);
-        if (path70[0] !== "turnHistory") return [];
+        const path71 = array7(patch.path);
+        if (path71[0] !== "turnHistory") return [];
         const invalidate = () => {
           this.itemOrders.delete(context.threadId);
           this.itemOrderGaps.add(context.threadId);
           return [];
         };
-        if (path70.length < 3) return invalidate();
-        if (path70[1] !== "history" || path70[2] !== "entitiesByKey") return [];
-        if (path70.length < 4) return invalidate();
+        if (path71.length < 3) return invalidate();
+        if (path71[1] !== "history" || path71[2] !== "entitiesByKey") return [];
+        if (path71.length < 4) return invalidate();
         const activeId = this.activeTurnByThread.get(context.threadId);
         if (!activeId) return [];
-        const entityKey = String(path70[3]);
+        const entityKey = String(path71[3]);
         const events = [];
         const emitItem = (value) => {
           const item = this.orderedRawItem(value, activeId, context);
@@ -73433,8 +73459,8 @@ var init_desktop_ipc_thread_view_adapter = __esm({
           return item?.id ?? null;
         };
         let order = this.itemOrders.get(context.threadId);
-        const wholeEntity = path70.length === 4;
-        const wholeArray = path70.length === 5 && path70[4] === "items";
+        const wholeEntity = path71.length === 4;
+        const wholeArray = path71.length === 5 && path71[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);
@@ -73450,12 +73476,12 @@ var init_desktop_ipc_thread_view_adapter = __esm({
           }
           values.forEach(emitItem);
         } else {
-          if (!order || order.turnId !== activeId || order.entityKey !== entityKey || path70[4] !== "items") return [];
-          if (path70.length > 6) {
-            return ["id", "type"].includes(String(path70[6])) ? invalidate() : [];
+          if (!order || order.turnId !== activeId || order.entityKey !== entityKey || path71[4] !== "items") return [];
+          if (path71.length > 6) {
+            return ["id", "type"].includes(String(path71[6])) ? invalidate() : [];
           }
-          if (path70.length !== 6 || !["add", "replace", "remove"].includes(String(patch.op))) return invalidate();
-          const index = path70[5] === "-" && patch.op === "add" ? order.ids.length : path70[5];
+          if (path71.length !== 6 || !["add", "replace", "remove"].includes(String(patch.op))) return invalidate();
+          const index = path71[5] === "-" && patch.op === "add" ? order.ids.length : path71[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];
@@ -73676,12 +73702,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 path70 = array7(patch.path);
-          if (path70[0] !== "turnHistory" || path70[1] !== "history" || path70[2] !== "entitiesByKey" || typeof path70[3] !== "string") continue;
-          const entityKey = path70[3];
-          const wholeEntity = path70.length === 4;
-          const statusField = path70.length === 5 && path70[4] === "status";
-          const startField = path70.length === 5 && path70[4] === "turnStartedAtMs";
+          const path71 = array7(patch.path);
+          if (path71[0] !== "turnHistory" || path71[1] !== "history" || path71[2] !== "entitiesByKey" || typeof path71[3] !== "string") continue;
+          const entityKey = path71[3];
+          const wholeEntity = path71.length === 4;
+          const statusField = path71.length === 5 && path71[4] === "status";
+          const startField = path71.length === 5 && path71[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;
@@ -73886,12 +73912,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 path70 = match[1];
-    if (slashes % 2 || paths.parseLocal(path70) === null) continue;
+    const path71 = match[1];
+    if (slashes % 2 || paths.parseLocal(path71) === null) continue;
     try {
-      const target = paths.toLink(path70);
+      const target = paths.toLink(path71);
       if (target === null) continue;
-      const label2 = fallbackFileName(path70, paths).replace(/[\\`*_[\]<> &]/gu, (value) => `&#${value.codePointAt(0)};`);
+      const label2 = fallbackFileName(path71, paths).replace(/[\\`*_[\]<> &]/gu, (value) => `&#${value.codePointAt(0)};`);
       edits.push({ start, end, value: `[${label2}](<${target}>)` });
     } catch {
     }
@@ -73909,9 +73935,9 @@ function fileReferences(text11, paths) {
   return markdownTargets(text11).references.filter((ref) => !ref.image).flatMap((ref) => {
     try {
       const target = withoutFileLocation(ref.url);
-      const path70 = paths.parseLink(target);
-      if (path70 === null) return [];
-      return [{ ...ref, path: path70 }];
+      const path71 = paths.parseLink(target);
+      if (path71 === null) return [];
+      return [{ ...ref, path: path71 }];
     } catch {
       return [];
     }
@@ -73921,8 +73947,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(path70, paths) {
-  const name2 = paths.basename(path70).slice(0, 255);
+function fallbackFileName(path71, paths) {
+  const name2 = paths.basename(path71).slice(0, 255);
   return name2.trim() && !/[\\/\x00-\x1f\x7f-\x9f]/u.test(name2) ? name2 : "\u6587\u4EF6";
 }
 function projectFileLinks(item, register, isRegistered = () => true, paths = localResourcePaths) {
@@ -73986,7 +74012,7 @@ var init_thread_view_files = __esm({
 
 // apps/desktop/src/daemon/runtime/projection.ts
 import { createHash as createHash36 } from "node:crypto";
-import path53 from "node:path";
+import path54 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"() {
@@ -74118,14 +74144,14 @@ var init_projection2 = __esm({
       isFileReferenceVisible(entry) {
         if (this.ports.stopping()) return false;
         const root = this.ports.projectRoot(entry.threadId);
-        if (!root || path53.resolve(root) !== entry.root) return false;
+        if (!root || path54.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" && path53.resolve(source2.path) === entry.path);
+          return this.store.nativeFileSources(entry.threadId, entry.itemId).some((source2) => item.content[source2.index]?.type === "file" && path54.resolve(source2.path) === entry.path);
         }
         if (item.type !== "assistant_message") return false;
-        if (collectFileLinkPaths(item).some((sourcePath) => path53.resolve(sourcePath) === entry.path)) return true;
+        if (collectFileLinkPaths(item).some((sourcePath) => path54.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();
@@ -75663,8 +75689,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), path70 = Array.isArray(patch.path) ? patch.path : [];
-            const fields3 = path70[0] === "conversationState" ? path70.slice(1) : path70;
+            const patch = objectRecord3(value), path71 = Array.isArray(patch.path) ? patch.path : [];
+            const fields3 = path71[0] === "conversationState" ? path71.slice(1) : path71;
             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);
@@ -77939,7 +77965,7 @@ var init_image_decoder = __esm({
 });
 
 // apps/desktop/src/attachments/image-assets.ts
-import path54 from "node:path";
+import path55 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)}` };
@@ -77986,7 +78012,7 @@ var init_image_assets = __esm({
       }
       paths(id5) {
         const n = names(id5);
-        return { sourcePath: path54.join(this.root, n.source, "source"), previewPath: path54.join(this.root, n.preview, "source") };
+        return { sourcePath: path55.join(this.root, n.source, "source"), previewPath: path55.join(this.root, n.preview, "source") };
       }
       asset(id5) {
         const value = this.assets.get(id5);
@@ -78118,7 +78144,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 execFile13 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
-import path55 from "node:path";
+import path56 from "node:path";
 async function preparePrivateImageRoot(directory3) {
   if (process.platform === "win32") {
     await ensureWindowsPrivateDirectoryAsync(directory3);
@@ -78134,7 +78160,7 @@ async function createPrivateImageDirectory(directory3) {
     return;
   }
   directory3 = localWindowsPath(directory3);
-  const parent = await openPrivateImageDirectory(path55.dirname(directory3));
+  const parent = await openPrivateImageDirectory(path56.dirname(directory3));
   try {
     await parent.verify();
     await mkdir2(directory3, { mode: 448 });
@@ -78157,7 +78183,7 @@ Check-PrivateDirectory $env:NIUMA_IMAGE_DIRECTORY
 }
 async function openPrivateImageDirectory(requested, openFile2 = open6) {
   const windows2 = process.platform === "win32";
-  const directory3 = windows2 ? localWindowsPath(requested) : path55.resolve(requested);
+  const directory3 = windows2 ? localWindowsPath(requested) : path56.resolve(requested);
   const initial = await lstat5(directory3, { bigint: true });
   if (!initial.isDirectory() || initial.isSymbolicLink()) throw unavailable10();
   let handle;
@@ -78266,7 +78292,7 @@ var init_private_image_files = __esm({
 // apps/desktop/src/platform/private-image-commit.ts
 import { randomUUID as randomUUID50 } from "node:crypto";
 import { lstat as lstat6, rename as rename2, rm as rm2 } from "node:fs/promises";
-import path56 from "node:path";
+import path57 from "node:path";
 async function snapshot(file, maxBytes) {
   try {
     await lstat6(file);
@@ -78331,7 +78357,7 @@ var init_private_image_commit = __esm({
             await this.writeBinary(file, bytes3, maxBytes);
             return;
           }
-          const directory3 = await openPrivateImageDirectory(path56.dirname(file));
+          const directory3 = await openPrivateImageDirectory(path57.dirname(file));
           try {
             const handle = await privateBinaryFiles.open(file, { maxBytes, writable: true, mode: "mutable" });
             try {
@@ -78366,7 +78392,7 @@ var init_private_image_commit = __esm({
         }
       },
       async writeBinary(file, bytes3, maxBytes) {
-        const directory3 = await openPrivateImageDirectory(path56.dirname(file));
+        const directory3 = await openPrivateImageDirectory(path57.dirname(file));
         try {
           await directory3.verify();
           await writeNew(file, bytes3, maxBytes);
@@ -78379,8 +78405,8 @@ var init_private_image_commit = __esm({
         const bytes3 = Buffer.from(input);
         let published = false, renameAttempted = false;
         let temporaryIdentity;
-        const directory3 = await openPrivateImageDirectory(path56.dirname(file));
-        const temporary = path56.join(path56.dirname(file), `.manifest-${randomUUID50()}.tmp`);
+        const directory3 = await openPrivateImageDirectory(path57.dirname(file));
+        const temporary = path57.join(path57.dirname(file), `.manifest-${randomUUID50()}.tmp`);
         try {
           if (bytes3.length > maxBytes) throw new PrivateImageCommitError();
           new TextDecoder("utf-8", { fatal: true }).decode(bytes3);
@@ -78428,14 +78454,14 @@ var init_private_image_commit = __esm({
 });
 
 // apps/desktop/src/platform/private-document-directory.ts
-import fs39 from "node:fs";
-import path57 from "node:path";
+import fs40 from "node:fs";
+import path58 from "node:path";
 async function openPrivateDocumentDirectory(root) {
-  const directory3 = path57.resolve(root);
+  const directory3 = path58.resolve(root);
   let identity6;
   try {
     privateLogFiles.ensureDirectory(directory3);
-    identity6 = fs39.lstatSync(directory3, { bigint: true });
+    identity6 = fs40.lstatSync(directory3, { bigint: true });
     privateLogFiles.checkDirectory(directory3);
     guard();
   } catch {
@@ -78443,7 +78469,7 @@ async function openPrivateDocumentDirectory(root) {
   }
   function guard() {
     try {
-      const current2 = fs39.lstatSync(directory3, { bigint: true });
+      const current2 = fs40.lstatSync(directory3, { bigint: true });
       if (!current2.isDirectory() || current2.isSymbolicLink() || current2.dev !== identity6.dev || current2.ino !== identity6.ino) {
         throw new PrivateDocumentFileError("unavailable");
       }
@@ -78456,7 +78482,7 @@ async function openPrivateDocumentDirectory(root) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/u.test(name2) || name2 === "." || name2 === "..") {
       throw new PrivateDocumentFileError("unavailable");
     }
-    return path57.join(directory3, name2);
+    return path58.join(directory3, name2);
   }
   const files = privateStateFilesWithGuard(guard);
   return {
@@ -78540,36 +78566,36 @@ function decodeBase64(value) {
 function sha256(value) {
   return createHash39("sha256").update(value).digest("hex");
 }
-async function readJsonManifest(path70, io) {
+async function readJsonManifest(path71, io) {
   try {
     if (io.controlledFiles) {
-      const { data } = await io.controlledFiles.read(path70);
+      const { data } = await io.controlledFiles.read(path71);
       return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(data));
     }
-    const status2 = await lstat7(path70);
+    const status2 = await lstat7(path71);
     if (!status2.isFile() || status2.isSymbolicLink()) {
       return null;
     }
-    return JSON.parse(await readFile2(path70, "utf8"));
+    return JSON.parse(await readFile2(path71, "utf8"));
   } catch {
     return null;
   }
 }
-async function assertRegularControlledFile(directoryPath, path70) {
-  if (dirname3(path70) !== directoryPath) {
+async function assertRegularControlledFile(directoryPath, path71) {
+  if (dirname3(path71) !== directoryPath) {
     throw new Error("ATTACHMENT_PATH_OUTSIDE_ROOT");
   }
-  const status2 = await lstat7(path70).catch(() => null);
+  const status2 = await lstat7(path71).catch(() => null);
   if (!status2?.isFile() || status2.isSymbolicLink()) {
     throw new Error("ATTACHMENT_FILE_NOT_AVAILABLE");
   }
 }
-async function readRegularFileNoFollow(io, directoryPath, path70, expectedIdentity, expectedSize) {
-  if (dirname3(path70) !== directoryPath) {
+async function readRegularFileNoFollow(io, directoryPath, path71, expectedIdentity, expectedSize) {
+  if (dirname3(path71) !== directoryPath) {
     throw new Error("ATTACHMENT_PATH_OUTSIDE_ROOT");
   }
-  if (io.controlledFiles) return io.controlledFiles.read(path70, expectedIdentity, expectedSize);
-  const handle = await io.open(path70, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
+  if (io.controlledFiles) return io.controlledFiles.read(path71, expectedIdentity, expectedSize);
+  const handle = await io.open(path71, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
   if (!handle) {
     throw new Error("ATTACHMENT_FILE_NOT_AVAILABLE");
   }
@@ -78593,8 +78619,8 @@ async function readRegularFileNoFollow(io, directoryPath, path70, expectedIdenti
     await handle.close();
   }
 }
-async function readStableLocalFile(io, path70) {
-  const handle = await io.open(path70, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
+async function readStableLocalFile(io, path71) {
+  const handle = await io.open(path71, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
   if (!handle) {
     throw new Error("LOCAL_IMAGE_NOT_REGULAR_FILE");
   }
@@ -78606,8 +78632,8 @@ async function readStableLocalFile(io, path70) {
     if (openedStatus.size > BigInt(MAX_IMAGE_BYTES)) {
       throw new Error("ATTACHMENT_TOO_LARGE");
     }
-    const canonicalPath = await realpath3(path70).catch(() => null);
-    const currentStatus = await lstat7(path70, { bigint: true }).catch(() => null);
+    const canonicalPath = await realpath3(path71).catch(() => null);
+    const currentStatus = await lstat7(path71, { 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");
     }
@@ -78620,17 +78646,17 @@ async function readStableLocalFile(io, path70) {
     await handle.close();
   }
 }
-async function pathIsMissing(path70) {
+async function pathIsMissing(path71) {
   try {
-    await lstat7(path70);
+    await lstat7(path71);
     return false;
   } catch (error2) {
     return error2.code === "ENOENT";
   }
 }
-async function readFileIdentity(io, path70) {
-  if (io.controlledFiles) return io.controlledFiles.identity(path70);
-  const handle = await io.open(path70, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
+async function readFileIdentity(io, path71) {
+  if (io.controlledFiles) return io.controlledFiles.identity(path71);
+  const handle = await io.open(path71, constants6.O_RDONLY | constants6.O_NOFOLLOW).catch(() => null);
   if (!handle) {
     throw new Error("ATTACHMENT_FILE_NOT_AVAILABLE");
   }
@@ -78745,7 +78771,7 @@ var init_store = __esm({
       webp: "image/webp"
     };
     DEFAULT_ATTACHMENT_STORE_IO = {
-      open: (path70, flags) => open7(path70, flags),
+      open: (path71, flags) => open7(path71, flags),
       controlledFiles: privateImageFiles
     };
     AttachmentStore = class _AttachmentStore {
@@ -78958,15 +78984,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 path70 = join2(upload.directoryPath, `chunk-${input.startIndex + offset}`), chunk = chunks[offset];
+              const path71 = join2(upload.directoryPath, `chunk-${input.startIndex + offset}`), chunk = chunks[offset];
               let handle;
               try {
-                handle = await this.#io.open(path70, constants6.O_WRONLY | constants6.O_CREAT | constants6.O_EXCL | constants6.O_NOFOLLOW);
+                handle = await this.#io.open(path71, 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, path70, void 0, chunk.length);
+                const stored = await readRegularFileNoFollow(this.#io, upload.directoryPath, path71, void 0, chunk.length);
                 if (!stored.data.equals(chunk)) throw new Error("CHUNK_CONFLICT");
-                handle = await this.#io.open(path70, constants6.O_RDONLY | constants6.O_NOFOLLOW);
+                handle = await this.#io.open(path71, constants6.O_RDONLY | constants6.O_NOFOLLOW);
               }
               try {
                 const status2 = await handle.stat();
@@ -79346,9 +79372,9 @@ var init_store = __esm({
                 await this.#imageAssets.removeBytes(record26.id);
                 continue;
               }
-              for (const path70 of [record26.sourcePath, record26.previewPath]) {
-                const status2 = await lstat7(path70).catch(() => null);
-                if (status2?.isFile() && !status2.isSymbolicLink()) await rm3(path70);
+              for (const path71 of [record26.sourcePath, record26.previewPath]) {
+                const status2 = await lstat7(path71).catch(() => null);
+                if (status2?.isFile() && !status2.isSymbolicLink()) await rm3(path71);
               }
             }
           }
@@ -79886,10 +79912,10 @@ var init_store = __esm({
         return bytes3;
       }
       async #loadBindingIndex() {
-        const path70 = 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(path70, this.#io);
+        const path71 = 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(path71, this.#io);
         if (manifest === null) {
-          if (this.#rawCommit && !await pathIsMissing(path70)) this.#bindingUnavailable = true;
+          if (this.#rawCommit && !await pathIsMissing(path71)) this.#bindingUnavailable = true;
           return;
         }
         if (!isBindingIndexManifest(manifest)) {
@@ -79949,14 +79975,14 @@ var init_store = __esm({
           return;
         }
         const temporaryPath = join2(this.#rootDir, `.bindings-${randomUUID51()}.tmp`);
-        const path70 = join2(this.#rootDir, BINDINGS_RELATIVE_PATH);
+        const path71 = join2(this.#rootDir, BINDINGS_RELATIVE_PATH);
         await writeFile(temporaryPath, `${JSON.stringify(manifest)}
 `, {
           flag: "wx",
           mode: 384
         });
-        await rename3(temporaryPath, path70);
-        await chmod3(path70, 384);
+        await rename3(temporaryPath, path71);
+        await chmod3(path71, 384);
       }
       #commitBindings(bindings) {
         this.#bindings.clear();
@@ -81068,7 +81094,7 @@ var init_managed_store = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/attachment-storage.ts
-import path58 from "node:path";
+import path59 from "node:path";
 import { randomUUID as randomUUID53 } from "node:crypto";
 var ATTACHMENT_CLEANUP_INTERVAL_MS, RuntimeAttachmentStorage;
 var init_attachment_storage = __esm({
@@ -81210,7 +81236,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(path58.join(this.ports.dataDirectory(), "attachments", "bindings")).then((store) => {
+          this.attachmentMessageBindingsPromise = AttachmentMessageBindings.open(path59.join(this.ports.dataDirectory(), "attachments", "bindings")).then((store) => {
             this.attachmentMessageBindings = store;
             return store;
           }).catch((error2) => {
@@ -81226,7 +81252,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(
-            path58.join(this.ports.dataDirectory(), "attachments", "managed")
+            path59.join(this.ports.dataDirectory(), "attachments", "managed")
           )).catch((error2) => {
             if (this.managedAttachmentStorePromise === opening) this.managedAttachmentStorePromise = null;
             throw error2;
@@ -82623,9 +82649,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(path70, signal) {
+async function readSourceFile(path71, signal) {
   signal?.throwIfAborted();
-  const handle = await open8(path70, constants7.O_RDONLY | constants7.O_NOFOLLOW);
+  const handle = await open8(path71, 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");
@@ -82854,12 +82880,12 @@ var init_image_resources = __esm({
         }, JSON.stringify(identity6));
       }
       /** 仅供已认证实时消息登记；调用方每次请求仍须验证当前 item/上传暂存资格。 */
-      async registerDeferredFile(threadId2, path70, resourceKey = `live-file:${threadId2}:${path70}`) {
-        return this.register({ resourceKey, name: basename4(path70), source: { kind: "deferred-file", threadId: threadId2, path: path70 } });
+      async registerDeferredFile(threadId2, path71, resourceKey = `live-file:${threadId2}:${path71}`) {
+        return this.register({ resourceKey, name: basename4(path71), source: { kind: "deferred-file", threadId: threadId2, path: path71 } });
       }
-      async registerFile(threadId2, path70, attachmentId, context) {
+      async registerFile(threadId2, path71, attachmentId, context) {
         if (context && context.visibilityLocator.threadId !== threadId2) throw missing3();
-        const canonical = await realpath4(path70);
+        const canonical = await realpath4(path71);
         const file = await readSourceFile(canonical);
         return this.register({ attachmentId, resourceKey: context?.resourceKey ?? `file:${threadId2}:${canonical}`, name: basename4(canonical), source: {
           kind: "file",
@@ -82889,9 +82915,9 @@ var init_image_resources = __esm({
         return sameLocator(this.historyLocator(threadId2, attachmentId) ?? void 0, expectedLocator);
       }
       /** 保留原件换源时只复用相同受控文件；历史别名和旧暂存不能遮蔽新来源。 */
-      matchesFilePath(threadId2, attachmentId, path70) {
+      matchesFilePath(threadId2, attachmentId, path71) {
         const entry = this.entries.get(attachmentId);
-        return !!entry && threadOf(entry.source) === threadId2 && entry.source.kind === "file" && entry.source.path === path70;
+        return !!entry && threadOf(entry.source) === threadId2 && entry.source.kind === "file" && entry.source.path === path71;
       }
       has(threadId2, attachmentId) {
         const entry = this.entries.get(attachmentId);
@@ -83297,7 +83323,7 @@ var init_image_confirmation2 = __esm({
 // apps/desktop/src/daemon/runtime/images.ts
 import { createHash as createHash42 } from "node:crypto";
 import { realpath as realpath5 } from "node:fs/promises";
-import path59 from "node:path";
+import path60 from "node:path";
 function objectRecord12(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -83416,7 +83442,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" && path59.isAbsolute(input.path)) registrations.push(this.importThreadImage(threadId2, input.path, itemId, index));
+              if (["localImage", "local_image"].includes(String(input.type)) && typeof input.path === "string" && path60.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));
             });
@@ -83440,7 +83466,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: path59.join(this.ports.dataDirectory(), "image-resources", "index.json"),
+          indexPath: path60.join(this.ports.dataDirectory(), "image-resources", "index.json"),
           readAppServerImage: (source2, signal) => this.readAppServerImage(source2, signal),
           onDiagnostic: (event) => this.ports.diagnostic(event)
         }).catch((error2) => {
@@ -83621,7 +83647,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 || !path59.isAbsolute(sourcePath) && !embedded) return Promise.resolve();
+        if (!itemId || !path60.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);
@@ -83658,7 +83684,7 @@ var init_images = __esm({
             this.knownLocalImages.set(key, {
               type: "image",
               attachmentId: registered.attachmentId,
-              name: embedded ? "\u56FE\u7247" : path59.basename(sourcePath),
+              name: embedded ? "\u56FE\u7247" : path60.basename(sourcePath),
               previewAvailable: false,
               previewState: "deferred"
             });
@@ -85744,18 +85770,18 @@ var init_session_sources = __esm({
         const isCurrent = () => options.isCurrent?.() !== false;
         const paths = /* @__PURE__ */ new Map();
         for (const thread4 of threads) {
-          const path70 = typeof thread4.path === "string" && thread4.path.length > 0 ? thread4.path : null;
-          if (!paths.has(thread4.id)) paths.set(thread4.id, path70);
-          else if (paths.get(thread4.id) !== path70) paths.set(thread4.id, void 0);
+          const path71 = typeof thread4.path === "string" && thread4.path.length > 0 ? thread4.path : null;
+          if (!paths.has(thread4.id)) paths.set(thread4.id, path71);
+          else if (paths.get(thread4.id) !== path71) paths.set(thread4.id, void 0);
         }
-        for (const [id5, path70] of paths) {
+        for (const [id5, path71] 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, path70);
+              resolution = await resolver.resolve(thread4.id, path71);
             } catch {
               resolution = null;
             }
@@ -85820,7 +85846,7 @@ var init_session_sources = __esm({
 });
 
 // apps/desktop/src/daemon/runtime/settings-selection.ts
-import path60 from "node:path";
+import path61 from "node:path";
 var RuntimeSettingsSelection;
 var init_settings_selection = __esm({
   "apps/desktop/src/daemon/runtime/settings-selection.ts"() {
@@ -85836,7 +85862,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 ?? path60.normalize(cwd);
+        return matched ?? path61.normalize(cwd);
       }
       inheritedCreate(threadId2) {
         const empty = { authorization: null, model: null };
@@ -86180,7 +86206,7 @@ var init_device_name = __esm({
 });
 
 // apps/desktop/src/daemon/debug-log.ts
-import path61 from "node:path";
+import path62 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);
 }
@@ -86219,10 +86245,10 @@ function hasDebugFilter(filter) {
   return Boolean(filter?.components || filter?.channels || filter?.events);
 }
 function createSafeFilePath(runtimeDir, files) {
-  const dir = path61.join(runtimeDir, "debug");
+  const dir = path62.join(runtimeDir, "debug");
   files.ensureDirectory(dir);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return path61.join(dir, `${timestamp}-${process.pid}.ndjson`);
+  return path62.join(dir, `${timestamp}-${process.pid}.ndjson`);
 }
 function createFileDebugLogger(filePath, shouldWrite, files) {
   let writer;
@@ -86828,7 +86854,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(
-    path61.join(runtimeDir, "debug"),
+    path62.join(runtimeDir, "debug"),
     now,
     policy.maxSegmentBytes ?? RAW_DEBUG_MAX_SEGMENT_BYTES,
     policy.maxSegments ?? RAW_DEBUG_MAX_SEGMENTS,
@@ -87839,7 +87865,7 @@ var init_debug_log = __esm({
         }
         const timestamp = this.now().toISOString().replace(/[:.]/g, "-");
         for (; ; ) {
-          const filePath = path61.join(this.directory, `${timestamp}-${process.pid}-raw-${this.sequence++}.ndjson`);
+          const filePath = path62.join(this.directory, `${timestamp}-${process.pid}-raw-${this.sequence++}.ndjson`);
           try {
             return this.files.create(filePath);
           } catch (error2) {
@@ -87872,7 +87898,7 @@ var init_debug_log = __esm({
 });
 
 // apps/desktop/src/daemon/control-observability.ts
-import path62 from "node:path";
+import path63 from "node:path";
 function isRecentControlTimestamp(timestampMs, nowMs) {
   return timestampMs <= nowMs && isRetainedDaemonLogTimestamp(timestampMs, nowMs);
 }
@@ -87905,7 +87931,7 @@ function page3(values, params) {
   };
 }
 function listControlLogs(input) {
-  const directoryPath = path62.join(input.runtimeDir, input.kind === "error" ? "errors" : "debug");
+  const directoryPath = path63.join(input.runtimeDir, input.kind === "error" ? "errors" : "debug");
   const values = [];
   let totalBytes = 0;
   let processedLines = 0;
@@ -88928,7 +88954,7 @@ var init_composition = __esm({
         refreshFallback: async (id5, token3) => {
           await this.historySnapshot.tryRefreshThreadMessages(id5, false, { kind: "fallback", token: token3 });
         },
-        resolveKnownLocalImage: (id5, path70, itemId, partIndex) => this.images.resolveKnownLocalImage(id5, path70, itemId, partIndex),
+        resolveKnownLocalImage: (id5, path71, itemId, partIndex) => this.images.resolveKnownLocalImage(id5, path71, itemId, partIndex),
         hasDesktopSnapshot: (id5) => this.controlAccess.snapshot(id5).hasCurrentDesktopSnapshot,
         followerPhase: (id5) => this.followerCoordination.activeThreadFollowerCoordinatorValue?.phaseFor(id5) ?? null,
         generation: () => this.lifecycle.runtimeGenerationValue
@@ -90524,7 +90550,7 @@ var init_runtime2 = __esm({
 
 // apps/desktop/src/daemon/follower-open-trace.ts
 import { randomUUID as randomUUID56 } from "node:crypto";
-import path63 from "node:path";
+import path64 from "node:path";
 function isFiniteTimestamp2(value) {
   return typeof value === "number" && Number.isFinite(value) && Number.isSafeInteger(value);
 }
@@ -90662,7 +90688,7 @@ function parseRecord2(line) {
 function listPrivateTraceFiles(runtimeDir, storage) {
   try {
     storage.checkDirectory(runtimeDir);
-    const scan = storage.scan(path63.join(runtimeDir, TRACE_DIRECTORY_NAME), MAX_DIRECTORY_ENTRIES3);
+    const scan = storage.scan(path64.join(runtimeDir, TRACE_DIRECTORY_NAME), MAX_DIRECTORY_ENTRIES3);
     const files = [];
     let incomplete = scan.truncated;
     for (const entry of scan.entries) {
@@ -90676,8 +90702,8 @@ function listPrivateTraceFiles(runtimeDir, storage) {
   }
 }
 function compareTraceFilePaths(left, right) {
-  const a = path63.basename(left);
-  const b = path63.basename(right);
+  const a = path64.basename(left);
+  const b = path64.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) {
@@ -91194,7 +91220,7 @@ var init_follower_open_trace = __esm({
       }
       clearAll() {
         try {
-          const directoryPath = path63.join(this.runtimeDir, TRACE_DIRECTORY_NAME);
+          const directoryPath = path64.join(this.runtimeDir, TRACE_DIRECTORY_NAME);
           this.files.checkDirectory(this.runtimeDir);
           let scan;
           try {
@@ -91251,7 +91277,7 @@ var init_follower_open_trace = __esm({
         }
       }
       append(record26) {
-        const directoryPath = path63.join(this.runtimeDir, TRACE_DIRECTORY_NAME);
+        const directoryPath = path64.join(this.runtimeDir, TRACE_DIRECTORY_NAME);
         this.ensureTraceDirectory(directoryPath);
         const content2 = `${JSON.stringify(record26)}
 `;
@@ -91261,8 +91287,8 @@ var init_follower_open_trace = __esm({
       selectAppendFile(directoryPath, dateName, bytes3) {
         const date = dateName.slice(0, 10);
         let filePath = this.appendFilePath;
-        if (!filePath || path63.basename(filePath).slice(0, 10) !== date) {
-          filePath = listPrivateTraceFiles(this.runtimeDir, this.files).files.find((candidate) => candidate.name.slice(0, 10) === date)?.path ?? path63.join(directoryPath, dateName);
+        if (!filePath || path64.basename(filePath).slice(0, 10) !== date) {
+          filePath = listPrivateTraceFiles(this.runtimeDir, this.files).files.find((candidate) => candidate.name.slice(0, 10) === date)?.path ?? path64.join(directoryPath, dateName);
         }
         for (let attempt = 0; attempt < MAX_DIRECTORY_ENTRIES3; attempt += 1) {
           let stats;
@@ -91275,9 +91301,9 @@ var init_follower_open_trace = __esm({
             this.appendFilePath = filePath;
             return filePath;
           }
-          const next = Number(path63.basename(filePath).slice(11, -7)) + 1;
+          const next = Number(path64.basename(filePath).slice(11, -7)) + 1;
           if (next > 999999) break;
-          filePath = path63.join(directoryPath, `${date}.${String(next).padStart(6, "0")}.ndjson`);
+          filePath = path64.join(directoryPath, `${date}.${String(next).padStart(6, "0")}.ndjson`);
         }
         throw new Error("trace segment limit reached");
       }
@@ -92652,7 +92678,7 @@ var init_watch = __esm({
 });
 
 // apps/desktop/src/relay/relay-origin-store.ts
-import path64 from "node:path";
+import path65 from "node:path";
 function parseStoredOrigin(value) {
   try {
     const document = JSON.parse(value);
@@ -92666,7 +92692,7 @@ function parseStoredOrigin(value) {
   }
 }
 function resolveDefaultRelayOriginStorePath() {
-  return path64.join(desktopPlatform().directories.data, DEFAULT_FILE_NAME2);
+  return path65.join(desktopPlatform().directories.data, DEFAULT_FILE_NAME2);
 }
 var DEFAULT_FILE_NAME2, MAX_FILE_BYTES3, FileRelayOriginStore;
 var init_relay_origin_store = __esm({
@@ -92682,7 +92708,7 @@ var init_relay_origin_store = __esm({
       files;
       tail = Promise.resolve();
       constructor(options = {}) {
-        this.filePath = path64.resolve(options.file_path ?? resolveDefaultRelayOriginStorePath());
+        this.filePath = path65.resolve(options.file_path ?? resolveDefaultRelayOriginStorePath());
         this.files = options.files ?? privateDocumentFiles;
       }
       async load() {
@@ -92718,7 +92744,7 @@ var init_relay_origin_store = __esm({
 });
 
 // apps/desktop/src/cli/commands/daemon.ts
-import path65 from "node:path";
+import path66 from "node:path";
 function daemonStartFailed3() {
   return new NiumaError("DAEMON_START_FAILED", "niuma daemon \u542F\u52A8\u5931\u8D25");
 }
@@ -92911,7 +92937,7 @@ async function runDaemonCommand(args, options = {}) {
           loggers.rawDebugLogger?.path,
           loggers.errorLogger?.path,
           // 后台 worker 的 stdout/stderr descriptor 无法安全重开，只按 daemon 所有权保护固定路径。
-          ...options.mode === "background" ? [path65.join(runtimeDir, "daemon-worker.log")] : []
+          ...options.mode === "background" ? [path66.join(runtimeDir, "daemon-worker.log")] : []
         ].filter((filePath) => typeof filePath === "string")
       });
     } catch {
@@ -93401,7 +93427,7 @@ var init_auth2 = __esm({
 });
 
 // apps/desktop/src/control/routes.ts
-import fs40 from "node:fs";
+import fs41 from "node:fs";
 function daemonStoppedOverview() {
   return {
     daemon: { state: "stopped" },
@@ -93420,12 +93446,12 @@ function emptyControlPage(page4, pageSize) {
 }
 function isDaemonRuntimeActive(socketPath = daemonSocketPath(), statusPath = daemonStatusPath()) {
   try {
-    const socket = fs40.lstatSync(socketPath);
-    const status2 = fs40.lstatSync(statusPath);
+    const socket = fs41.lstatSync(socketPath);
+    const status2 = fs41.lstatSync(statusPath);
     if (!socket.isSocket() || !status2.isFile() || status2.isSymbolicLink() || status2.size > 4 * 1024) {
       return false;
     }
-    const parsed = JSON.parse(fs40.readFileSync(statusPath, "utf8"));
+    const parsed = JSON.parse(fs41.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;
@@ -94978,8 +95004,8 @@ var init_lifecycle3 = __esm({
 
 // apps/desktop/src/control/server.ts
 import http4 from "node:http";
-import fs41 from "node:fs";
-import path66 from "node:path";
+import fs42 from "node:fs";
+import path67 from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 function isControlApiPath(pathname) {
   const [, api, version2, control] = pathname.split("/", 4);
@@ -95025,15 +95051,15 @@ function requestHasBody(request2) {
   return Number(contentLength) !== 0;
 }
 function resolveExactControlWritePath(requestTarget) {
-  for (const path70 of [CONTROL_DEVICE_REVOKE_PATH, CONTROL_DAEMON_ACTION_PATH, CONTROL_TRACE_CLEAR_PATH]) {
-    if (requestTarget === path70 || requestTarget.startsWith(`${path70}?`) && !requestTarget.includes("#")) return path70;
+  for (const path71 of [CONTROL_DEVICE_REVOKE_PATH, CONTROL_DAEMON_ACTION_PATH, CONTROL_TRACE_CLEAR_PATH]) {
+    if (requestTarget === path71 || requestTarget.startsWith(`${path71}?`) && !requestTarget.includes("#")) return path71;
   }
   return null;
 }
 function resolveExactControlTraceReadPath(requestTarget) {
-  for (const path70 of [CONTROL_TRACE_LIST_PATH, CONTROL_TRACE_DETAIL_PATH]) {
-    if (requestTarget === path70 || requestTarget.startsWith(`${path70}?`) && !requestTarget.includes("#")) {
-      return path70;
+  for (const path71 of [CONTROL_TRACE_LIST_PATH, CONTROL_TRACE_DETAIL_PATH]) {
+    if (requestTarget === path71 || requestTarget.startsWith(`${path71}?`) && !requestTarget.includes("#")) {
+      return path71;
     }
   }
   return null;
@@ -95054,9 +95080,9 @@ var init_server5 = __esm({
     init_lifecycle3();
     require2 = createRequire2(import.meta.url);
     CONTROL_PAGE_PATHS = ["/", "/connections", "/sessions", "/subscriptions", "/turn-audit", "/logs"];
-    CONTROL_INDEX = fs41.readFileSync(desktopAssetUrl("control", "index.html"));
-    BOOTSTRAP_CSS = fs41.readFileSync(require2.resolve("bootstrap/dist/css/bootstrap.min.css"));
-    BOOTSTRAP_BUNDLE = fs41.readFileSync(require2.resolve("bootstrap/dist/js/bootstrap.bundle.min.js"));
+    CONTROL_INDEX = fs42.readFileSync(desktopAssetUrl("control", "index.html"));
+    BOOTSTRAP_CSS = fs42.readFileSync(require2.resolve("bootstrap/dist/css/bootstrap.min.css"));
+    BOOTSTRAP_BUNDLE = fs42.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",
@@ -95064,11 +95090,11 @@ var init_server5 = __esm({
       }])),
       "/app.js": {
         contentType: "application/javascript; charset=utf-8",
-        body: fs41.readFileSync(desktopAssetUrl("control", "app.js"))
+        body: fs42.readFileSync(desktopAssetUrl("control", "app.js"))
       },
       "/chart.umd.js": {
         contentType: "application/javascript; charset=utf-8",
-        body: fs41.readFileSync(path66.join(path66.dirname(require2.resolve("chart.js")), "chart.umd.js"))
+        body: fs42.readFileSync(path67.join(path67.dirname(require2.resolve("chart.js")), "chart.umd.js"))
       },
       "/bootstrap.min.css": {
         contentType: "text/css; charset=utf-8",
@@ -95284,41 +95310,41 @@ var init_server5 = __esm({
 
 // apps/desktop/src/control/state.ts
 import { createHash as createHash44, randomUUID as randomUUID60 } from "node:crypto";
-import fs42 from "node:fs";
-import path67 from "node:path";
+import fs43 from "node:fs";
+import path68 from "node:path";
 function createControlState(input) {
   return createControlStateUnlocked(input);
 }
 function createControlStateUnlocked(input) {
   const state = toControlState(input);
   const statePath = controlStatePath(input.runtimeDir);
-  const temporaryPath = path67.join(
-    path67.dirname(statePath),
-    `.${path67.basename(statePath)}.${randomUUID60()}.tmp`
+  const temporaryPath = path68.join(
+    path68.dirname(statePath),
+    `.${path68.basename(statePath)}.${randomUUID60()}.tmp`
   );
   let descriptor = null;
   let temporaryIdentity = null;
   let published = null;
   let operationError;
   try {
-    descriptor = fs42.openSync(temporaryPath, "wx", 384);
-    if (process.platform !== "win32") fs42.fchmodSync(descriptor, 384);
-    const stats = fs42.fstatSync(descriptor, { bigint: true });
+    descriptor = fs43.openSync(temporaryPath, "wx", 384);
+    if (process.platform !== "win32") fs43.fchmodSync(descriptor, 384);
+    const stats = fs43.fstatSync(descriptor, { bigint: true });
     assertRegularControlStateDescriptor(stats);
     temporaryIdentity = identityFromStats(stats);
-    fs42.writeFileSync(descriptor, `${JSON.stringify(state)}
+    fs43.writeFileSync(descriptor, `${JSON.stringify(state)}
 `, "utf8");
-    fs42.fsyncSync(descriptor);
-    fs42.closeSync(descriptor);
+    fs43.fsyncSync(descriptor);
+    fs43.closeSync(descriptor);
     descriptor = null;
-    fs42.linkSync(temporaryPath, statePath);
+    fs43.linkSync(temporaryPath, statePath);
     published = persistedControlState(state, statePath, identityFromStats(stats), "canonical");
   } catch (error2) {
     operationError = error2;
   } finally {
     if (descriptor !== null) {
       try {
-        fs42.closeSync(descriptor);
+        fs43.closeSync(descriptor);
       } catch (error2) {
         operationError ??= error2;
       }
@@ -95341,7 +95367,7 @@ function createControlStateUnlocked(input) {
   return published;
 }
 function cleanupControlStateArtifactsForOwnedListener(runtimeDir) {
-  const stateBasename = path67.basename(controlStatePath(runtimeDir));
+  const stateBasename = path68.basename(controlStatePath(runtimeDir));
   const artifactPattern = new RegExp(
     `^\\.${escapeRegExp(stateBasename)}(?:\\.coordination\\.lock)?\\.[0-9a-f-]+\\.(?:tmp|snapshot)$`,
     "u"
@@ -95349,19 +95375,19 @@ function cleanupControlStateArtifactsForOwnedListener(runtimeDir) {
   let removed = 0;
   let entries;
   try {
-    entries = fs42.readdirSync(runtimeDir);
+    entries = fs43.readdirSync(runtimeDir);
   } catch {
     return 0;
   }
   for (const entry of entries) {
     if (entry !== `${stateBasename}.coordination.lock` && !artifactPattern.test(entry)) continue;
-    const artifactPath = path67.join(runtimeDir, entry);
+    const artifactPath = path68.join(runtimeDir, entry);
     try {
-      const stats = fs42.lstatSync(artifactPath, { bigint: true });
+      const stats = fs43.lstatSync(artifactPath, { bigint: true });
       if (!stats.isFile() || stats.isSymbolicLink() || process.platform !== "win32" && (stats.mode & 0o777n) !== 0o600n) {
         continue;
       }
-      fs42.unlinkSync(artifactPath);
+      fs43.unlinkSync(artifactPath);
       removed += 1;
     } catch {
     }
@@ -95399,7 +95425,7 @@ function removeControlStateUnlocked(input) {
   if (input.expected.path !== statePath) return false;
   const snapshotPath = stateSnapshotPath(statePath);
   try {
-    fs42.linkSync(statePath, snapshotPath);
+    fs43.linkSync(statePath, snapshotPath);
   } catch (error2) {
     if (error2.code === "ENOENT") return false;
     return false;
@@ -95418,7 +95444,7 @@ function removeControlStateUnlocked(input) {
       return false;
     }
     if (!canonicalMatchesSnapshot(statePath, snapshotPath, snapshot2)) return false;
-    fs42.unlinkSync(statePath);
+    fs43.unlinkSync(statePath);
     canonicalRemoved = true;
     return true;
   } catch {
@@ -95436,7 +95462,7 @@ function removeControlStateUnlocked(input) {
 function readControlStateAtPath(filePath, logicalPath) {
   const descriptor = openControlStateForRead(filePath);
   try {
-    const stats = fs42.fstatSync(descriptor, { bigint: true });
+    const stats = fs43.fstatSync(descriptor, { bigint: true });
     assertRegularControlStateDescriptor(stats);
     assertPrivateControlStateMode(stats);
     if (stats.size > BigInt(CONTROL_STATE_MAX_BYTES)) {
@@ -95451,14 +95477,14 @@ function readControlStateAtPath(filePath, logicalPath) {
       throw new CorruptControlStateError(logicalPath, identity6, contents);
     }
   } finally {
-    fs42.closeSync(descriptor);
+    fs43.closeSync(descriptor);
   }
 }
 function readBoundedControlState(descriptor) {
   const buffer = Buffer.alloc(CONTROL_STATE_MAX_BYTES + 1);
   let bytesRead = 0;
   while (bytesRead < buffer.length) {
-    const count = fs42.readSync(
+    const count = fs43.readSync(
       descriptor,
       buffer,
       bytesRead,
@@ -95477,12 +95503,12 @@ function removeCorruptControlState(error2) {
   const snapshotPath = stateSnapshotPath(error2.statePath);
   let canonicalRemoved = false;
   try {
-    fs42.linkSync(error2.statePath, snapshotPath);
+    fs43.linkSync(error2.statePath, snapshotPath);
   } catch {
     return false;
   }
   try {
-    const snapshotStats = fs42.lstatSync(snapshotPath, { bigint: true });
+    const snapshotStats = fs43.lstatSync(snapshotPath, { bigint: true });
     if (!snapshotStats.isFile()) return false;
     const snapshotIdentity = identityFromStats(snapshotStats);
     if (hasUsableInode(error2.fileIdentity) && hasUsableInode(snapshotIdentity) && !sameIdentity(error2.fileIdentity, snapshotIdentity)) {
@@ -95493,7 +95519,7 @@ function removeCorruptControlState(error2) {
       if (fingerprint(snapshot2) !== error2.fingerprint) return false;
     }
     if (!canonicalMatchesSnapshotByIdentity(error2.statePath, snapshotPath)) return false;
-    fs42.unlinkSync(error2.statePath);
+    fs43.unlinkSync(error2.statePath);
     canonicalRemoved = true;
     return true;
   } catch {
@@ -95509,7 +95535,7 @@ function removeCorruptControlState(error2) {
 function readRawControlState(filePath) {
   const descriptor = openControlStateForRead(filePath);
   try {
-    const stats = fs42.fstatSync(descriptor, { bigint: true });
+    const stats = fs43.fstatSync(descriptor, { bigint: true });
     assertRegularControlStateDescriptor(stats);
     assertPrivateControlStateMode(stats);
     if (stats.size > BigInt(CONTROL_STATE_MAX_BYTES)) {
@@ -95517,13 +95543,13 @@ function readRawControlState(filePath) {
     }
     return readBoundedControlState(descriptor);
   } finally {
-    fs42.closeSync(descriptor);
+    fs43.closeSync(descriptor);
   }
 }
 function canonicalMatchesSnapshot(statePath, snapshotPath, snapshot2) {
   if (!canonicalMatchesSnapshotByIdentity(statePath, snapshotPath)) return false;
-  const canonicalStats = fs42.lstatSync(statePath, { bigint: true });
-  const snapshotStats = fs42.lstatSync(snapshotPath, { bigint: true });
+  const canonicalStats = fs43.lstatSync(statePath, { bigint: true });
+  const snapshotStats = fs43.lstatSync(snapshotPath, { bigint: true });
   if (hasUsableInode(identityFromStats(canonicalStats)) && hasUsableInode(identityFromStats(snapshotStats))) {
     return true;
   }
@@ -95531,8 +95557,8 @@ function canonicalMatchesSnapshot(statePath, snapshotPath, snapshot2) {
   return current2.pid === snapshot2.pid && current2.ownershipSecret === snapshot2.ownershipSecret;
 }
 function canonicalMatchesSnapshotByIdentity(statePath, snapshotPath) {
-  const canonicalStats = fs42.lstatSync(statePath, { bigint: true });
-  const snapshotStats = fs42.lstatSync(snapshotPath, { bigint: true });
+  const canonicalStats = fs43.lstatSync(statePath, { bigint: true });
+  const snapshotStats = fs43.lstatSync(snapshotPath, { bigint: true });
   if (!canonicalStats.isFile() || !snapshotStats.isFile()) return false;
   const canonicalIdentity = identityFromStats(canonicalStats);
   const snapshotIdentity = identityFromStats(snapshotStats);
@@ -95563,9 +95589,9 @@ function sameIdentity(left, right) {
   return left.device === right.device && left.inode === right.inode;
 }
 function stateSnapshotPath(statePath) {
-  return path67.join(
-    path67.dirname(statePath),
-    `.${path67.basename(statePath)}.${randomUUID60()}.snapshot`
+  return path68.join(
+    path68.dirname(statePath),
+    `.${path68.basename(statePath)}.${randomUUID60()}.snapshot`
   );
 }
 function fingerprint(contents) {
@@ -95576,7 +95602,7 @@ function escapeRegExp(value) {
 }
 function unlinkControlStateTemporary(temporaryPath) {
   try {
-    fs42.unlinkSync(temporaryPath);
+    fs43.unlinkSync(temporaryPath);
     return void 0;
   } catch (error2) {
     return error2.code === "ENOENT" ? void 0 : error2;
@@ -95588,28 +95614,28 @@ function eraseControlStateTemporary(temporaryPath, expectedIdentity) {
   try {
     let beforeIdentity = null;
     if (process.platform === "win32") {
-      const before = fs42.lstatSync(temporaryPath, { bigint: true });
+      const before = fs43.lstatSync(temporaryPath, { bigint: true });
       beforeIdentity = identityFromStats(before);
       if (!before.isFile() || before.isSymbolicLink() || !hasUsableInode(beforeIdentity) || !sameIdentity(beforeIdentity, expectedIdentity)) return;
     }
-    const noFollow = process.platform === "win32" ? 0 : fs42.constants.O_NOFOLLOW;
+    const noFollow = process.platform === "win32" ? 0 : fs43.constants.O_NOFOLLOW;
     if (process.platform !== "win32" && (!noFollow || typeof noFollow !== "number")) return;
-    descriptor = fs42.openSync(temporaryPath, fs42.constants.O_RDWR | noFollow);
-    const stats = fs42.fstatSync(descriptor, { bigint: true });
+    descriptor = fs43.openSync(temporaryPath, fs43.constants.O_RDWR | noFollow);
+    const stats = fs43.fstatSync(descriptor, { bigint: true });
     const identity6 = identityFromStats(stats);
     if (!stats.isFile() || !hasUsableInode(identity6) || !sameIdentity(identity6, expectedIdentity)) return;
     if (process.platform === "win32") {
-      const after = fs42.lstatSync(temporaryPath, { bigint: true });
+      const after = fs43.lstatSync(temporaryPath, { bigint: true });
       const afterIdentity = identityFromStats(after);
       if (!after.isFile() || after.isSymbolicLink() || !beforeIdentity || !hasUsableInode(afterIdentity) || !sameIdentity(beforeIdentity, identity6) || !sameIdentity(identity6, afterIdentity)) return;
     }
-    fs42.ftruncateSync(descriptor, 0);
-    fs42.fsyncSync(descriptor);
+    fs43.ftruncateSync(descriptor, 0);
+    fs43.fsyncSync(descriptor);
   } catch {
   } finally {
     if (descriptor !== null) {
       try {
-        fs42.closeSync(descriptor);
+        fs43.closeSync(descriptor);
       } catch {
       }
     }
@@ -95656,16 +95682,16 @@ function parseControlState(value) {
 }
 function openControlStateForRead(statePath) {
   if (process.platform === "win32") return openControlStateForReadOnWindows(statePath);
-  const noFollow = fs42.constants.O_NOFOLLOW;
+  const noFollow = fs43.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 = fs42.constants.O_NONBLOCK;
+  const nonBlock = fs43.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 fs42.openSync(statePath, fs42.constants.O_RDONLY | noFollow | nonBlock);
+    return fs43.openSync(statePath, fs43.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");
@@ -95674,14 +95700,14 @@ function openControlStateForRead(statePath) {
   }
 }
 function openControlStateForReadOnWindows(statePath) {
-  const before = fs42.lstatSync(statePath, { bigint: true });
+  const before = fs43.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 = fs42.openSync(statePath, fs42.constants.O_RDONLY);
+  const descriptor = fs43.openSync(statePath, fs43.constants.O_RDONLY);
   try {
-    const opened = fs42.fstatSync(descriptor, { bigint: true });
-    const after = fs42.lstatSync(statePath, { bigint: true });
+    const opened = fs43.fstatSync(descriptor, { bigint: true });
+    const after = fs43.lstatSync(statePath, { bigint: true });
     const beforeIdentity = identityFromStats(before);
     const openedIdentity = identityFromStats(opened);
     const afterIdentity = identityFromStats(after);
@@ -95690,7 +95716,7 @@ function openControlStateForReadOnWindows(statePath) {
     }
     return descriptor;
   } catch (error2) {
-    fs42.closeSync(descriptor);
+    fs43.closeSync(descriptor);
     throw error2;
   }
 }
@@ -96132,9 +96158,9 @@ var init_direct2 = __esm({
 });
 
 // apps/desktop/src/cli/commands/events.ts
-import path68 from "node:path";
+import path69 from "node:path";
 function normalizedProjectRoot(value) {
-  return typeof value === "string" && value.length > 0 ? path68.resolve(value) : null;
+  return typeof value === "string" && value.length > 0 ? path69.resolve(value) : null;
 }
 function toOutputEvent(event) {
   if (event.ok === true && typeof event.schemaVersion === "number") {
@@ -96518,7 +96544,7 @@ var init_state2 = __esm({
 });
 
 // apps/desktop/src/cli/commands/threads.ts
-import path69 from "node:path";
+import path70 from "node:path";
 function readPositiveInteger2(value, name2, fallback) {
   if (value === void 0) {
     return fallback;
@@ -96536,7 +96562,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 ? path69.resolve(args.flags.project) : null;
+  const projectRoot = typeof args.flags.project === "string" && args.flags.project.length > 0 ? path70.resolve(args.flags.project) : null;
   const daemon = options.daemonClient ?? new DaemonClient(options.socketPath);
   const result = await daemon.request("threads/list", {
     pageSize,